From 16aa7ef2f09142ce660fa09f3e6d5c501d2c67e0 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 09:50:07 -0400 Subject: [PATCH 01/90] =?UTF-8?q?wave6:=20retire=20dead=20ctor=20entries?= =?UTF-8?q?=20(ALLOWLIST=5FDISCIPLINE=20=C2=A7495,=20shared-diff=20fold)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The shared signature diff now EXCLUDES a `__init__` member whenever the reference publishes a `construction` entry for that class (porting-sdk `_is_folded_dunder_member`, ALLOWLIST_DISCIPLINE.md §495: "ctor / dunder → EMISSION (exclude); never a surface capability difference"). §10's construction node already compares the same capability BY PARAMETER NAME instead of by position, which is the comparison that is actually meaningful for a Ruby keyword constructor held against Python's positional-with-default. That makes 30 of this port's 133 PORT_SIGNATURE_OMISSIONS entries dead weight — entries the diff no longer consults. Deleted: * 22 `signalwire.relay.event.*Event.__init__` base-spread entries (the whole "Ruby **base spread" section, now empty and removed); * ReceptionistAgent / SurveyAgent `**_opts` forwarding; * GatherInfo / GatherQuestion / RestClient / PromptObjectModel / BedrockAgent keyword-constructor entries. Category 4 of the header ("Ruby `**base` event spread") is replaced by a note stating the fold, so the next reader does not re-add what the diff now folds. 3 `__init__` entries stay LIVE and are deliberately NOT touched — their classes have no `construction` entry in the reference, so the member comparison is the only comparison there is: signalwire.skills.api_ninjas_trivia.skill.ApiNinjasTriviaSkill.__init__ signalwire.skills.play_background_file.skill.PlayBackgroundFileSkill.__init__ signalwire.skills.weather_api.skill.WeatherApiSkill.__init__ Ledger 133 -> 103 entries. Construction node unchanged: 147 classes / 498 params, byte-identical to HEAD. Deletion only — no source change, no new allowlist/omission entry, PORT_OMISSIONS.md and PORT_ADDITIONS.md untouched. Merge order: porting-sdk #125 FIRST. Until it merges (or PORTING_SDK_REF is pinned), this PR's CI is red BY DESIGN — the fold and the prune are mutually dependent. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01GFKJhLvfV8yGrASwqxdgaf --- PORT_SIGNATURE_OMISSIONS.md | 45 +++++++------------------------------ 1 file changed, 8 insertions(+), 37 deletions(-) diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 20750298..33860995 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -79,10 +79,14 @@ PORT_ADDITIONS.md and are inherited automatically by the signature diff. instead of the full Python parameter list. Tracked here as Ruby idiom matching the TypeScript port's BACKLOG entries. -4. **Ruby `**base` event spread** — Subclassed event `__init__` methods - take their subclass-specific keyword args plus `**base` to forward to - `super(**base)`. Python flattens the constructor inheritance into a - single explicit signature; Ruby keeps base-class params under `**base`. +Constructors (`__init__` as a member) are NOT excused here: per +ALLOWLIST_DISCIPLINE.md §495 the shared signature diff EXCLUDES a `__init__` +member whenever the reference publishes a `construction` entry for that class, +because the §10 construction node already compares the same capability BY +PARAMETER NAME instead of by position. The Ruby keyword-constructor idiom and +the event-subclass `**base` spread therefore need no ledger entries at all. +A `__init__` on a class the construction node does NOT cover keeps its member +finding and stays listed below. # Ruby keyword-argument idiom (Python positional with default ≡ Ruby keyword arg) @@ -94,14 +98,11 @@ signalwire.core.mixins.ai_config_mixin.AIConfigMixin.add_language: kwargs-idiom signalwire.core.mixins.ai_config_mixin.AIConfigMixin.add_pattern_hint: kwargs-idiom — Ruby splats positional args plus optional keyword `ignore_case:`; ≡ Python `(hint, pattern, replace, ignore_case=False)` signalwire.core.mixins.web_mixin.WebMixin.on_swml_request: kwargs-idiom — Ruby third positional optional + `request:` keyword ≡ Python `on_swml_request(request_data, callback_path, request)` signalwire.core.agent_base.AgentBase.on_debug_event: kwargs-idiom — Ruby `handler:` keyword ≡ Python positional with default -signalwire.core.contexts.GatherInfo.__init__: kwargs-idiom — Ruby `(output_key:, completion_action:, prompt:, isolated:)` ≡ Python positional with default -signalwire.core.contexts.GatherQuestion.__init__: kwargs-idiom — Ruby keyword constructor ≡ Python positional with default signalwire.core.contexts.Step.set_gather_info: kwargs-idiom — Ruby keyword args ≡ Python positional with default signalwire.core.data_map.DataMap.parameter: kwargs-idiom — Ruby `(required:, enum:)` keyword ≡ Python positional with default signalwire.core.swml_service.SWMLService.register_routing_callback: kwargs-idiom — Ruby keyword args ≡ Python positional with default signalwire.relay.client.RelayClient.on_call: kwargs-idiom — Ruby keyword args ≡ Python positional with default signalwire.relay.client.RelayClient.on_message: kwargs-idiom — Ruby keyword args ≡ Python positional with default -signalwire.rest.client.RestClient.__init__: kwargs-idiom — Ruby keyword constructor ≡ Python positional with default # from_payload classmethod — Ruby static method has no explicit cls receiver @@ -131,34 +132,6 @@ signalwire.relay.call.Call.send_digits: kwargs-collapse — Ruby includes option signalwire.relay.call.Call.send_fax: kwargs-collapse — Ruby keeps required args explicit, optionals collapse into **kwargs signalwire.relay.call.Call.stream: kwargs-collapse — Ruby keeps required args explicit, optionals collapse into **kwargs signalwire.relay.call.Call.transcribe: kwargs-collapse — Ruby keeps required args explicit, optionals collapse into **kwargs -signalwire.prefabs.receptionist.ReceptionistAgent.__init__: kwargs-collapse — Ruby `**_opts` forwards extra kwargs to AgentBase super -signalwire.prefabs.survey.SurveyAgent.__init__: kwargs-collapse — Ruby `**_opts` forwards extra kwargs to AgentBase super - -# Ruby **base spread — event subclass __init__ takes its own keyword args plus **base for super - -signalwire.relay.event.CallReceiveEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super; Python flattens inheritance -signalwire.relay.event.CallStateEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.CallingErrorEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.CollectEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.ConferenceEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.ConnectEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.DenoiseEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.DetectEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.DialEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.EchoEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.FaxEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.HoldEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.MessageReceiveEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.MessageStateEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.PayEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.PlayEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.QueueEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.RecordEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.ReferEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.SendDigitsEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.StreamEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.TapEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super -signalwire.relay.event.TranscribeEvent.__init__: base-spread — Ruby keyword args + `**base` forwarded to super # Single-case: kind 'keyword' vs 'var_keyword' (RelayClient.dial) @@ -166,7 +139,6 @@ signalwire.relay.client.RelayClient.dial: kwargs-spread — Ruby `dial_timeout:` # Prompt Object Model — Ruby keyword-arg idiom -signalwire.pom.pom.PromptObjectModel.__init__: Ruby keyword-arg idiom — `debug:` defaults are keyword in Ruby, positional with default in Python signalwire.pom.pom.PromptObjectModel.to_json: Ruby JSON convention — `to_json(*_args)` accepts the optional state argument that Ruby's JSON.generate forwards signalwire.pom.pom.Section.render_markdown: Ruby keyword-arg idiom — `level:` and `section_number:` are keyword in Ruby, positional with default in Python signalwire.pom.pom.Section.render_xml: Ruby keyword-arg idiom — `indent:` and `section_number:` are keyword in Ruby, positional with default in Python @@ -206,7 +178,6 @@ signalwire.core.swml_service.SWMLService.security: Ruby SWMLService keeps securi signalwire.web.web_service.WebService.app: Ruby WebService wraps a Rack app via `rack_app`; Python exposes a Flask `.app` attribute — no direct equivalent (matches AgentServer.app / PORT_OMISSIONS) # --- Reference signature-oracle gaps (reference surface HAS the symbol) --- -signalwire.agents.bedrock.BedrockAgent.__init__: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) signalwire.agents.bedrock.BedrockAgent.set_inference_params: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) signalwire.agents.bedrock.BedrockAgent.set_llm_model: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) signalwire.agents.bedrock.BedrockAgent.set_llm_temperature: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) From 9dbbd2524244b97c1c466de2512175be549592aa Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 12:37:40 -0400 Subject: [PATCH 02/90] derived-attr parity: expose SWMLService TLS config + SpiderSkill remove_xpaths MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The signature oracle now records 7 derived public __init__ attributes. Ruby already carried 2 of them (SignalWireRestError#request_id, Action#completed); this closes the remaining 5. SWML::Service — @ssl_enabled / @ssl_cert_path / @ssl_key_path / @domain were already derived in #init_ssl_config (from the SWML_SSL_* + SWML_DOMAIN env vars) and overridden by the matching #serve kwargs, but were write-only state. Added to the existing attr_reader so a caller can inspect the effective TLS posture without re-deriving it from the environment. SpiderSkill#remove_xpaths — new prefilled list of the boilerplate elements dropped before text extraction. #strip_html previously hardcoded regexes for script/style only; it is now driven by the list, so nav/header/footer/aside/ noscript are dropped with their content (they were flattened to their inner text before) and the list is a real per-instance knob rather than a decorative accessor. Only the simple //tag form is compiled — Ruby ships no HTML tree parser, so a more expressive expression is skipped rather than mis-applied. Signature drift 27 -> 22; the 22 remaining are the pre-existing RestClient. accessor drift from a separate task. Tests: 3 TLS-config readback cases (defaults / env-derived / serve override, no certs required) + 4 spider cases (prefilled list, full-subtree drop, mutated list honoured, non-simple xpath skipped). Full suite 2656 runs, 0 failures, 0 errors, 0 skips. FMT + LINT clean. --- lib/signalwire/skills/builtin/spider.rb | 37 +++++++++++++++--- lib/signalwire/swml/service.rb | 9 ++++- port_signatures.json | 45 ++++++++++++++++++++++ tests/skills/spider_skill_test.rb | 37 ++++++++++++++++++ tests/tls/tls_https_server_test.rb | 50 +++++++++++++++++++++++++ 5 files changed, 172 insertions(+), 6 deletions(-) diff --git a/lib/signalwire/skills/builtin/spider.rb b/lib/signalwire/skills/builtin/spider.rb index 79d42150..c54a086a 100644 --- a/lib/signalwire/skills/builtin/spider.rb +++ b/lib/signalwire/skills/builtin/spider.rb @@ -17,6 +17,26 @@ def supports_multiple_instances? = true # Default user-agent. DEFAULT_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' + # Elements whose *entire subtree* is dropped before text extraction — + # boilerplate that would otherwise pollute the extracted text. Spelled + # as XPath expressions to match the reference; {#strip_html} compiles + # each to the equivalent tag-with-content regex (Ruby has no bundled + # HTML tree parser, so there is no lxml-style +drop_tree+ to call). + DEFAULT_REMOVE_XPATHS = [ + '//script', + '//style', + '//nav', + '//header', + '//footer', + '//aside', + '//noscript' + ].freeze + + # XPath expressions for the unwanted elements dropped by {#strip_html}. + # Prefilled with {DEFAULT_REMOVE_XPATHS}; mutable per instance so a + # caller can add or remove entries before scraping. + attr_reader :remove_xpaths + # Extracts the performance / crawling / content-processing # configuration off ``params`` and allocates the per-instance # response cache at construction time so the ivars (and the cache @@ -32,6 +52,7 @@ def initialize(agent = nil, params = nil) @tool_prefix = "#{@tool_prefix}_" unless @tool_prefix.empty? @cache_enabled = get_param('cache_enabled', default: true) != false @cache = @cache_enabled ? {} : nil + @remove_xpaths = DEFAULT_REMOVE_XPATHS.dup end def setup @@ -207,12 +228,18 @@ def unwrap_html(body) body end + # Drop each {#remove_xpaths} element together with its content, then + # flatten whatever tags remain to whitespace. Only the simple + # ``//tag`` form is compiled — anything more expressive would need a + # real XPath engine, so it is skipped rather than mis-applied. def strip_html(body) - body.gsub(%r{]*>.*?}mi, '') - .gsub(%r{]*>.*?}mi, '') - .gsub(/<[^>]+>/, ' ') - .gsub(/\s+/, ' ') - .strip + text = remove_xpaths.reduce(body) do |acc, xpath| + tag = xpath[%r{\A//([a-zA-Z][a-zA-Z0-9]*)\z}, 1] + next acc if tag.nil? + + acc.gsub(%r{<#{tag}\b[^>]*>.*?}mi, '') + end + text.gsub(/<[^>]+>/, ' ').gsub(/\s+/, ' ').strip end # Extract the path-and-query portion of a URL. Used by diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 806c492e..f3e80d66 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -24,8 +24,15 @@ class Service # - ``schema_validation`` — boolean flag controlling out-bound SWML # schema validation. ``SWML_SKIP_SCHEMA_VALIDATION=1`` env var # forces this to false. + # - ``ssl_enabled``, ``ssl_cert_path``, ``ssl_key_path``, ``domain`` — + # the resolved TLS configuration, derived in {#init_ssl_config} from + # the ``SWML_SSL_*`` / ``SWML_DOMAIN`` env vars and overridable by the + # matching {#serve} kwargs. Readable so a caller can inspect the + # effective TLS posture (and the public URL scheme it implies) without + # re-deriving it from the environment. attr_reader :name, :route, :host, :port, - :schema_path, :config_file, :schema_validation + :schema_path, :config_file, :schema_validation, + :ssl_enabled, :ssl_cert_path, :ssl_key_path, :domain # @param name [String] Human-readable service name # @param route [String] HTTP path this service responds on (default "/") diff --git a/port_signatures.json b/port_signatures.json index ffe7e47b..c2f6c41f 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -11172,6 +11172,15 @@ ], "returns": "any" }, + "domain": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "execute_verb": { "params": [ { @@ -11747,6 +11756,33 @@ ], "returns": "any" }, + "ssl_cert_path": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "ssl_enabled": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "ssl_key_path": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "stop": { "params": [ { @@ -39097,6 +39133,15 @@ ], "returns": "any" }, + "remove_xpaths": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "setup": { "params": [ { diff --git a/tests/skills/spider_skill_test.rb b/tests/skills/spider_skill_test.rb index bd00f904..417df26c 100644 --- a/tests/skills/spider_skill_test.rb +++ b/tests/skills/spider_skill_test.rb @@ -49,6 +49,43 @@ def test_get_hints assert_includes hints, 'crawl' end + def test_remove_xpaths_is_prefilled + factory = SignalWire::Skills::SkillRegistry.get_factory('spider') + skill = factory.call({}) + + assert_equal ['//script', '//style', '//nav', '//header', '//footer', '//aside', '//noscript'], + skill.remove_xpaths + end + + def test_strip_html_drops_every_remove_xpath_element_with_its_content + factory = SignalWire::Skills::SkillRegistry.get_factory('spider') + skill = factory.call({}) + html = '
HEAD
' \ + '' \ + '

keep me

FOOT
' + text = skill.send(:strip_html, html) + + assert_equal 'keep me', text + end + + def test_strip_html_honours_a_mutated_remove_xpaths + factory = SignalWire::Skills::SkillRegistry.get_factory('spider') + skill = factory.call({}) + skill.remove_xpaths.delete('//nav') + text = skill.send(:strip_html, '

body

') + + assert_equal 'MENU body', text + end + + def test_strip_html_skips_non_simple_xpath_expressions + factory = SignalWire::Skills::SkillRegistry.get_factory('spider') + skill = factory.call({}) + skill.remove_xpaths.replace(['//div[@class="ad"]']) + text = skill.send(:strip_html, '
AD

body

') + + assert_equal 'AD body', text + end + def test_scrape_empty_url factory = SignalWire::Skills::SkillRegistry.get_factory('spider') skill = factory.call({}) diff --git a/tests/tls/tls_https_server_test.rb b/tests/tls/tls_https_server_test.rb index 60b34e93..7f8da6b1 100644 --- a/tests/tls/tls_https_server_test.rb +++ b/tests/tls/tls_https_server_test.rb @@ -172,3 +172,53 @@ def test_agent_base_serves_verified_https_from_env assert_untrusted_rejected(base) end end + +# The resolved TLS configuration is READABLE off the service (ssl_enabled, +# ssl_cert_path, ssl_key_path, domain) — a caller can inspect the effective TLS +# posture without re-deriving it from the environment. No certs needed: this +# pins the config derivation + override, not a live handshake. +class TlsConfigReadbackTest < Minitest::Test + SSL_ENV = %w[SWML_SSL_ENABLED SWML_SSL_CERT_PATH SWML_SSL_KEY_PATH SWML_DOMAIN].freeze + + def setup + @saved = SSL_ENV.to_h { |k| [k, ENV.fetch(k, nil)] } + SSL_ENV.each { |k| ENV.delete(k) } + end + + def teardown + @saved.each { |k, v| v.nil? ? ENV.delete(k) : ENV[k] = v } + end + + def test_defaults_to_ssl_off_with_no_paths + svc = SignalWire::SWML::Service.new(name: 'plain') + + refute svc.ssl_enabled + assert_nil svc.ssl_cert_path + assert_nil svc.ssl_key_path + assert_nil svc.domain + end + + def test_reads_the_env_derived_tls_config + ENV['SWML_SSL_ENABLED'] = 'true' + ENV['SWML_SSL_CERT_PATH'] = '/etc/ssl/x.crt' + ENV['SWML_SSL_KEY_PATH'] = '/etc/ssl/x.key' + ENV['SWML_DOMAIN'] = 'agent.example.com' + svc = SignalWire::SWML::Service.new(name: 'tls') + + assert svc.ssl_enabled + assert_equal '/etc/ssl/x.crt', svc.ssl_cert_path + assert_equal '/etc/ssl/x.key', svc.ssl_key_path + assert_equal 'agent.example.com', svc.domain + end + + def test_serve_kwargs_override_the_env_derived_config + svc = SignalWire::SWML::Service.new(name: 'override') + svc.send(:apply_ssl_overrides, ssl_cert: '/o.crt', ssl_key: '/o.key', + ssl_enabled: true, domain: 'override.example') + + assert svc.ssl_enabled + assert_equal '/o.crt', svc.ssl_cert_path + assert_equal '/o.key', svc.ssl_key_path + assert_equal 'override.example', svc.domain + end +end From 30050b53cb20672ba296852b008f91f58132e889 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 14:11:06 -0400 Subject: [PATCH 03/90] =?UTF-8?q?chore(surface):=20regenerate=20port=5Fsur?= =?UTF-8?q?face.json=20=E2=80=94=20was=20stale=20at=20c72a0b2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Committed artifact was generated at c72a0b2, the commit BEFORE the derived-attr work. 9dbbd25 regenerated port_signatures.json but not port_surface.json — exactly why the signature axis read clean while the surface axis showed 5 missing. scripts/enumerate_surface.rb needed ZERO changes: it already collects attr_reader members and none of the 5 appear in SURFACE_MEMBER_DROPS. Running the existing enumerator at the tree picked all 5 up. Non-RestClient surface gaps 5 -> 0 (verified independently by the orchestrator). SURFACE-DIFF 27 -> 22, all RestClient.. SIGNATURE gate byte-identical to HEAD. SURFACE-FRESH --check now exit 0 (was red). Tests 2656 runs / 0 failures. FMT + LINT clean. --- port_surface.json | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/port_surface.json b/port_surface.json index 9a16f2ba..cdf8f7a4 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ c72a0b28a75aba8f75612d073ab81d769b955f84", + "generated_from": "signalwire-ruby @ 9dbbd2524244b97c1c466de2512175be549592aa", "modules": { "signalwire": { "classes": {}, @@ -825,6 +825,7 @@ "define_tool", "define_tools", "document", + "domain", "execute_verb", "extract_sip_username", "full_validation_enabled", @@ -862,6 +863,9 @@ "schema_utils", "schema_validation", "serve", + "ssl_cert_path", + "ssl_enabled", + "ssl_key_path", "stop", "swaig_pre_dispatch", "validate_basic_auth", @@ -3639,6 +3643,7 @@ "get_parameter_schema", "name", "register_tools", + "remove_xpaths", "setup", "supports_multiple_instances?" ] From 88253c6f1a9dbb67adc17be15543371396644e6b Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 15:51:32 -0400 Subject: [PATCH 04/90] enumerator: lift `include`d module members onto the including class MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both Ruby enumerators walked DECLARED members only (`public_instance_methods(false)` / `instance_methods(false)`), so any surface a class reaches through `include` was invisible. `RestClient` composes its 22 flat-resource / namespace-container accessors by including the generated `Namespaces::Generated::ResourceTree` (lib/signalwire/rest/rest_client.rb:42) rather than writing 22 `def`s. All 22 were therefore reported as missing against a reference that records them on `RestClient` — 22 signature drifts AND 22 surface drifts. They were never missing: `client.calling` / `client.fabric` / `client.video` have always worked. The gap was the walker, not the port. This is the Ruby analog of `_wired_base_attributes` in porting-sdk's reference enumerator, and is scoped the same way: only modules already EXCLUDED from the surface scan are lifted (a module that is its own audited symbol would be double-counted), only SignalWire-owned modules, and `initialize` is skipped. Also folds Ruby LANGUAGE-PROTOCOL hooks (to_s / to_json / hash / eql? / deconstruct / deconstruct_keys). `Relay::Message` includes the excluded `MessageSerialization` mixin, so an unscoped lift surfaced its JSON, equality, and pattern-matching protocol methods as 6 port ADDITIONS. The reference records none of them (it records `__repr__`, the Python side of the same idiom), so they fold at the emitter — the same reasoning that already folds `AIChatClient#inspect`/`#to_s` in SURFACE_MEMBER_DROPS. No ledger entry. `ResourceTree` added to enumerate_signatures.py's EXCLUDED_RUBY_CLASSES so a lifted module can never also be recorded as its own symbol. Adds tests/rest/resource_tree_accessors_mock_test.rb: pins all 22 accessors reachable + memoized on a live client, and three of them (addresses / fabric / video) landing real journaled requests on the shared mock. No omission, addition, or allow-list entry was added; the excused-divergence count is unchanged at 1155. The drift closed because the enumerators now see real, already-working matched surface. SIGNATURES: 22 drifts -> 0 (exit 0, 1557 reference symbols, 2554 port symbols) SURFACE: 22 drifts -> 0 (exit 0, 2637 symbols) --- port_signatures.json | 198 ++++++++++++++++++ port_surface.json | 26 ++- scripts/enumerate_signatures.py | 7 + scripts/enumerate_surface.rb | 71 +++++++ scripts/signature_dump.rb | 50 ++++- .../rest/resource_tree_accessors_mock_test.rb | 95 +++++++++ 6 files changed, 444 insertions(+), 3 deletions(-) create mode 100644 tests/rest/resource_tree_accessors_mock_test.rb diff --git a/port_signatures.json b/port_signatures.json index c2f6c41f..d7caffe0 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -27489,6 +27489,51 @@ ], "returns": "void" }, + "addresses": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "calling": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "chat": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "datasphere": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "fabric": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "generated_http_client": { "params": [ { @@ -27507,6 +27552,15 @@ ], "returns": "any" }, + "imported_numbers": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "inspect": { "params": [ { @@ -27516,6 +27570,69 @@ ], "returns": "any" }, + "logs": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "lookup": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "messages": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "mfa": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "number_groups": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "phone_numbers": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "project": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "project_id": { "params": [ { @@ -27525,6 +27642,69 @@ ], "returns": "any" }, + "projects": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "pubsub": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "queues": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "recordings": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "registry": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "short_codes": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "sip_profile": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, "to_s": { "params": [ { @@ -27533,6 +27713,24 @@ } ], "returns": "any" + }, + "verified_callers": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" + }, + "video": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" } } } diff --git a/port_surface.json b/port_surface.json index cdf8f7a4..d023b0a7 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 9dbbd2524244b97c1c466de2512175be549592aa", + "generated_from": "signalwire-ruby @ 30050b53cb20672ba296852b008f91f58132e889", "modules": { "signalwire": { "classes": {}, @@ -2049,11 +2049,33 @@ "classes": { "RestClient": [ "__init__", + "addresses", + "calling", + "chat", + "datasphere", + "fabric", "generated_http_client", "http", + "imported_numbers", "inspect", + "logs", + "lookup", + "messages", + "mfa", + "number_groups", + "phone_numbers", + "project", "project_id", - "to_s" + "projects", + "pubsub", + "queues", + "recordings", + "registry", + "short_codes", + "sip_profile", + "to_s", + "verified_callers", + "video" ] }, "functions": [] diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 97a8419b..5d5be45b 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -989,6 +989,13 @@ def apply(key: tuple, sig: dict) -> None: "SignalWire::POM::SectionBuilder", "SignalWire::Skills::SkillIntrospection", "SignalWire::Relay::MessageSerialization", + # Composition-only mixins whose members signature_dump.rb LIFTS onto the + # classes that `include` them (COMPOSED_MODULES there), so the enumerator + # records the surface a CALLER sees: RestClient's 22 resource accessors come + # from ResourceTree, Relay::Message's serialization from MessageSerialization. + # They must stay excluded HERE so a lifted module is not also recorded as its + # own symbol, which would double-count every member it contributes. + "SignalWire::REST::Namespaces::Generated::ResourceTree", # RequestOptions helpers mirroring the reference's PRIVATE # signalwire.rest._request_options._EffectiveOptions / _AbortSignal. "SignalWire::REST::EffectiveOptions", diff --git a/scripts/enumerate_surface.rb b/scripts/enumerate_surface.rb index b23cbdea..f0b72fa9 100755 --- a/scripts/enumerate_surface.rb +++ b/scripts/enumerate_surface.rb @@ -780,11 +780,82 @@ def raw_class_methods(klass) # Class methods (Python module-level "classmethod"/"staticmethod" show up as # methods on the class too). raw.concat(klass.singleton_methods(false).map(&:to_s)) + # Methods the class COMPOSES via `include` from a non-surface module. + raw.concat(composed_module_methods(klass)) # initialize is private by default — include it explicitly. raw << 'initialize' if klass.private_method_defined?(:initialize, false) raw end +# Public instance methods a class reaches through `include`, lifted onto the +# class so a reflective walk sees the surface a CALLER sees. +# +# The blind spot this closes: `public_instance_methods(false)` is +# DECLARED-ONLY. `RestClient` composes its 22 flat-resource / namespace-container +# accessors by including the generated `Namespaces::Generated::ResourceTree` +# (rest/rest_client.rb:42) instead of writing 22 `def`s, so every one of them was +# invisible to this enumerator — and reported as 22 missing symbols against a +# reference that records them all on `RestClient`. They were never missing; +# `client.calling` / `client.fabric` / `client.video` have always worked (pinned +# by tests/rest/resource_tree_accessors_mock_test.rb). This is the Ruby analog of +# `_wired_base_attributes` in porting-sdk's own reference enumerator, which lifts +# members off a base the walker would otherwise miss. +# +# Scoped deliberately narrow, mirroring that precedent: +# * Only modules EXCLUDED from the surface scan (RUBY_EXCLUDED_CLASSES) are +# lifted. A module that is its own surface symbol already has its members +# enumerated on itself; lifting those onto every includer would duplicate +# real composition into flattened members. `ResourceTree` and `Generated` +# are both excluded, so nothing double-counts. +# * Only SignalWire-owned modules — never a stdlib/gem mixin (Comparable, +# Enumerable, Kernel), which are language idiom and not port surface. +# * `initialize` is skipped; the class's own constructor is handled above. +# * RUBY_PROTOCOL_METHODS are skipped — see that constant. +# Filtering to the public surface (`_`-prefixed, `=` writers) happens in the +# caller via `surface_method?`, exactly as for declared methods. +def composed_module_methods(klass) + klass.included_modules.select { |mod| composed_module?(mod.name) } + .flat_map { |mod| liftable_module_methods(mod) } +end + +# A module whose members are lifted onto its includers: SignalWire-owned AND +# excluded from the surface scan (so lifting cannot double-count a module that is +# its own surface symbol). +def composed_module?(name) + return false if name.nil? || !name.start_with?('SignalWire') + + RUBY_EXCLUDED_CLASSES.include?(name) +end + +# The public instance methods of a composed module that count as lifted surface. +def liftable_module_methods(mod) + mod.public_instance_methods(false).map(&:to_s).reject do |m| + m == 'initialize' || RUBY_PROTOCOL_METHODS.include?(m) + end +end + +# Ruby LANGUAGE-PROTOCOL hooks: methods the interpreter (or a core protocol like +# pattern matching / Hash keying / JSON) calls on an object, not methods a caller +# invokes for a SignalWire capability. These are never port surface — the same +# reasoning that already folds `AIChatClient#inspect`/`#to_s` in +# SURFACE_MEMBER_DROPS ("token-redacting Ruby object hooks; the reference defines +# no `__repr__`/`__str__`"). +# +# Only consulted by `composed_module_methods`, i.e. for methods reached through an +# `include`. A class that DECLARES one of these keeps its existing treatment, so +# this cannot retroactively strip anything that was already emitted. +# +# Concretely: `MessageSerialization` (an excluded mixin, extracted from +# `Relay::Message` so the class stays focused on lifecycle) contributes +# to_s / to_json / hash / eql? / deconstruct / deconstruct_keys — Ruby's +# JSON, equality, and Ruby-3 pattern-matching protocols. The reference `Message` +# records none of them (it records `__repr__`, which is the Python side of the +# same idiom), so lifting them would surface pure language idiom as 6 port +# ADDITIONS. Folding them here is the emitter doing the idiom reconciliation. +RUBY_PROTOCOL_METHODS = %w[ + to_s to_json inspect hash eql? deconstruct deconstruct_keys +].freeze + # A method is part of the public surface unless it's a single-underscore # "private convention" name or an auto-generated writer (attr_writer/accessor); # the Python surface file emits neither. diff --git a/scripts/signature_dump.rb b/scripts/signature_dump.rb index bcc4a881..a47d4a6f 100755 --- a/scripts/signature_dump.rb +++ b/scripts/signature_dump.rb @@ -37,7 +37,7 @@ def instance_method_entries(mod) return [] unless mod.is_a?(Class) entries = constructor_entry(mod) - mod.instance_methods(false).sort.each do |meth_name| + (mod.instance_methods(false).sort + composed_module_methods(mod)).each do |meth_name| next if meth_name == :initialize next if meth_name.to_s.start_with?('_') @@ -47,6 +47,54 @@ def instance_method_entries(mod) entries end +# Ruby LANGUAGE-PROTOCOL hooks — methods the interpreter or a core protocol +# (JSON, equality/Hash keying, Ruby-3 pattern matching, object printing) calls, +# not methods a caller invokes for a SignalWire capability. Never port surface. +# Kept in lockstep with RUBY_PROTOCOL_METHODS in scripts/enumerate_surface.rb. +RUBY_PROTOCOL_METHODS = %i[ + to_s to_json inspect hash eql? deconstruct deconstruct_keys +].freeze + +# Modules that are pure INTERNAL COMPOSITION: a class `include`s them to reach +# their methods, but they are not themselves audited surface. Their members must +# therefore be attributed to the INCLUDING class, which is how a caller sees them. +# This is an EXPLICIT list rather than a reference to the surface enumerator's +# RUBY_EXCLUDED_CLASSES because this dump is a standalone Ruby script that shares +# no constants with it. Every entry must also be excluded there (and in +# enumerate_signatures.py's EXCLUDED_RUBY_CLASSES) — otherwise the module is BOTH +# its own audited symbol and lifted onto its includers, double-counting its +# members. Both current entries satisfy that. Adding an entry here means checking +# the other two tables. +COMPOSED_MODULES = %w[ + SignalWire::REST::Namespaces::Generated::ResourceTree + SignalWire::Relay::MessageSerialization +].freeze + +# Public instance methods a class reaches through `include` from a +# COMPOSED_MODULES module. +# +# The blind spot this closes: `instance_methods(false)` is DECLARED-ONLY. +# `RestClient` composes its 22 flat-resource / namespace-container accessors by +# including the generated `Namespaces::Generated::ResourceTree` +# (lib/signalwire/rest/rest_client.rb:42) rather than writing 22 `def`s, so all 22 +# were invisible here — recorded as 1 of 23 members and reported as 22 missing +# symbols against a reference that records them all on `RestClient`. They were +# never missing; `client.calling` / `client.fabric` / `client.video` have always +# worked (pinned by tests/rest/resource_tree_accessors_mock_test.rb). This is the +# Ruby analog of `_wired_base_attributes` in porting-sdk's reference enumerator, +# which lifts members off a base the walker would otherwise miss. +# +# Scoped deliberately narrow, mirroring that precedent: only the explicitly listed +# non-surface modules are lifted (a module that is its own audited symbol would be +# double-counted), and language-protocol hooks are skipped. +def composed_module_methods(klass) + klass.included_modules.flat_map do |mod| + next [] unless COMPOSED_MODULES.include?(mod.name) + + mod.public_instance_methods(false).reject { |m| RUBY_PROTOCOL_METHODS.include?(m) }.sort + end +end + def constructor_entry(mod) entries = [] has_init = mod.method_defined?(:initialize, false) || mod.private_method_defined?(:initialize, false) diff --git a/tests/rest/resource_tree_accessors_mock_test.rb b/tests/rest/resource_tree_accessors_mock_test.rb new file mode 100644 index 00000000..3cf1190f --- /dev/null +++ b/tests/rest/resource_tree_accessors_mock_test.rb @@ -0,0 +1,95 @@ +# frozen_string_literal: true + +# Regression guard for the RestClient resource-tree accessors. +# +# `RestClient` composes its 22 flat-resource / namespace-container accessors by +# including the GENERATED `Namespaces::Generated::ResourceTree` module +# (rest_client.rb:42) rather than defining them in the class body. A reflective +# walk that only looks at methods defined directly on `RestClient` misses all 22 +# — which is exactly the enumerator blind spot this file pins shut from the +# behavioural side: every accessor named in the reference surface must be +# reachable on a live client, and requests reached through the accessor path must +# actually land on the wire. + +require 'minitest/autorun' +require_relative 'mock_test' + +class ResourceTreeAccessorsMockTest < Minitest::Test + parallelize_me! + + RELAY_BASE = '/api/relay/rest' + VIDEO_BASE = '/api/video' + FABRIC_BASE = '/api/fabric/resources' + + # The full accessor set the reference (python) RestClient exposes. Hard-coded + # rather than derived from ResourceTree so the test fails if an accessor is + # ever dropped from the generated module. + EXPECTED_ACCESSORS = %w[ + addresses calling chat datasphere fabric imported_numbers logs lookup + messages mfa number_groups phone_numbers project projects pubsub queues + recordings registry short_codes sip_profile verified_callers video + ].freeze + + def setup + h = MockTest.client + @client = h[:client] + @mock = h[:mock] + end + + # Every expected accessor answers on a live client and returns a real object. + def test_every_resource_tree_accessor_is_reachable + missing = EXPECTED_ACCESSORS.reject { |name| @client.respond_to?(name) } + + assert_empty missing, "RestClient is missing accessors: #{missing.join(', ')}" + + EXPECTED_ACCESSORS.each do |name| + resource = @client.public_send(name) + + refute_nil resource, "client.#{name} returned nil" + end + end + + # The accessors memoize: a second call returns the very same object. + def test_accessors_memoize + EXPECTED_ACCESSORS.each do |name| + assert_same @client.public_send(name), @client.public_send(name), + "client.#{name} is not memoized" + end + end + + # A flat resource reached through the accessor path lands a real request. + def test_addresses_accessor_reaches_the_wire + body = @client.addresses.list + + assert_kind_of Hash, body + last = @mock.last + + assert_equal 'GET', last.method + assert_equal "#{RELAY_BASE}/addresses", last.path + refute_nil last.matched_route + end + + # A namespace container reached through the accessor path lands a real request. + def test_fabric_accessor_reaches_the_wire + body = @client.fabric.ai_agents.list + + assert_kind_of Hash, body + last = @mock.last + + assert_equal 'GET', last.method + assert_equal "#{FABRIC_BASE}/ai_agents", last.path + refute_nil last.matched_route + end + + # A second namespace container, on a different spec namespace. + def test_video_accessor_reaches_the_wire + body = @client.video.rooms.list + + assert_kind_of Hash, body + last = @mock.last + + assert_equal 'GET', last.method + assert_equal "#{VIDEO_BASE}/rooms", last.path + refute_nil last.matched_route + end +end From 07eda64be0f03a09e4c6661d5997bc3fc9029067 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 18:08:59 -0400 Subject: [PATCH 05/90] fix(secure-default): emit the rendered wire payload, not a self-verdict MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ruby's SECURE-DEFAULT dump still spoke the pre-2026-07-27 protocol — {secure_default_true, wire_reflects_secure}, two booleans the PORT computed by inspecting its own render. The differ never saw the wire, so it could not see WHICH key carried the token; that is how java passed this gate green while minting into meta_data_token with a tokenless web_hook_url. The differ now rejects the legacy shape outright, so the gate was RED. Migrate to the payload protocol (mirrors signalwire-php bin/secure-default-dump d3cbc47): {"": {"secure_default_true": bool, "rendered": {}}} * secure_default_true is read back from the live registry (@tools[name][:secure]), never echoed from what this program passed to define_tool — an echoed input is incapable of ever failing. * rendered is the tool's own SWAIG.functions[] entry verbatim, with token VALUES replaced by the corpus placeholder and every KEY and key path preserved. Redaction mirrors diff_port_secure_default.redact_entry so the differ's re-application is a fixed point. The program makes no judgement about correctness; the differ derives has_own_webhook and token_carrier from the keys. Dump-only change — ruby's emitter was already correct on both halves (agent_base.rb:2282-2295 appends __token to the secure tool's own webhook and omits web_hook_url entirely when qp is empty, matching the reference guard at agent_base.py:1085-1099). Gate: EXIT=1 (2 FAIL, legacy protocol) -> EXIT=0 (PASS). Mutation-tested both directions: token moved to meta_data_token reds with "TOKEN IN THE WRONG PLACE"; a per-tool web_hook_url on the insecure tool reds with "WEBHOOK SHAPE". Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- bin/secure-default-dump | 138 +++++++++++++++++++++++++--------------- 1 file changed, 88 insertions(+), 50 deletions(-) diff --git a/bin/secure-default-dump b/bin/secure-default-dump index a8f098b3..aa773b43 100755 --- a/bin/secure-default-dump +++ b/bin/secure-default-dump @@ -7,26 +7,36 @@ # See LICENSE file in the project root for full license information. # -# secure-default-dump — the Ruby port's SECURE-DEFAULT dump program for the -# cross-port behavioral differ (porting-sdk/scripts/diff_port_secure_default.py). +# secure-default-dump — the Ruby port's SECURE-DEFAULT (A1) Layer-D dump program +# for the cross-port behavioral differ +# (porting-sdk/scripts/diff_port_secure_default.py). # -# The A1 secure-default parity contract: AgentBase#define_tool defaults -# secure=true fleet-wide, and a SECURE tool rendered with an active call_id -# carries a per-tool __token on its SWAIG web_hook_url (the wire manifestation of -# secure). A secure=false tool carries NO __token. +# The differ drives the python reference through the secure_default corpus to +# build the golden token TOPOLOGY, then runs THIS program (which embeds the same +# two fixtures) and classifies OUR rendered payload the same way. # -# This program defines two tools — one default (no explicit secure:) and one -# secure:false — renders the SWML with the fixed corpus CALL_ID, and for each -# emits {secure_default_true, wire_reflects_secure}: +# Protocol (the 2026-07-27 redesign — a WIRE payload, not a self-verdict): # -# secure_default_true the SDK-recorded secure flag for the default tool -# (true for the default case, false for the explicit case). -# wire_reflects_secure a __token is present on the rendered webhook IFF the -# tool is secure (secure -> token present; insecure -> -# token absent). +# {"": {"secure_default_true": bool, "rendered": {}}} # -# The token VALUE is an HMAC and is NOT compared — only its PRESENCE. Protocol: -# stdout = ONE JSON object mapping corpus fixture-id -> classification map. +# secure_default_true — the SDK-RECORDED secure flag for that tool, read back +# from the live registry (``@tools[name][:secure]``). It is deliberately NOT +# the value this program passed to ``define_tool``: echoing the input back +# would make the field incapable of ever failing, which is precisely the +# vacuity this redesign exists to close. +# rendered — that tool's own ``SWAIG.functions[]`` entry, VERBATIM, with every +# token VALUE replaced by the corpus placeholder ```` (the values are +# HMACs and vary per run; the KEY PATH is the whole contract and is preserved +# exactly). +# +# This program makes NO judgement about whether the render is correct — the +# differ derives ``has_own_webhook`` and ``token_carrier`` from the keys. The +# contract it pins (signalwire-python core/agent_base.py:1085-1099): a SECURE +# tool's entry carries its own ``web_hook_url`` with a ``__token`` query param; +# an INSECURE tool's entry carries NO ``web_hook_url`` key at all and falls back +# to the shared ``SWAIG.defaults.web_hook_url``. +# +# Only stdout carries JSON; setup noise goes to stderr. # # Run from the signalwire-ruby repo root: # @@ -40,62 +50,90 @@ REAL_STDOUT = $stdout.dup $stdout.reopen($stderr) require_relative '../lib/signalwire' -# Must match porting-sdk/scripts/secure_default_corpus.py CALL_ID + tool names. +# The FIXED call_id the corpus renders with, so a secure tool deterministically +# gets a __token. Mirrors secure_default_corpus.CALL_ID. CALL_ID = 'call-secure-default-fixture' -CORPUS = [ - { 'id' => 'define_tool_default_is_secure', 'kind' => 'secure_default', - 'tool_name' => 'sd_default_secure', 'expect_secure' => true }, - { 'id' => 'define_tool_explicit_insecure', 'kind' => 'secure_explicit_false', - 'tool_name' => 'sd_explicit_insecure', 'expect_secure' => false } -].freeze +# Mirrors secure_default_corpus.TOKEN_PLACEHOLDER. +TOKEN_PLACEHOLDER = '' -# Locate one SWAIG function entry (by name) in a rendered SWML document. +# Locate the SWAIG functions array in a rendered SWML document. def swaig_functions(doc) sections = doc['sections'] main = sections.is_a?(Hash) ? sections['main'] : nil return [] unless main.is_a?(Array) - ai = main.find { |sec| sec.is_a?(Hash) && sec.key?('ai') } + ai = main.find { |sec| sec.is_a?(Hash) && sec['ai'].is_a?(Hash) } return [] unless ai fns = ai.dig('ai', 'SWAIG', 'functions') fns.is_a?(Array) ? fns : [] end -# True iff a rendered SWAIG function entry's webhook carries a per-tool __token. -def webhook_has_token?(entry) - url = (entry && entry['web_hook_url']) || '' - url.include?('__token=') +# Replace the VALUE of every token-suffixed query parameter in a URL, preserving +# the key and every other pair exactly. +def redact_url(url) + q = url.index('?') + return url unless q + + rebuilt = url[(q + 1)..].split('&').map do |pair| + key, sep, _value = pair.partition('=') + sep == '=' && key.downcase.end_with?('token') ? "#{key}=#{TOKEN_PLACEHOLDER}" : pair + end + "#{url[0..q]}#{rebuilt.join('&')}" end -def main - agent = SignalWire::AgentBase.new(name: 'secure-default-fixture', route: '/sd') +# Replace every nondeterministic token VALUE (an HMAC) with the corpus +# placeholder while preserving every KEY and key path exactly — both a +# token-suffixed field and a token-suffixed query parameter on a URL value. +# Mirrors diff_port_secure_default.redact_entry so the differ's re-application +# is a no-op. +def redact_entry(entry) + entry.each_with_object({}) do |(key, value), out| + out[key] = + if value.is_a?(String) && key.to_s.downcase.end_with?('token') + TOKEN_PLACEHOLDER + elsif value.is_a?(String) && (value.include?('://') || value.start_with?('/')) + redact_url(value) + else + value + end + end +end - # A default tool (no explicit secure:) + a secure:false tool. - agent.define_tool(name: 'sd_default_secure', description: 'secure-default fixture tool', - parameters: {}) { |_a, _r| nil } - agent.define_tool(name: 'sd_explicit_insecure', description: 'secure-default fixture tool', - parameters: {}, secure: false) { |_a, _r| nil } +# Build a fresh agent, define one tool via the caller's block, render the SWML +# with the fixed call_id, and emit {secure_default_true, rendered} for the +# differ to classify. +def emit(tool_name) + agent = SignalWire::AgentBase.new(name: 'secure-default-fixture', route: '/sd') + yield agent - # Read back the SDK-recorded secure flag per tool. - recorded = agent.instance_variable_get(:@tools).transform_values { |t| t[:secure] ? true : false } + # The SDK-RECORDED flag, read back from the registry — never the value we + # passed in (see the header: an echoed input can never red). + tool = agent.instance_variable_get(:@tools)[tool_name] || {} + recorded_secure = tool[:secure] ? true : false - # Render the SWML WITH the fixed call_id so secure tools emit their __token. doc = agent._render_swml_internal(call_id: CALL_ID) - by_name = {} - swaig_functions(doc).each { |f| by_name[f['function']] = f if f.is_a?(Hash) } + entry = swaig_functions(doc).find { |f| f.is_a?(Hash) && f['function'] == tool_name } || {} + + { 'secure_default_true' => recorded_secure, 'rendered' => redact_entry(entry) } +end +def main out = {} - CORPUS.each do |kase| - name = kase['tool_name'] - expect_secure = kase['expect_secure'] - is_secure = recorded.fetch(name, false) - token_present = webhook_has_token?(by_name[name]) - out[kase['id']] = { - 'secure_default_true' => (is_secure ? true : false), - 'wire_reflects_secure' => (token_present == expect_secure) - } + + # A1 (a): a tool defined with NO explicit secure: must default to SECURE → + # its rendered entry carries its own web_hook_url with a __token query param. + out['define_tool_default_is_secure'] = emit('sd_default_secure') do |a| + a.define_tool(name: 'sd_default_secure', description: 'A default-secure tool', + parameters: { 'q' => { 'type' => 'string' } }) { |_args, _raw| nil } + end + + # A1 (b): a tool defined with secure: false must be INSECURE → NO per-tool + # web_hook_url key at all (it falls back to SWAIG.defaults.web_hook_url). + out['define_tool_explicit_insecure'] = emit('sd_explicit_insecure') do |a| + a.define_tool(name: 'sd_explicit_insecure', description: 'An explicitly-insecure tool', + parameters: { 'q' => { 'type' => 'string' } }, secure: false) { |_args, _raw| nil } end REAL_STDOUT.puts(JSON.generate(out)) From 9fb26e28fc03f2a784ab5ae2365e08602bd6ef65 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 21:06:22 -0400 Subject: [PATCH 06/90] fix(security): SessionManager default token_expiry_secs 3600 -> 900 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The reference mints 15-minute tool tokens by default (core/security/session_manager.py __init__, "default: 15 minutes"); this port minted 60-minute ones. A stale tool token is a credential, so the longer window is a security divergence, not a cosmetic one. The port's OWN class docstring already advertised `SessionManager.new(token_expiry_secs: 900)` — the doc and the code disagreed, which is how the divergence survived review. Folding the code makes the existing docstring true. Only the DEFAULT changes. An explicit `token_expiry_secs:` still wins, and AgentBase is unaffected: it passes the value explicitly (agent_base.rb:153) and keeps its own 3600 default, which is what the reference's AgentBase does too (core/agent_base.py:130). The four doc mentions of 3600 all describe that AgentBase parameter and remain true. Tested by asserting the default directly rather than an explicitly-passed value — the latter cannot catch a drifted default, which is exactly the hole this sat in. Mutating the default back to 3600 turns the new test red (Expected: 900, Actual: 3600). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/security/session_manager.rb | 6 ++++-- tests/security_test.rb | 17 +++++++++++++++++ 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/lib/signalwire/security/session_manager.rb b/lib/signalwire/security/session_manager.rb index 49b367a2..96b8201d 100644 --- a/lib/signalwire/security/session_manager.rb +++ b/lib/signalwire/security/session_manager.rb @@ -41,9 +41,11 @@ class SessionManager # means the stored value is not always the value passed). attr_reader :secret_key, :token_expiry_secs - # @param token_expiry_secs [Integer] seconds until tokens expire (minimum 1) + # @param token_expiry_secs [Integer] seconds until tokens expire + # (default: 900 — 15 minutes; minimum 1). Matches the reference + # (+core/security/session_manager.py+ +__init__+). # @param secret_key [String, nil] hex-encoded secret; generated if omitted - def initialize(token_expiry_secs: 3600, secret_key: nil) + def initialize(token_expiry_secs: 900, secret_key: nil) @token_expiry_secs = [token_expiry_secs, 1].max @secret_key = secret_key || SecureRandom.hex(32) @debug_mode = false diff --git a/tests/security_test.rb b/tests/security_test.rb index 45e6e2dc..114b8410 100644 --- a/tests/security_test.rb +++ b/tests/security_test.rb @@ -184,6 +184,23 @@ def test_custom_secret_key_roundtrip assert mgr.validate_token('my_tool', token, 'call-99') end + # ------------------------------------------------------------------ + # Default expiry + # ------------------------------------------------------------------ + + # The DEFAULT lifetime is 900s (15 minutes), matching the reference + # (core/security/session_manager.py __init__). A test that only checks an + # explicitly-passed value cannot catch a drifted default, which is how this + # port sat at 3600 while its own class docstring advertised 900. + def test_default_token_expiry_secs_is_900_seconds + assert_equal 900, SM.new.token_expiry_secs + end + + # Passing a lifetime explicitly still wins over the default. + def test_explicit_token_expiry_secs_overrides_the_default + assert_equal 3600, SM.new(token_expiry_secs: 3600).token_expiry_secs + end + # ------------------------------------------------------------------ # Minimum expiry # ------------------------------------------------------------------ From 1fa058c0a287317f7a0745f40d0124d193fbddc0 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 21:26:07 -0400 Subject: [PATCH 07/90] enumerator: recover parameter DEFAULT VALUES from source (0 -> 330) The signature enumerator emitted `"default": null` for all 235 defaultable params, so a defaults-comparison gate would have been VACUOUS for ruby -- passing on silence. That is the failure mode that let a 4x-too-long SWAIG token replay window (token_expiry_secs 3600 vs the reference's 900) sit unnoticed until a human spotted the number. Ruby reflection cannot supply the value. Method#parameters reports that a default EXISTS (:opt / :key) but never what it IS: class T; def m(a, b = 42, c: "hi"); end; end T.instance_method(:m).parameters #=> [[:req, :a], [:opt, :b], [:key, :c]] So the value has to come from the SOURCE. signature_dump.rb now parses every lib/**/*.rb with Ripper (stdlib -- deliberately NOT the prism/parser gems, which are present only transitively as rubocop deps and would be an undeclared dev dep) and indexes each def node's parameter defaults by [realpath, line]. That pair is an EXACT join key: Method#source_location returns the file and line of the `def` keyword, and Ripper's def node carries the same line. So the join needs no class/method name matching and cannot mis-attribute a same-named method on another class or one reached through include. LITERALS ONLY, by design. Integers (incl. radix prefixes / underscores), floats, true/false/nil, strings, symbols, and arrays/hashes whose elements are themselves literals are recovered. A non-literal EXPRESSION has no static value and is left unrecovered rather than evaluated or guessed: * named constants -- DEFAULT_VOICE, RecordFormat::WAV, STRING (10 params) * arithmetic -- max_file_size: 100 * 1024 * 1024 (1 param) String interpolation is explicitly rejected: Ripper would otherwise hand back the concatenated static fragments ("a#{x}b" -> "ab"), a FABRICATED value. A wrong default is worse than a missing one -- it makes a correct port look defective, and "fixing" the port to match could introduce a real defect. Recovery: 1463 of 1474 defaultable params (11 unrecoverable, listed above). At the emitted-signature level, non-null defaults go 0 -> 330. Also documented as genuinely unrecoverable: the AI-Chat Struct.new(keyword_init: true) value models. A Struct declares field NAMES only -- there is no per-field default expression anywhere in source -- so `default: null` there is accurate, not a placeholder. Verified ADDITIVE-ONLY: stripping `default` from the before/after artifacts leaves them structurally identical (param set, order, names, types, kinds, required flags, returns all unmoved), and the count of params carrying a `default` key is unchanged at 1648. Spot-checked against source, not against the reference: SessionManager#initialize(token_expiry_secs) 900 -> 900 (number) SessionManager#initialize(secret_key) nil -> null ToolRegistry#define_tool(secure) true -> true ToolMixin#define_tool(secure) true -> true WebhookMiddleware#initialize(trust_proxy) false -> false `define_tool(secure)` is worth noting: php and dotnet both emit `false` for this param while their sources say `true`. Ruby emits `true`, matching both its source (registry.rb:68, agent_base.rb:709) and the reference. The rubocop Metrics exclusions are scoped to this one file and are SIZE/shape only, per .rubocop.yml's stated discipline. The extractor's size is a 1:1 dispatch over Ruby's literal AST node types, and its branch count is entirely shape-guarding -- each guard is a place it declines to invent a value it cannot prove, which is the property that keeps it honest. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- .rubocop.yml | 32 ++ port_signatures.json | 664 ++++++++++++++++---------------- scripts/enumerate_signatures.py | 30 +- scripts/signature_dump.rb | 264 ++++++++++++- 4 files changed, 658 insertions(+), 332 deletions(-) diff --git a/.rubocop.yml b/.rubocop.yml index aedba0ad..456c12c0 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -195,6 +195,38 @@ Metrics/ModuleLength: Metrics/MethodLength: Exclude: - 'lib/signalwire/skills/builtin/mcp_gateway.rb' + # signature_dump.rb's Ripper default-value extractor: same DATA-SHAPE (not + # logic) rationale. Its size is a 1:1 DISPATCH over Ruby's literal AST node + # types (int/float/keyword/string/symbol/array/hash), one arm per node kind + # the parser can emit. The arms were already extracted into named + # per-node-type helpers (ripper_string_literal / ripper_array_literal / + # ripper_hash_literal / ...); what remains is the irreducible dispatch itself + # plus each helper's exhaustive shape-guard chain. Splitting further would + # scatter one node type's handling across two methods and make it HARDER to + # confirm the extractor rejects every non-literal — which is the property + # that keeps it from emitting a fabricated default. Size only; no naming or + # type idiom is being suppressed. + - 'scripts/signature_dump.rb' + +# Same scope + same rationale as the Metrics/MethodLength entry above, for the +# same file. A literal-AST extractor's "complexity" is entirely SHAPE-GUARDING: +# every branch asks "is this node actually the literal it looks like?" (is it an +# Array, is its head the expected tag, does a string contain an interpolation, +# is every array element itself a literal). Those guards are the correctness +# property — each one is a place the extractor declines to invent a value it +# cannot prove — so collapsing them to satisfy a branch count would trade the +# gate's honesty for a metric. Scoped to this file only. +Metrics/CyclomaticComplexity: + Exclude: + - 'scripts/signature_dump.rb' + +Metrics/PerceivedComplexity: + Exclude: + - 'scripts/signature_dump.rb' + +Metrics/AbcSize: + Exclude: + - 'scripts/signature_dump.rb' # Prefer keyword args for boolean defaults — a good cop in general, but a known # false positive on FLUENT SINGLE-ARGUMENT TOGGLES, which is exactly these sites: diff --git a/port_signatures.json b/port_signatures.json index d7caffe0..dde7bab6 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -68,21 +68,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "0.0.0.0" }, { "name": "port", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 3000 }, { "name": "log_level", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "info" } ], "returns": "void" @@ -299,14 +299,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/sip" }, { "name": "auto_map", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -344,14 +344,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "bedrock_agent" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/bedrock" }, { "name": "system_prompt", @@ -365,28 +365,28 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "matthew" }, { "name": "temperature", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 0.7 }, { "name": "top_p", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 0.9 }, { "name": "max_tokens", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 1024 }, { "name": "**", @@ -600,7 +600,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "user" }, { "name": "config_url", @@ -628,7 +628,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -685,7 +685,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -1151,14 +1151,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "numbered_bullets", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "subsections", @@ -1354,7 +1354,7 @@ "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "handler", @@ -1368,7 +1368,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "fillers", @@ -1410,7 +1410,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "swaig_fields", @@ -1556,21 +1556,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "agent" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/" }, { "name": "host", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "0.0.0.0" }, { "name": "port", @@ -1591,42 +1591,42 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "token_expiry_secs", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 3600 }, { "name": "auto_answer", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "record_call", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "record_format", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "mp4" }, { "name": "record_stereo", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "default_webhook_url", @@ -1661,21 +1661,21 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "enable_post_prompt_override", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "check_for_input_override", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "config_file", @@ -1689,7 +1689,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "signing_key", @@ -1703,7 +1703,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "void" @@ -1840,7 +1840,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -1953,14 +1953,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "path", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/sip" } ], "returns": "any" @@ -1996,7 +1996,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -2012,7 +2012,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -2089,7 +2089,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -2411,7 +2411,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -2427,7 +2427,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -2692,7 +2692,7 @@ "name": "env_prefix", "type": "string", "required": false, - "default": null + "default": "SWML_" } ], "returns": "any" @@ -2712,7 +2712,7 @@ "name": "max_depth", "type": "int", "required": false, - "default": null + "default": 10 } ], "returns": "any" @@ -3273,7 +3273,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "void" @@ -3378,14 +3378,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "string" }, { "name": "confirm", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "prompt", @@ -3543,14 +3543,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "string" }, { "name": "confirm", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "prompt", @@ -3673,7 +3673,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -3851,7 +3851,7 @@ "name": "name", "type": "string", "required": false, - "default": null + "default": "default" } ], "returns": "any" @@ -4040,7 +4040,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "enum", @@ -4124,7 +4124,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "require_args", @@ -4210,7 +4210,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "GET" }, { "name": "headers", @@ -4259,7 +4259,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "void" @@ -4345,7 +4345,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "from_addr", @@ -4426,7 +4426,7 @@ "name": "enabled", "type": "bool", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -4441,7 +4441,7 @@ "name": "enabled", "type": "bool", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -4497,7 +4497,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -4521,7 +4521,7 @@ "name": "timeout", "type": "int", "required": false, - "default": null + "default": 300 } ], "returns": "any" @@ -4542,28 +4542,28 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "beep", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "true" }, { "name": "start_on_enter", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "end_on_exit", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "wait_url", @@ -4577,14 +4577,14 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 250 }, { "name": "record", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "do-not-record" }, { "name": "region", @@ -4598,7 +4598,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "trim-silence" }, { "name": "coach", @@ -4626,7 +4626,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "POST" }, { "name": "recording_status_callback", @@ -4640,14 +4640,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "POST" }, { "name": "recording_status_callback_event", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "completed" }, { "name": "result", @@ -4690,7 +4690,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "dtmf" }, { "name": "status_url", @@ -4704,49 +4704,49 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "credit-card" }, { "name": "timeout", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 5 }, { "name": "max_attempts", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 1 }, { "name": "security_code", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "postal_code", "type": "union", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "min_postal_code_length", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "token_type", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "reusable" }, { "name": "charge_amount", @@ -4760,21 +4760,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "usd" }, { "name": "language", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "en-US" }, { "name": "voice", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "woman" }, { "name": "description", @@ -4788,7 +4788,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "visa mastercard amex" }, { "name": "parameters", @@ -4830,7 +4830,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -4862,7 +4862,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "format", @@ -4890,14 +4890,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "input_sensitivity", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 44.0 }, { "name": "initial_timeout", @@ -4968,7 +4968,7 @@ "name": "text", "type": "union", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -5003,7 +5003,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "system" } ], "returns": "any" @@ -5051,7 +5051,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "phone" } ], "returns": "any" @@ -5292,21 +5292,21 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "full_reset", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "isolated", "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -5360,7 +5360,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -5416,7 +5416,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 20 }, { "name": "status_url", @@ -5511,7 +5511,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -5739,7 +5739,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "resource_vars", @@ -5790,14 +5790,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "language", "type": "any", "kind": "keyword", "required": false, - "default": null + "default": "en-US" } ], "returns": "any" @@ -5823,14 +5823,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "language_code", "type": "any", "kind": "keyword", "required": false, - "default": null + "default": "en-US" } ], "returns": "any" @@ -5845,7 +5845,7 @@ "name": "level", "type": "int", "required": false, - "default": null + "default": 1 } ], "returns": "any" @@ -6107,7 +6107,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -6143,7 +6143,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "resource_vars", @@ -6225,14 +6225,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "numbered_bullets", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "subsections", @@ -6429,7 +6429,7 @@ "name": "params", "type": "optional>", "required": false, - "default": null + "default": {} } ], "returns": "any" @@ -6534,7 +6534,7 @@ "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "handler", @@ -6548,7 +6548,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "fillers", @@ -6590,7 +6590,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "swaig_fields", @@ -6904,7 +6904,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -6918,14 +6918,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "numbered_bullets", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "subsections", @@ -6958,7 +6958,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -8594,7 +8594,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 900 }, { "name": "secret_key", @@ -8854,7 +8854,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "paths", @@ -8868,7 +8868,9 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": [ + "POST" + ] } ], "returns": "void" @@ -9079,7 +9081,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -9299,7 +9301,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "kwargs", @@ -9705,7 +9707,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "fillers", @@ -9747,7 +9749,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "extra_swaig_fields", @@ -9923,7 +9925,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true } ], "returns": "any" @@ -10762,7 +10764,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "json" } ], "returns": "any" @@ -10821,7 +10823,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "params", @@ -10835,35 +10837,35 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "record_call", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "record_format", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "mp4" }, { "name": "record_stereo", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "format", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "json" }, { "name": "default_webhook_url", @@ -10972,14 +10974,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/" }, { "name": "host", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "0.0.0.0" }, { "name": "port", @@ -11014,7 +11016,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true } ], "returns": "void" @@ -11135,14 +11137,14 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "secure", "type": "any", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "handler", @@ -11196,13 +11198,13 @@ "name": "args", "type": "any", "required": false, - "default": null + "default": [] }, { "name": "kwargs", "type": "any", "required": false, - "default": null + "default": {} } ], "returns": "any" @@ -11260,7 +11262,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -11294,7 +11296,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -19447,7 +19449,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "void" @@ -19488,7 +19490,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -19509,7 +19511,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -19639,7 +19641,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -19660,7 +19662,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "void" @@ -19709,7 +19711,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -19723,14 +19725,14 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "numberedBullets", "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -19773,7 +19775,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 2 }, { "name": "section_number", @@ -19796,7 +19798,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "section_number", @@ -19902,14 +19904,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "concierge" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/concierge" }, { "name": "_opts", @@ -20132,7 +20134,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true }, { "name": "persona", @@ -20146,14 +20148,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "faq_bot" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/faq" }, { "name": "_opts", @@ -20302,14 +20304,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "info_gatherer" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/info_gatherer" }, { "name": "**", @@ -20414,7 +20416,7 @@ "name": "raw_data", "type": "dict", "required": false, - "default": null + "default": {} } ], "returns": "any" @@ -20434,7 +20436,7 @@ "name": "raw_data", "type": "dict", "required": false, - "default": null + "default": {} } ], "returns": "any" @@ -20464,21 +20466,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "receptionist" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/receptionist" }, { "name": "greeting", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "Thank you for calling. How can I help you today?" }, { "name": "voice", @@ -20658,14 +20660,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "survey" }, { "name": "route", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "/survey" }, { "name": "_opts", @@ -21078,49 +21080,49 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "context", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tag", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "device", "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "segment_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" } ], "returns": "void" @@ -21602,7 +21604,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "hangup" } ], "returns": "any" @@ -23162,7 +23164,9 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": [ + "default" + ] }, { "name": "max_active_calls", @@ -23215,7 +23219,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": 120 }, { "name": "tag", @@ -23249,7 +23253,7 @@ "name": "params", "type": "dict", "required": false, - "default": null + "default": {} } ], "returns": "any" @@ -23770,7 +23774,7 @@ "name": "params", "type": "any", "required": false, - "default": null + "default": {} } ], "returns": "void" @@ -23975,56 +23979,56 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "device", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "node_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "project_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "context", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "segment_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tag", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -24133,28 +24137,28 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "end_reason", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "device", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -24236,14 +24240,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "message", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -24298,21 +24302,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "result", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "final", @@ -24392,21 +24396,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "name", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "status", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -24470,14 +24474,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "peer", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -24532,7 +24536,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "base", @@ -24578,14 +24582,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "detect", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -24640,21 +24644,21 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "dial_state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "call", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -24745,7 +24749,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -24791,14 +24795,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "fax", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -24853,7 +24857,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -24899,70 +24903,70 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "context", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "from_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "to_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "body", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "media", "type": "list", "kind": "keyword", "required": false, - "default": null + "default": [] }, { "name": "segments", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "message_state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tags", "type": "list", "kind": "keyword", "required": false, - "default": null + "default": [] }, { "name": "base", @@ -25089,77 +25093,77 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "context", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "from_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "to_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "body", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "media", "type": "list", "kind": "keyword", "required": false, - "default": null + "default": [] }, { "name": "segments", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "message_state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "reason", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tags", "type": "list", "kind": "keyword", "required": false, - "default": null + "default": [] }, { "name": "base", @@ -25304,14 +25308,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -25366,14 +25370,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -25428,42 +25432,42 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "status", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "queue_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "queue_name", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "position", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "size", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "base", @@ -25554,42 +25558,42 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "url", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "duration", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 0.0 }, { "name": "size", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "record", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -25680,28 +25684,28 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "sip_refer_to", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "sip_refer_response_code", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "sip_notify_response_code", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -25780,21 +25784,21 @@ "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "call_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "timestamp", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 0.0 } ], "returns": "void" @@ -25931,14 +25935,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -25993,28 +25997,28 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "url", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "name", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "base", @@ -26087,28 +26091,28 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tap", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "device", "type": "dict", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "base", @@ -26181,42 +26185,42 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "url", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "recording_id", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "duration", "type": "float", "kind": "keyword", "required": false, - "default": null + "default": 0.0 }, { "name": "size", "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "base", @@ -26323,42 +26327,42 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "context", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "from_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "to_number", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "body", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "media", @@ -26372,21 +26376,21 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 0 }, { "name": "state", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "reason", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "tags", @@ -27068,7 +27072,7 @@ "name": "method", "type": "string", "required": false, - "default": null + "default": "GET" }, { "name": "headers", @@ -27157,7 +27161,7 @@ "name": "method", "type": "string", "required": false, - "default": null + "default": "GET" } ], "returns": "void" @@ -27196,7 +27200,7 @@ "name": "data_key", "type": "string", "required": false, - "default": null + "default": "data" }, { "name": "request_options", @@ -30046,7 +30050,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30173,7 +30177,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30285,7 +30289,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30339,7 +30343,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30460,7 +30464,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30625,7 +30629,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -30799,7 +30803,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31100,7 +31104,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31163,7 +31167,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31266,7 +31270,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31357,7 +31361,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31756,7 +31760,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -31812,7 +31816,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32055,7 +32059,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32111,7 +32115,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32214,7 +32218,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32304,7 +32308,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32382,7 +32386,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32452,7 +32456,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32569,7 +32573,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32827,7 +32831,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -32978,7 +32982,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -33034,7 +33038,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -33137,7 +33141,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -33228,7 +33232,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -33786,7 +33790,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -33898,7 +33902,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -34533,7 +34537,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -34668,7 +34672,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -34722,7 +34726,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -35249,7 +35253,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -35311,7 +35315,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -35453,7 +35457,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -36201,7 +36205,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -36320,7 +36324,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -36580,7 +36584,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -36875,7 +36879,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -37437,7 +37441,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -37641,7 +37645,7 @@ "type": "optional>", "kind": "keyword", "required": false, - "default": null + "default": {} }, { "name": "request_options", @@ -39768,7 +39772,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -39816,7 +39820,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -39867,7 +39871,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -39908,7 +39912,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -39956,7 +39960,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -40004,7 +40008,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "block", @@ -40070,7 +40074,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "default", @@ -40226,7 +40230,7 @@ "name": "section", "type": "any", "required": false, - "default": null + "default": "main" } ], "returns": "any" @@ -40331,7 +40335,7 @@ "name": "schema_validation", "type": "bool", "required": false, - "default": null + "default": true } ], "returns": "void" @@ -40542,7 +40546,7 @@ "name": "allow_private", "type": "bool", "required": false, - "default": null + "default": false } ], "returns": "any" @@ -40564,7 +40568,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 8002 }, { "name": "directories", @@ -40592,7 +40596,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": false }, { "name": "allowed_extensions", @@ -40620,7 +40624,7 @@ "type": "bool", "kind": "keyword", "required": false, - "default": null + "default": true } ], "returns": "void" @@ -40755,7 +40759,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "127.0.0.1" }, { "name": "port", @@ -40783,7 +40787,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": false } ], "returns": "any" diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 5d5be45b..19ec2bb3 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -481,6 +481,21 @@ def synth_ai_chat_struct_inits(out_modules: dict) -> None: f for f in fields if f in methods and not _has_value_params(methods[f]) ] + # DEFAULT VALUES ARE GENUINELY UNRECOVERABLE HERE, and not for the usual + # reflection reason. These models are ``Struct.new(..., keyword_init: + # true)``: a Struct declares FIELD NAMES only, so there is no per-field + # default EXPRESSION anywhere in the source for a parser to read. Every + # omitted field is nil by the Struct protocol itself. So unlike a ``def`` + # parameter — whose default the Ripper pass in signature_dump.rb + # recovers from source — there is nothing here to recover, in any + # language-level sense. + # + # ``default: None`` is therefore the accurate record for a Struct field, + # not a placeholder. Note the reference oracle types some of these fields + # ``required: true`` with no default (the dataclass declares them without + # one); Ruby's Struct cannot express a required field, and that + # divergence is pre-existing and governed as before — it is NOT changed + # here, since this pass is additive to ``default`` only. params = [{"name": "self", "kind": "self"}] + [ {"name": f, "type": "any", "kind": "keyword", "required": False, "default": None} for f in readers @@ -1480,7 +1495,20 @@ def build_signature(method: dict, instance_method: bool) -> dict: # for the generated REST bodies' `**kwargs` forward-compat tail.) if ruby_kind in ("opt", "key", "block", "rest", "keyrest"): param["required"] = False - param["default"] = None + # The DEFAULT VALUE comes from signature_dump.rb's Ripper source + # parse (Method#parameters reports only that a default EXISTS, never + # what it IS -- see that script's block comment). ``has_default`` + # marks a literal that was actually recovered, which is what lets a + # recovered literal ``nil`` (``def f(x = nil)``) stay distinct from + # "not statically recoverable" (``def f(x = SOME_CONST)``). Both + # emit ``default: None``, but only the former is a real match -- + # they are recorded identically because the reference oracle has no + # third state either, so an unrecovered default is reported below + # rather than encoded here. + # + # A splat (*args/**kwargs) and a block have no default expression at + # all; they are optional by nature and keep ``default: None``. + param["default"] = p.get("default") if p.get("has_default") else None else: param["required"] = True params_out.append(param) diff --git a/scripts/signature_dump.rb b/scripts/signature_dump.rb index a47d4a6f..b4c20c6b 100755 --- a/scripts/signature_dump.rb +++ b/scripts/signature_dump.rb @@ -13,10 +13,272 @@ # typed divergence. require 'json' +require 'ripper' require_relative '../lib/signalwire' +# --------------------------------------------------------------------------- +# DEFAULT-VALUE recovery (source parse, joined to reflection by source_location) +# +# ``Method#parameters`` reports that a default EXISTS (:opt / :key) but never +# what it IS -- the value is compiled away and the reflection API has no accessor +# for it. That is a hard limit of Ruby reflection, not an oversight: +# +# class T; def m(a, b = 42, c: "hi"); end; end +# T.instance_method(:m).parameters +# #=> [[:req, :a], [:opt, :b], [:key, :c]] +# +# So a default VALUE can only come from the SOURCE. This pass parses every +# lib/**/*.rb with ``Ripper`` (stdlib -- deliberately NOT the ``prism`` / +# ``parser`` gems, which are present only transitively as rubocop dependencies +# and would be an undeclared dev dep) and indexes each ``def`` node's parameter +# defaults by ``[realpath, line]``. +# +# That pair is the join key because ``Method#source_location`` returns exactly +# the file and line of the ``def`` keyword, and Ripper's ``def`` node carries the +# same line for its method-name token. The join is therefore EXACT -- it needs no +# class/method name matching, so it cannot mis-attribute an overload, a +# same-named method on another class, or a method reached through include. +# +# LITERALS ONLY. A default that is a non-literal EXPRESSION (``SOME_CONST``, +# ``compute()``, ``other * 2``, an interpolated string) has no static value; this +# pass records ``nil`` for it rather than evaluating it or inventing one. Emitting +# a guessed value would be worse than emitting none -- it makes a correct port +# look defective, and "fixing" the port to match a wrong default can introduce a +# real defect. See DEFAULT_LITERAL_BLIND_SPOTS below for the exact list. +# --------------------------------------------------------------------------- + +# Sentinel distinguishing "no static value recoverable" from a literal ``nil`` +# default. ``def f(x = nil)`` genuinely defaults to nil and must be recorded as +# such; ``def f(x = CONST)`` must not be recorded at all. +NO_STATIC_DEFAULT = Object.new.freeze + +# Convert a Ripper value sexp to its literal Ruby value, or NO_STATIC_DEFAULT +# when it is not a static literal. +# +# Handled: integers (incl. 0x/0b/underscored), floats, rationals/imaginaries, +# true/false/nil, strings (rejecting interpolation), symbols, and empty +# array/hash literals. Everything else -- constants, method calls, operators, +# ranges, non-empty collections -- is NOT a static value. +def ripper_literal(node) + return NO_STATIC_DEFAULT unless node.is_a?(Array) + + case node[0] + when :@int then ripper_numeric(node[1], Integer) + when :@float then ripper_numeric(node[1], Float) + when :var_ref, :vcall then ripper_keyword_literal(node[1]) + when :string_literal then ripper_string_literal(node[1]) + when :symbol_literal then ripper_symbol_literal(node[1]) + # A bare word inside a %w[] / %i[] list -- Ripper emits the raw token with + # no enclosing :string_literal. + when :@tstring_content then node[1] + when :array then ripper_array_literal(node[1]) + when :hash then ripper_hash_literal(node[1]) + else NO_STATIC_DEFAULT + end +end + +# Integer()/Float() rather than to_i/to_f: they honour 0x/0o/0b radix prefixes +# and ``_`` separators, where a bare to_i would silently turn "0x1f" into 0. +def ripper_numeric(token, converter) + converter.call(token) +rescue ArgumentError, TypeError + NO_STATIC_DEFAULT +end + +# Only the true/false/nil KEYWORDS are literals. A :@const (SOME_CONST) or an +# :@ident (a local or method call) is not. +def ripper_keyword_literal(inner) + return NO_STATIC_DEFAULT unless inner.is_a?(Array) && inner[0] == :@kw + + case inner[1] + when 'true' then true + when 'false' then false + when 'nil' then nil + else NO_STATIC_DEFAULT + end +end + +def ripper_string_literal(content) + return NO_STATIC_DEFAULT unless content.is_a?(Array) && content[0] == :string_content + + parts = content[1..] || [] + # Any embedded expression (``"a#{x}b"``) means the value is computed at call + # time. Ripper would otherwise hand back the concatenated static fragments + # ("ab"), which is a FABRICATED value -- reject it. + return NO_STATIC_DEFAULT unless parts.all? { |p| p.is_a?(Array) && p[0] == :@tstring_content } + + parts.map { |p| p[1] }.join +end + +def ripper_symbol_literal(sym) + return NO_STATIC_DEFAULT unless sym.is_a?(Array) && sym[0] == :symbol + + tok = sym[1] + tok.is_a?(Array) ? tok[1].to_s : NO_STATIC_DEFAULT +end + +# Resolve every element; ONE non-literal element makes the whole array +# non-static (a partially-reconstructed collection would be a fabricated value). +def ripper_array_literal(elements) + return [] if elements.nil? + return NO_STATIC_DEFAULT unless elements.is_a?(Array) + + out = [] + elements.each do |el| + val = ripper_literal(el) + return NO_STATIC_DEFAULT if val.equal?(NO_STATIC_DEFAULT) + + out << val + end + out +end + +def ripper_hash_literal(assoclist) + return {} if assoclist.nil? + return NO_STATIC_DEFAULT unless assoclist.is_a?(Array) && assoclist[0] == :assoclist_from_args + + pairs = assoclist[1] + return NO_STATIC_DEFAULT unless pairs.is_a?(Array) + + out = {} + pairs.each do |pair| + key, val = ripper_hash_pair(pair) + return NO_STATIC_DEFAULT if key.equal?(NO_STATIC_DEFAULT) || val.equal?(NO_STATIC_DEFAULT) + + out[key] = val + end + out +end + +# [key, value] for one ``k => v`` / ``k: v`` pair, either being +# NO_STATIC_DEFAULT when unresolvable. A ``**splat`` (:assoc_splat) is not a +# plain pair and makes the hash non-static. +def ripper_hash_pair(pair) + return [NO_STATIC_DEFAULT, nil] unless pair.is_a?(Array) && pair[0] == :assoc_new + + key_node = pair[1] + key = + if key_node.is_a?(Array) && key_node[0] == :@label + # ``k:`` shorthand -- the key is the SYMBOL :k, recorded as the bare name + # to match how a symbol default is recorded above. + key_node[1].to_s.chomp(':') + else + ripper_literal(key_node) + end + [key, ripper_literal(pair[2])] +end + +# Extract {param_name => literal_value} for one Ripper ``params`` node. +# Only params that HAVE a recoverable literal default appear in the result. +def ripper_param_defaults(params_node) + # ``def m(...)`` with parens wraps params in a :paren node. + params_node = params_node[1] if params_node.is_a?(Array) && params_node[0] == :paren + return {} unless params_node.is_a?(Array) && params_node[0] == :params + + # [:params, reqs, optionals, rest, post_reqs, keywords, kwrest, block] + out = collect_defaults(params_node[2]) { |name_node| name_node[1].to_s } + # Keyword label tokens are "name:" -- strip the trailing colon. + out.merge(collect_defaults(params_node[5]) { |label_node| label_node[1].to_s.chomp(':') }) +end + +# Shared walk over an optionals/keywords list of [name_node, value_node] pairs. +# Only entries whose default resolves to a literal are returned. +def collect_defaults(entries) + out = {} + (entries || []).each do |name_node, value_node| + next unless name_node.is_a?(Array) + # A REQUIRED keyword (``f:``) has value_node == false -- no default at all. + next if value_node == false || value_node.nil? + + val = ripper_literal(value_node) + out[yield(name_node)] = val unless val.equal?(NO_STATIC_DEFAULT) + end + out +end + +# [realpath, def_line] => {param_name => literal_default}, for every ``def`` in +# lib/. Built once; consulted per reflected method via #source_location. +def build_default_index + index = {} + Dir[File.join(__dir__, '..', 'lib', '**', '*.rb')].each do |path| + sexp = parse_file(path) + # A file Ripper cannot parse contributes no defaults; its params then stay + # null, i.e. honestly unrecovered rather than wrong. + next if sexp.nil? + + real = File.realpath(path) + walk_sexp(sexp) do |node| + line, params_node = def_node_parts(node) + next if line.nil? + + defaults = ripper_param_defaults(params_node) + index[[real, line]] = defaults unless defaults.empty? + end + end + index +end + +def parse_file(path) + Ripper.sexp(File.read(path)) +rescue StandardError + nil +end + +# [def_line, params_node] for a ``def``/``def self.`` node, or [nil, nil]. +# :def => [:def, name_token, params, body] +# :defs => [:defs, target, op, name_token, params, body] +def def_node_parts(node) + name_tok, params_node = + case node[0] + when :def then [node[1], node[2]] + when :defs then [node[3], node[4]] + else return [nil, nil] + end + return [nil, nil] unless name_tok.is_a?(Array) && name_tok[2].is_a?(Array) + + [name_tok[2][0], params_node] +end + +def walk_sexp(node, &block) + return unless node.is_a?(Array) + + yield(node) if node[0].is_a?(Symbol) + node.each { |child| walk_sexp(child, &block) } +end + +DEFAULT_INDEX = build_default_index + +# Literal defaults for this method, keyed by param name. Empty when the method +# has no source location (C-defined / dynamically defined via define_method) or +# no literal-valued defaults. +def defaults_for(meth) + loc = begin + meth.source_location + rescue StandardError + nil + end + return {} if loc.nil? + + DEFAULT_INDEX[[realpath_or_self(loc[0]), loc[1]]] || {} +end + +def realpath_or_self(path) + File.realpath(path) +rescue StandardError + path +end + def method_entry(meth, name, is_constructor:, is_static:) - parameters = meth.parameters.map { |kind, pname| { kind: kind.to_s, name: pname.to_s } } + defaults = defaults_for(meth) + parameters = meth.parameters.map do |kind, pname| + entry = { kind: kind.to_s, name: pname.to_s } + # Emit ``default`` ONLY when a literal was actually recovered. Its ABSENCE + # means "not recoverable", which the wrapper keeps as null -- distinct from a + # recovered literal ``nil`` default, which is present with a nil value. + entry[:default] = defaults[pname.to_s] if defaults.key?(pname.to_s) + entry[:has_default] = defaults.key?(pname.to_s) + entry + end { name: name, is_constructor: is_constructor, is_static: is_static, parameters: parameters } end From d71247608539431447a6a61574f6063ddaf0b4d2 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 21:30:49 -0400 Subject: [PATCH 08/90] fix(enumerator): Integer()/Float() are methods, not callable objects MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Self-inflicted in 1fa058c's rubocop-driven refactor: extracting the numeric arms of ripper_literal into a shared `ripper_numeric(token, converter)` passed `Integer` / `Float` as a converter and called `converter.call(token)`. Those are Kernel METHODS, not procs — the constants name the CLASSES, which have no #call — so every integer/float default raised NoMethodError, taking the whole dump (and therefore the SIGNATURES gate) down with exit 1. Split into ripper_integer / ripper_float, which call Kernel#Integer / #Float directly. Behaviour is otherwise unchanged: 330 non-null defaults, including the 23 int + 6 float ones this bug was destroying. The committed port_signatures.json was NOT stale — a regen after this fix reproduces it byte-for-byte (git diff empty), because 1fa058c's artifact was generated before the refactor introduced the fault. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- scripts/signature_dump.rb | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/scripts/signature_dump.rb b/scripts/signature_dump.rb index b4c20c6b..2fb47d75 100755 --- a/scripts/signature_dump.rb +++ b/scripts/signature_dump.rb @@ -63,8 +63,8 @@ def ripper_literal(node) return NO_STATIC_DEFAULT unless node.is_a?(Array) case node[0] - when :@int then ripper_numeric(node[1], Integer) - when :@float then ripper_numeric(node[1], Float) + when :@int then ripper_integer(node[1]) + when :@float then ripper_float(node[1]) when :var_ref, :vcall then ripper_keyword_literal(node[1]) when :string_literal then ripper_string_literal(node[1]) when :symbol_literal then ripper_symbol_literal(node[1]) @@ -79,8 +79,16 @@ def ripper_literal(node) # Integer()/Float() rather than to_i/to_f: they honour 0x/0o/0b radix prefixes # and ``_`` separators, where a bare to_i would silently turn "0x1f" into 0. -def ripper_numeric(token, converter) - converter.call(token) +# (Kernel#Integer / Kernel#Float are METHODS, not callable objects -- they cannot +# be passed as a converter argument.) +def ripper_integer(token) + Integer(token) +rescue ArgumentError, TypeError + NO_STATIC_DEFAULT +end + +def ripper_float(token) + Float(token) rescue ArgumentError, TypeError NO_STATIC_DEFAULT end From c5daf0cf115a043f53cdbdd7ff3e68ec1b6a5254 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 21:58:34 -0400 Subject: [PATCH 09/90] fold(web): WebService.start host default 127.0.0.1 -> 0.0.0.0 (reference parity) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ruby's WebService.start defaulted to '127.0.0.1', so a ruby agent started with defaults accepted LOOPBACK ONLY — a containerised or remote-hosted ruby agent silently failed where every other port worked. The reference (signalwire/signalwire/web/web_service.py:543) defaults to "0.0.0.0" and carries an explicit deliberate-choice marker: host: str = "0.0.0.0", # noqa: S104 # intended server default: listen on # all interfaces (overridable) so the wide bind is considered, not an oversight. Owner ruled to fold ruby to match, accepting the widened default network exposure for fleet parity. Verified line 79 is the live server-start path: start(host:) flows to build_server -> WEBrick BindAddress with nothing overriding it in between. - default folded; explicit start(host: ...) is unchanged and still honoured - doc comment records the rationale so a future reader does not "harden" it back - test_default_host_binds_all_interfaces exercises the DEFAULT path (start() called with no host: kwarg) and asserts both the WEBrick BindAddress config and the actual bound listener address — mutation-tested: reverting the default to '127.0.0.1' turns it RED - test_explicit_host_overrides_default pins the override behaviour - port_signatures.json regenerated (ruby enumerates real default VALUES since 1fa058c, so the host value lives in the artifact) run-ci: exit 0, 22/22 PASS (unchanged from baseline). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/web/web_service.rb | 8 +++++++- port_signatures.json | 2 +- tests/web_web_service_test.rb | 29 +++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+), 2 deletions(-) diff --git a/lib/signalwire/web/web_service.rb b/lib/signalwire/web/web_service.rb index 15aa7569..a48ac1ae 100644 --- a/lib/signalwire/web/web_service.rb +++ b/lib/signalwire/web/web_service.rb @@ -76,7 +76,13 @@ def remove_directory(route) # Start the service. Non-blocking by default (runs WEBrick in a background # thread and returns the bound port). Pass +block: true+ to run in the # foreground. +port+ 0 binds an ephemeral port. - def start(host: '127.0.0.1', port: nil, ssl_cert: nil, ssl_key: nil, block: false) + # + # +host+ defaults to '0.0.0.0' -- the INTENDED server default: listen on all + # interfaces so a containerised or remote-hosted agent is reachable. This + # matches the reference (signalwire/web/web_service.py, which carries the same + # deliberate-choice marker). It is not an oversight; do NOT "harden" it back to + # '127.0.0.1' -- pass +host: '127.0.0.1'+ explicitly for loopback-only binding. + def start(host: '0.0.0.0', port: nil, ssl_cert: nil, ssl_key: nil, block: false) bind_port = port || @port @server = build_server(host, bind_port, ssl_cert, ssl_key) @directories.each { |route, directory| mount_directory(route, directory) } diff --git a/port_signatures.json b/port_signatures.json index dde7bab6..8f6157c9 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -40759,7 +40759,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": "127.0.0.1" + "default": "0.0.0.0" }, { "name": "port", diff --git a/tests/web_web_service_test.rb b/tests/web_web_service_test.rb index c3aa8979..0bffa8bf 100644 --- a/tests/web_web_service_test.rb +++ b/tests/web_web_service_test.rb @@ -106,4 +106,33 @@ def test_file_allowed_predicate def test_start_returns_bound_ephemeral_port assert_operator @port, :>, 0 end + + # The DEFAULT host must be '0.0.0.0' (listen on all interfaces), matching the + # Python reference. Exercises the default path: start() is called with NO host: + # kwarg, and we read back the address WEBrick was actually bound to. + def test_default_host_binds_all_interfaces + svc = SignalWire::Web::WebService.new(basic_auth: [USER, PASS]) + svc.add_directory('/static', @dir) + svc.start(port: 0) + + server = svc.instance_variable_get(:@server) + + assert_equal '0.0.0.0', server.config[:BindAddress] + assert_includes server.listeners.map { |l| l.addr[3] }, '0.0.0.0' + ensure + svc&.stop + end + + # An explicit host: must still be honoured -- only the DEFAULT changed. + def test_explicit_host_overrides_default + svc = SignalWire::Web::WebService.new(basic_auth: [USER, PASS]) + svc.add_directory('/static', @dir) + svc.start(host: '127.0.0.1', port: 0) + + server = svc.instance_variable_get(:@server) + + assert_equal '127.0.0.1', server.config[:BindAddress] + ensure + svc&.stop + end end From c36ddd0faa5ca08f8e16c0f4d1a711d86f8e7060 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 27 Jul 2026 23:43:43 -0400 Subject: [PATCH 10/90] fix(parity): burn required-flip/default-invented/default-mismatch to zero MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The unified drift checker (porting-sdk 90164e9) now compares `required` and `default` on ALL params, not just __init__. That surfaced 61 ruby findings: 25 required-flip, 21 default-invented, 15 default-mismatch. RESULT: required-flip 25->0, default-invented 21->0, default-mismatch 15->1. The one remaining default-mismatch is positional collateral of a separate param-count-mismatch (ruby's AgentBase#define_tool carries wait_file / wait_file_loops, which the reference's ToolMixin.define_tool does not; they shift is_typed_handler by two slots). Not this change's kind. SOURCE FIXES — the handler/callback contract -------------------------------------------- The reference declares the handler REQUIRED on every registration method, and so does every other port (verified against ts/go/php/perl port_signatures). Ruby declared them `&block`-only, which the enumerator records as an optional `block` keyword — a caller could "register" nothing and silently get a dead callback. These now take the callable as a REQUIRED positional, with the block still accepted (and winning) for the idiomatic body form: RelayClient#on_call / #on_message, Call#on, Message#on_event, AgentBase#on_debug_event / #set_dynamic_config_callback, SWMLService#register_routing_callback, AgentServer#register_global_routing_callback Ruby cannot let a block satisfy a required positional, so `client.on_call { }` becomes `client.on_call(nil) { }`. That is the intended breaking consequence. `register_routing_callback` additionally had its parameters in the WRONG ORDER: ruby was `(path, &block)`, the reference is `(callback_fn, path="/sip")`. SOURCE FIXES — port-invented overloads removed ---------------------------------------------- `add_language` and `add_pattern_hint` had made every reference-required positional optional to support extra call shapes with no reference counterpart: * `add_language(config_hash)` and the braceless `add_language('name' => ...)` — the reference spells that capability #set_languages. * `add_pattern_hint(pattern, hint:, language:)` — this one also emitted a DIFFERENT wire shape (`{pattern, hint, language}` vs the reference's `{hint, pattern, replace, ignore_case}`), so it was invented wire surface. Both are removed; name/code/voice and hint/pattern/replace are now required. SOURCE FIXES — default values ----------------------------- * prompt_add_section / prompt_add_subsection `body`: nil -> '' (reference `body: str = ""`). agent_base.rb disagreed with the port's own core/agent/prompt/manager.rb, which was already correct. Ruby's '' is truthy where python's is falsy, so the emitters now omit an empty body explicitly — the wire is unchanged. * add_skill `params`: {} -> nil (reference `= None`), normalised to {} before the factory so no registered factory meets a nil. * RelayClient#dial: `timeout: 120, **kwargs` -> `tag:, max_duration:, dial_timeout:` — the reference's exact keywords, with the 120s fallback applied at the wait where python applies it, and max_duration promoted from a **kwargs passenger to an explicit keyword that reaches the wire only when truthy. * define_tool `parameters:`/`handler:` required on BOTH AgentBase and ToolRegistry (reference requires both). Reverse-direction flips (port REQUIRED where the reference defaults): add_answer_verb(config), on_function_call(raw_data), serve_static_files(route), InfoGatherer handle_start/handle_submit(raw_data). ENUMERATOR FIXES ---------------- 1. signature_dump.rb dropped CONSTANT-reference defaults. `format: RecordFormat::WAV` is exactly as fixed as `format: 'wav'`, but the Ripper pass recorded null, reporting five correct FunctionResult params as drift (record_call format/direction, tap direction/codec, pay ai_response). Constants are now resolved against the defining module's namespace chain (Method#owner is the lexical scope Ruby itself would use), rejecting anything that is not a JSON-representable value rather than fabricating one. 2. enumerate_signatures.py's MIXIN_PROJECTIONS CLOBBERED a real method on the target class. Ruby declares its own PromptManager#define_contexts(contexts) — required, matching the reference's PromptManager — but the projection overwrote it with AgentBase's optional one, whose reference counterpart (PromptMixin) is deliberately optional. The two reference methods genuinely differ. A projection now FILLS only what the target is missing, while still CLAIMING every name it covers so the AgentBase donor copy is popped (popping only the filled ones stranded set_prompt_pom on AgentBase, where the reference has no counterpart). VERIFICATION ------------ * tests/reference_required_and_defaults_test.rb: 27 new tests pinning both properties. Required-ness is asserted on the SIGNATURE (Method#parameters :req vs :opt) as well as behaviourally — mutation proved the behavioural assertion alone is VACUOUS here, because these methods raise from their own guard whether the param is required or optional-with-nil. * Defaults are asserted with the argument OMITTED, never passed explicitly. Where the wire cannot distinguish two candidate defaults (body ''/nil, add_skill {}/nil), the declared default itself is asserted — again found by mutation, which survived the wire-level assertion. * 24 mutations run across all three kinds (22 source + 2 enumerator); all 24 RED when reverted, GREEN when restored. * bash scripts/run-ci.sh -> exit 0, 22/22 PASS (baseline was 22/22). * 2696 tests, 0 failures, 0 errors. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- README.md | 5 +- bin/emit-skills | 2 +- bin/http-dump | 6 +- bin/relay-liveness-dump | 4 +- bin/secure-default-dump | 4 +- bin/state-dump | 5 +- bin/strict-render-dump | 8 +- bin/swml-dump | 4 +- bin/wait-liveness-dump | 2 +- examples/call_flow_and_actions_demo.rb | 8 +- examples/comprehensive_dynamic_agent.rb | 2 +- examples/concierge_agent_example.rb | 4 +- examples/contexts_demo.rb | 4 +- examples/custom_path_agent.rb | 2 +- examples/declarative_agent.rb | 6 +- examples/dynamic_swml_service.rb | 4 +- examples/faq_bot_agent.rb | 4 +- .../gather_per_question_functions_demo.rb | 10 +- examples/info_gatherer_example.rb | 4 +- examples/kubernetes_ready_agent.rb | 2 +- examples/lambda_agent.rb | 4 +- examples/llm_params_demo.rb | 6 +- examples/mcp_agent.rb | 4 +- examples/multi_agent_server.rb | 6 +- examples/multi_endpoint_agent.rb | 4 +- examples/quickstart_agent.rb | 3 +- examples/quickstart_relay.rb | 2 +- examples/receptionist_agent_example.rb | 4 +- examples/relay_answer_and_welcome.rb | 4 +- examples/session_and_state_demo.rb | 6 +- examples/simple_agent.rb | 4 +- examples/simple_dynamic_agent.rb | 4 +- examples/simple_dynamic_enhanced.rb | 2 +- examples/step_function_inheritance_demo.rb | 6 +- examples/survey_agent_example.rb | 6 +- examples/swml_service_routing_example.rb | 4 +- examples/swmlservice_ai_sidecar.rb | 2 +- lib/signalwire/agent/agent_base.rb | 225 +++++----- lib/signalwire/core/agent/tools/registry.rb | 5 +- lib/signalwire/prefabs/info_gatherer.rb | 4 +- lib/signalwire/relay/call.rb | 13 +- lib/signalwire/relay/client.rb | 48 ++- lib/signalwire/relay/message.rb | 11 +- lib/signalwire/server/agent_server.rb | 10 +- lib/signalwire/skills/skill_base.rb | 4 +- lib/signalwire/swml/service.rb | 18 +- port_signatures.json | 210 +++++----- scripts/enumerate_signatures.py | 23 +- scripts/signature_dump.rb | 122 +++++- tests/agent_test.rb | 97 +++-- tests/aiconfig_contract_test.rb | 3 +- tests/aiconfig_test.rb | 42 +- tests/bedrock_agent_test.rb | 2 +- tests/behavior_bundle_test.rb | 3 +- tests/cli_test.rb | 2 +- tests/function_result_test.rb | 51 +++ tests/handle_request_core_test.rb | 10 +- tests/lambda_agent_test.rb | 18 +- tests/mcp_test.rb | 2 +- tests/parameter_schema_test.rb | 4 +- tests/reference_required_and_defaults_test.rb | 394 ++++++++++++++++++ tests/relay/actions_mock_test.rb | 2 +- tests/relay/convenience_mock_test.rb | 2 +- tests/relay/event_dispatch_mock_test.rb | 6 +- tests/relay/inbound_call_mock_test.rb | 10 +- tests/relay/messaging_mock_test.rb | 2 +- tests/relay/outbound_call_mock_test.rb | 8 +- tests/relay/tier3_typed_objects_test.rb | 4 +- tests/relay_test.rb | 4 +- tests/render_test.rb | 2 +- tests/rest_relay_parity_test.rb | 15 +- tests/schema_utils_test.rb | 4 +- tests/secure_default_test.rb | 10 +- tests/served_routing_redirect_test.rb | 2 +- tests/serverless_dispatch_test.rb | 2 +- tests/simulate_serverless_test.rb | 2 +- tests/sip_served_routing_test.rb | 2 +- tests/swml_service_swaig_test.rb | 2 +- tests/swml_strict_render_test.rb | 8 +- tests/swml_test.rb | 2 +- tests/tool_registry_test.rb | 21 +- tests/tool_test.rb | 17 +- tests/tool_token_test.rb | 2 +- tests/web_test.rb | 23 +- 84 files changed, 1132 insertions(+), 502 deletions(-) create mode 100644 tests/reference_required_and_defaults_test.rb diff --git a/README.md b/README.md index ce4fbbef..8778d653 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,8 @@ AGENT.prompt_add_section('Role', 'You are a helpful assistant.') AGENT.define_tool( name: 'get_time', description: 'Get the current time', - parameters: {} + parameters: {}, + handler: nil # the block below is the handler ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("The time is #{Time.now.strftime('%H:%M:%S')}") end @@ -139,7 +140,7 @@ client = SignalWire::Relay::Client.new( contexts: ['default'] ) -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play([{ 'type' => 'tts', 'params' => { 'text' => 'Welcome!' } }]) action.wait diff --git a/bin/emit-skills b/bin/emit-skills index 8779d3d7..471da747 100755 --- a/bin/emit-skills +++ b/bin/emit-skills @@ -87,7 +87,7 @@ end # differ compares. Skills register tools in one of two shapes: # * handler tool — { name:, description:, parameters:, required?:, handler: } # where `parameters` is the flat {param => {type, ...}} map and `required` is -# an optional separate list (mirrors agent define_tool(parameters:, required:)). +# an optional separate list (mirrors agent define_tool(parameters:, required:, handler: nil)). # * DataMap tool — { datamap: }, where the # name lives under "function" and the WRAPPED param schema (with its own # `required` array) under "parameters". diff --git a/bin/http-dump b/bin/http-dump index 1e1e1752..cba87bb4 100755 --- a/bin/http-dump +++ b/bin/http-dump @@ -124,7 +124,7 @@ end # agent-relative (the Go reference does the same). def serverless_swaig a = SignalWire::AgentBase.new(name: 'demo', route: '/', basic_auth: [USER, PASSWORD]) - a.define_tool(name: 'say_hello', description: 'greet', parameters: {}) do |_args, _raw| + a.define_tool(name: 'say_hello', description: 'greet', parameters: {}, handler: nil) do |_args, _raw| SignalWire::Swaig::FunctionResult.new('hello there') end event = { @@ -170,7 +170,7 @@ out['http_handle_request_401_bad_password'] = observe_response(status, headers, # ---- handle_request: 307 redirect via routing callback ---- svc = new_swml_service cb = redirect_cb -svc.register_routing_callback('/sip', &cb) +svc.register_routing_callback(cb, '/sip') status, headers, body = svc.handle_request('POST', 'http://localhost:3000/swml/sip', { 'Authorization' => basic_auth(USER, PASSWORD) }, { 'call' => { 'to' => 'sip:redirect-me@space' } }) @@ -178,7 +178,7 @@ out['http_handle_request_307_redirect'] = observe_response(status, headers, body # ---- handle_request: callback returns nil -> normal 200 SWML ---- svc = new_swml_service -svc.register_routing_callback('/sip', &cb) +svc.register_routing_callback(cb, '/sip') status, headers, body = svc.handle_request('POST', 'http://localhost:3000/swml/sip', { 'Authorization' => basic_auth(USER, PASSWORD) }, { 'call' => { 'to' => 'sip:keep@space' } }) diff --git a/bin/relay-liveness-dump b/bin/relay-liveness-dump index c22d30f6..cad8e394 100755 --- a/bin/relay-liveness-dump +++ b/bin/relay-liveness-dump @@ -397,7 +397,7 @@ def drive_max_active_calls(cap) clear_relay_env client = SignalWire::Relay::Client.new(project: 'p', token: 't', host: 'x', max_active_calls: cap) - client.on_call { |_call| sleep 5 } # keep each accepted call "active" + client.on_call(nil) { |_call| sleep 5 } # keep each accepted call "active" (cap + 1).times do |i| client.send(:handle_inbound_call, 'params' => { 'call_id' => "c#{i}", 'node_id' => 'node-relay-live', @@ -436,7 +436,7 @@ def build_answered_call(handle) client = handle[:client] mock = handle[:mock] captured = Queue.new - client.on_call do |call| + client.on_call(nil) do |call| call.answer captured.push(call) end diff --git a/bin/secure-default-dump b/bin/secure-default-dump index aa773b43..5e344f59 100755 --- a/bin/secure-default-dump +++ b/bin/secure-default-dump @@ -126,14 +126,14 @@ def main # its rendered entry carries its own web_hook_url with a __token query param. out['define_tool_default_is_secure'] = emit('sd_default_secure') do |a| a.define_tool(name: 'sd_default_secure', description: 'A default-secure tool', - parameters: { 'q' => { 'type' => 'string' } }) { |_args, _raw| nil } + parameters: { 'q' => { 'type' => 'string' } }, handler: nil) { |_args, _raw| nil } end # A1 (b): a tool defined with secure: false must be INSECURE → NO per-tool # web_hook_url key at all (it falls back to SWAIG.defaults.web_hook_url). out['define_tool_explicit_insecure'] = emit('sd_explicit_insecure') do |a| a.define_tool(name: 'sd_explicit_insecure', description: 'An explicitly-insecure tool', - parameters: { 'q' => { 'type' => 'string' } }, secure: false) { |_args, _raw| nil } + parameters: { 'q' => { 'type' => 'string' } }, secure: false, handler: nil) { |_args, _raw| nil } end REAL_STDOUT.puts(JSON.generate(out)) diff --git a/bin/state-dump b/bin/state-dump index 71101096..27b515f3 100755 --- a/bin/state-dump +++ b/bin/state-dump @@ -128,8 +128,9 @@ out['server_unregister'] = s.get_agents.keys.sort # ---- routing-callback registration on SWMLService (path-normalized) ---- svc = SignalWire::SWML::Service.new(name: 'svc', route: '/svc') noop = ->(_body, _headers) {} -svc.register_routing_callback('/sip/', &noop) -svc.register_routing_callback('voice', &noop) +# Reference param ORDER is (callback_fn, path="/sip"): callback first, path second. +svc.register_routing_callback(noop, '/sip/') +svc.register_routing_callback(noop, 'voice') out['state_register_routing_callback'] = ivar(svc, :@routing_callbacks).keys.sort # ---- verb-handler registration (VerbHandlerRegistry: ai preloaded) ---- diff --git a/bin/strict-render-dump b/bin/strict-render-dump index 569a9ffa..9467ad54 100755 --- a/bin/strict-render-dump +++ b/bin/strict-render-dump @@ -144,14 +144,18 @@ end # ================================================================ out['strict_dangling_step_function'] = run_agent_case do |agent, builder| - agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}) { |_a, _r| nil } + agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}, handler: nil) do |_a, _r| + nil + end ctx_add_step(agent, builder, context: 'default', step: 'help', text: 'help', functions: %w[order_status get_datetime]) builder.to_h end out['strict_registered_step_function_ok'] = run_agent_case do |agent, builder| - agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}) { |_a, _r| nil } + agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}, handler: nil) do |_a, _r| + nil + end ctx_add_step(agent, builder, context: 'default', step: 'help', text: 'help', functions: %w[order_status]) builder.to_h diff --git a/bin/swml-dump b/bin/swml-dump index 63823423..011833af 100755 --- a/bin/swml-dump +++ b/bin/swml-dump @@ -105,7 +105,7 @@ out['swml_add_language'] = extract(render(a), 'ai.languages') # swml_add_pattern_hint: structured hint into ai.hints. a = new_agent -a.add_pattern_hint(hint: 'SignalWire', pattern: 'signal wire', replace: 'SignalWire', ignore_case: true) +a.add_pattern_hint('SignalWire', 'signal wire', 'SignalWire', ignore_case: true) out['swml_add_pattern_hint'] = extract(render(a), 'ai.hints') # swml_add_hint: a plain string hint. @@ -132,7 +132,7 @@ a = new_agent a.define_tool(name: 'lookup', description: 'Look up a thing', parameters: { 'type' => 'object', 'properties' => { 'q' => { 'type' => 'string' } }, - 'required' => ['q'] }) { |_args, _raw| nil } + 'required' => ['q'] }, handler: nil) { |_args, _raw| nil } out['swml_define_tool_complete_schema'] = swaig_field(extract(render(a), 'ai.SWAIG.functions'), 'lookup', 'parameters') diff --git a/bin/wait-liveness-dump b/bin/wait-liveness-dump index f86bed5a..f098e648 100755 --- a/bin/wait-liveness-dump +++ b/bin/wait-liveness-dump @@ -129,7 +129,7 @@ def run_case(handle, kase) # Establish an answered inbound call (mirrors RelayActionsTestBase helper). captured = Queue.new done = Queue.new - client.on_call do |call| + client.on_call(nil) do |call| captured.push(call) call.answer done.push(true) diff --git a/examples/call_flow_and_actions_demo.rb b/examples/call_flow_and_actions_demo.rb index 60eb3a2c..655998b2 100644 --- a/examples/call_flow_and_actions_demo.rb +++ b/examples/call_flow_and_actions_demo.rb @@ -49,7 +49,7 @@ agent.enable_debug_events(2) # Level 2 for detailed events -agent.on_debug_event do |event_type, event_data| +agent.on_debug_event(nil) do |event_type, event_data| puts "[DEBUG] #{event_type}: #{event_data.inspect}" end @@ -62,7 +62,7 @@ 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, 'check_out' => { 'type' => 'string', 'description' => 'Check-out date (YYYY-MM-DD)' }, 'room_type' => { 'type' => 'string', 'description' => 'Room type: standard, deluxe, suite' } - } + }, handler: nil ) do |args, _raw_data| SignalWire::Swaig::FunctionResult.new( "#{args['room_type']&.capitalize} room available from #{args['check_in']} " \ @@ -78,7 +78,7 @@ 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, 'check_out' => { 'type' => 'string', 'description' => 'Check-out date (YYYY-MM-DD)' }, 'room_type' => { 'type' => 'string', 'description' => 'Room type' } - } + }, handler: nil ) do |args, _raw_data| conf_num = "RES-#{rand(100_000..999_999)}" result = SignalWire::Swaig::FunctionResult.new( @@ -93,7 +93,7 @@ agent.define_tool( name: 'transfer_to_front_desk', description: 'Transfer the call to the front desk', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| result = SignalWire::Swaig::FunctionResult.new( 'Transferring you to the front desk now.' diff --git a/examples/comprehensive_dynamic_agent.rb b/examples/comprehensive_dynamic_agent.rb index 34cf141c..30f87ec6 100644 --- a/examples/comprehensive_dynamic_agent.rb +++ b/examples/comprehensive_dynamic_agent.rb @@ -27,7 +27,7 @@ record_call: true ) -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| tier = (query_params['tier'] || 'standard').downcase industry = (query_params['industry'] || 'general').downcase language = (query_params['language'] || 'en').downcase diff --git a/examples/concierge_agent_example.rb b/examples/concierge_agent_example.rb index 97e95b44..f8633803 100644 --- a/examples/concierge_agent_example.rb +++ b/examples/concierge_agent_example.rb @@ -67,7 +67,7 @@ description: 'Get information about a resort amenity', parameters: { 'amenity' => { 'type' => 'string', 'description' => 'Name of the amenity' } - } + }, handler: nil ) do |args, raw_data| concierge.handle_amenity_info(args, raw_data) end @@ -77,7 +77,7 @@ description: 'Get information about a resort service', parameters: { 'service' => { 'type' => 'string', 'description' => 'Name of the service' } - } + }, handler: nil ) do |args, raw_data| concierge.handle_service_info(args, raw_data) end diff --git a/examples/contexts_demo.rb b/examples/contexts_demo.rb index d6bada54..86b090af 100644 --- a/examples/contexts_demo.rb +++ b/examples/contexts_demo.rb @@ -71,7 +71,7 @@ description: 'Look up the status of an existing insurance claim', parameters: { 'claim_number' => { 'type' => 'string', 'description' => 'The claim number to look up' } - } + }, handler: nil ) do |args, _raw_data| claim = args['claim_number'] || 'unknown' SignalWire::Swaig::FunctionResult.new( @@ -88,7 +88,7 @@ 'date' => { 'type' => 'string', 'description' => 'Date of incident (YYYY-MM-DD)' }, 'description' => { 'type' => 'string', 'description' => 'Description of the incident' }, 'amount' => { 'type' => 'number', 'description' => 'Estimated damage amount in USD' } - } + }, handler: nil ) do |args, _raw_data| claim_num = "CLM-#{rand(100_000..999_999)}" result = SignalWire::Swaig::FunctionResult.new( diff --git a/examples/custom_path_agent.rb b/examples/custom_path_agent.rb index 20a86897..9ef38d8a 100644 --- a/examples/custom_path_agent.rb +++ b/examples/custom_path_agent.rb @@ -20,7 +20,7 @@ 'You are a friendly chat assistant ready to help with any questions or conversations.' ) -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| user_name = query_params['user_name'] || 'friend' topic = query_params['topic'] || 'general conversation' mood = (query_params['mood'] || 'friendly').downcase diff --git a/examples/declarative_agent.rb b/examples/declarative_agent.rb index 80b24178..d26a648c 100644 --- a/examples/declarative_agent.rb +++ b/examples/declarative_agent.rb @@ -49,7 +49,7 @@ agent.define_tool( name: 'get_time', description: 'Get the current time', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| now = Time.now.strftime('%H:%M:%S') SignalWire::Swaig::FunctionResult.new("The current time is #{now}") @@ -60,7 +60,7 @@ description: 'Get the current weather for a location', parameters: { 'location' => { 'type' => 'string', 'description' => 'City or location' } - } + }, handler: nil ) do |args, _raw_data| location = args['location'] || 'Unknown location' SignalWire::Swaig::FunctionResult.new("It's sunny and 72F in #{location}.") @@ -68,7 +68,7 @@ # --- Summary callback --- -agent.on_summary do |summary, _raw_data| +agent.on_summary(nil) do |summary, _raw_data| puts "Conversation summary: #{summary.inspect}" end diff --git a/examples/dynamic_swml_service.rb b/examples/dynamic_swml_service.rb index e25034c0..c3e83bfd 100644 --- a/examples/dynamic_swml_service.rb +++ b/examples/dynamic_swml_service.rb @@ -20,7 +20,7 @@ service.hangup # Register a callback for the /vip sub-path -service.register_routing_callback('/vip') do |request_data| +service.register_routing_callback(nil, '/vip') do |request_data| doc = SignalWire::SWML::Document.new doc.add_verb('answer', {}) @@ -34,7 +34,7 @@ end # Register a callback for the /new sub-path -service.register_routing_callback('/new') do |_request_data| +service.register_routing_callback(nil, '/new') do |_request_data| doc = SignalWire::SWML::Document.new doc.add_verb('answer', {}) doc.add_verb('play', { 'url' => 'say:Welcome to our service! Press 1 to learn about our products, 2 to speak with sales.' }) diff --git a/examples/faq_bot_agent.rb b/examples/faq_bot_agent.rb index 9e24250a..d3d94e81 100644 --- a/examples/faq_bot_agent.rb +++ b/examples/faq_bot_agent.rb @@ -50,7 +50,7 @@ description: 'Search the FAQ knowledge base', parameters: { 'query' => { 'type' => 'string', 'description' => 'Search query' } - } + }, handler: nil ) do |args, raw_data| faq_bot.handle_search(args, raw_data) end @@ -59,7 +59,7 @@ agent.post_prompt = 'Provide a JSON summary: {"question_type": "CATEGORY", "answered_from_kb": true/false, "follow_up_needed": true/false}' -agent.on_summary do |summary, _raw_data| +agent.on_summary(nil) do |summary, _raw_data| puts "FAQ Bot summary: #{summary.inspect}" end diff --git a/examples/gather_per_question_functions_demo.rb b/examples/gather_per_question_functions_demo.rb index 3f7d8cc8..6d5f097f 100644 --- a/examples/gather_per_question_functions_demo.rb +++ b/examples/gather_per_question_functions_demo.rb @@ -40,19 +40,19 @@ agent.define_tool( name: 'validate_email', description: 'Validate that an email address is well-formed and deliverable', - parameters: { 'email' => { 'type' => 'string' } } + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'valid' } } agent.define_tool( name: 'geocode_zip', description: 'Look up the city/state for a US ZIP code', - parameters: { 'zip' => { 'type' => 'string' } } + parameters: { 'zip' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => '{"city":"...","state":"..."}' } } agent.define_tool( name: 'check_age_eligibility', description: 'Verify the customer is old enough for the product', - parameters: { 'age' => { 'type' => 'integer' } } + parameters: { 'age' => { 'type' => 'integer' } }, handler: nil ) { |_args, _raw| { 'response' => 'eligible' } } # These tools are NOT whitelisted on any gather question. They are @@ -61,13 +61,13 @@ agent.define_tool( name: 'escalate_to_human', description: 'Transfer the conversation to a live agent', - parameters: {} + parameters: {}, handler: nil ) { |_args, _raw| { 'response' => 'transferred' } } agent.define_tool( name: 'lookup_existing_account', description: 'Search for an existing account by email', - parameters: { 'email' => { 'type' => 'string' } } + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'not found' } } # Build a single-context agent with one onboarding step. diff --git a/examples/info_gatherer_example.rb b/examples/info_gatherer_example.rb index 3fab41c0..8a91df1b 100644 --- a/examples/info_gatherer_example.rb +++ b/examples/info_gatherer_example.rb @@ -49,7 +49,7 @@ agent.define_tool( name: 'start_questions', description: 'Start the question sequence', - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| gatherer.handle_start(args, raw_data) end @@ -59,7 +59,7 @@ description: 'Submit an answer to the current question', parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's answer" } - } + }, handler: nil ) do |args, raw_data| gatherer.handle_submit(args, raw_data) end diff --git a/examples/kubernetes_ready_agent.rb b/examples/kubernetes_ready_agent.rb index 30c4ef7e..48f75ba0 100644 --- a/examples/kubernetes_ready_agent.rb +++ b/examples/kubernetes_ready_agent.rb @@ -31,7 +31,7 @@ agent.define_tool( name: 'health_status', description: 'Get the health status of this agent', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new( "Agent '#{agent.name}' is healthy, running on port #{agent.port} in Kubernetes." diff --git a/examples/lambda_agent.rb b/examples/lambda_agent.rb index 85a2da0f..00dad3a7 100644 --- a/examples/lambda_agent.rb +++ b/examples/lambda_agent.rb @@ -47,7 +47,7 @@ description: 'Greet a user by name', parameters: { 'name' => { 'type' => 'string', 'description' => 'Name to greet' } - } + }, handler: nil ) do |args, _raw_data| name = args['name'] || 'friend' SignalWire::Swaig::FunctionResult.new("Hello #{name}! I'm running in serverless mode!") @@ -56,7 +56,7 @@ AGENT.define_tool( name: 'get_time', description: 'Get the current time', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("Current time: #{Time.now.iso8601}") end diff --git a/examples/llm_params_demo.rb b/examples/llm_params_demo.rb index 1d2c3ce6..52e6d686 100644 --- a/examples/llm_params_demo.rb +++ b/examples/llm_params_demo.rb @@ -30,7 +30,7 @@ precise.set_post_prompt_llm_params(temperature: 0.1) precise.define_tool( - name: 'get_system_info', description: 'Get system info', parameters: {} + name: 'get_system_info', description: 'Get system info', parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new( "System Status: CPU #{rand(10..90)}%, Memory #{rand(1..16)}GB, Uptime #{rand(1..30)} days" @@ -60,7 +60,7 @@ creative.define_tool( name: 'generate_story_prompt', description: 'Generate a creative story prompt', - parameters: { 'theme' => { 'type' => 'string', 'description' => 'Story theme' } } + parameters: { 'theme' => { 'type' => 'string', 'description' => 'Story theme' } }, handler: nil ) do |args, _raw_data| theme = args['theme'] || 'adventure' prompts = { @@ -96,7 +96,7 @@ support.define_tool( name: 'check_order_status', description: 'Check order status', - parameters: { 'order_id' => { 'type' => 'string', 'description' => 'Order ID' } } + parameters: { 'order_id' => { 'type' => 'string', 'description' => 'Order ID' } }, handler: nil ) do |args, _raw_data| order_id = args['order_id'] || 'unknown' statuses = [ diff --git a/examples/mcp_agent.rb b/examples/mcp_agent.rb index 0ef819eb..ac4abed1 100644 --- a/examples/mcp_agent.rb +++ b/examples/mcp_agent.rb @@ -54,7 +54,7 @@ description: 'Get the current weather for a location', parameters: { 'location' => { 'type' => 'string', 'description' => 'City name or zip code' } - } + }, handler: nil ) do |args, _raw| location = args['location'] || 'unknown' SignalWire::Swaig::FunctionResult.new("Currently 72F and sunny in #{location}.") @@ -66,7 +66,7 @@ parameters: { 'subject' => { 'type' => 'string', 'description' => 'Ticket subject' }, 'description' => { 'type' => 'string', 'description' => 'Detailed description' } - } + }, handler: nil ) do |args, _raw| subject = args['subject'] || 'No subject' SignalWire::Swaig::FunctionResult.new("Ticket created: '#{subject}'. Reference number: TK-12345.") diff --git a/examples/multi_agent_server.rb b/examples/multi_agent_server.rb index c6ba9d55..f5c9383b 100644 --- a/examples/multi_agent_server.rb +++ b/examples/multi_agent_server.rb @@ -24,7 +24,7 @@ parameters: { 'email' => { 'type' => 'string', 'description' => 'Caller email address' }, 'date' => { 'type' => 'string', 'description' => 'Preferred date (YYYY-MM-DD)' } - } + }, handler: nil ) do |args, _raw_data| SignalWire::Swaig::FunctionResult.new( "Demo scheduled for #{args['email']} on #{args['date']}. " \ @@ -48,7 +48,7 @@ description: 'Look up a support ticket by number', parameters: { 'ticket_number' => { 'type' => 'string', 'description' => 'The support ticket number' } - } + }, handler: nil ) do |args, _raw_data| SignalWire::Swaig::FunctionResult.new( "Ticket #{args['ticket_number']}: Status is 'In Progress'. " \ @@ -75,7 +75,7 @@ 'type' => 'string', 'description' => 'Department name: sales, support, or billing' } - } + }, handler: nil ) do |args, _raw_data| dept = args['department'] || 'unknown' result = SignalWire::Swaig::FunctionResult.new( diff --git a/examples/multi_endpoint_agent.rb b/examples/multi_endpoint_agent.rb index 9dc8aa6b..51cefa51 100644 --- a/examples/multi_endpoint_agent.rb +++ b/examples/multi_endpoint_agent.rb @@ -24,7 +24,7 @@ voice.add_language('English', 'en-US', 'elevenlabs.rachel') voice.define_tool( - name: 'get_time', description: 'Get the current time', parameters: {} + name: 'get_time', description: 'Get the current time', parameters: {}, handler: nil ) do |_args, _raw_data| now = Time.now.strftime('%I:%M %p') SignalWire::Swaig::FunctionResult.new("The current time is #{now}") @@ -42,7 +42,7 @@ info.define_tool( name: 'get_directory', description: 'Look up a department', - parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } } + parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } }, handler: nil ) do |args, _raw_data| dept = args['department'] || 'unknown' SignalWire::Swaig::FunctionResult.new("#{dept.capitalize}: Floor 3, Room 302. Hours 9 AM-5 PM.") diff --git a/examples/quickstart_agent.rb b/examples/quickstart_agent.rb index cc070598..b962c3e9 100644 --- a/examples/quickstart_agent.rb +++ b/examples/quickstart_agent.rb @@ -21,7 +21,8 @@ AGENT.define_tool( name: 'get_time', description: 'Get the current time', - parameters: {} + parameters: {}, + handler: nil # the block below is the handler ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("The time is #{Time.now.strftime('%H:%M:%S')}") end diff --git a/examples/quickstart_relay.rb b/examples/quickstart_relay.rb index 25b25406..c307a611 100644 --- a/examples/quickstart_relay.rb +++ b/examples/quickstart_relay.rb @@ -16,7 +16,7 @@ contexts: ['default'] ) -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play([{ 'type' => 'tts', 'params' => { 'text' => 'Welcome!' } }]) action.wait diff --git a/examples/receptionist_agent_example.rb b/examples/receptionist_agent_example.rb index febe5541..b65175e5 100644 --- a/examples/receptionist_agent_example.rb +++ b/examples/receptionist_agent_example.rb @@ -45,14 +45,14 @@ description: 'Transfer the caller to a specific department', parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } - } + }, handler: nil ) do |args, raw_data| receptionist.handle_transfer(args, raw_data) end agent.add_hints(%w[sales support billing hours directions transfer]) -agent.on_summary do |summary, _raw_data| +agent.on_summary(nil) do |summary, _raw_data| puts "\n=== Call Summary ===" puts summary.inspect puts "==================\n" diff --git a/examples/relay_answer_and_welcome.rb b/examples/relay_answer_and_welcome.rb index cec9f7c2..9a27c9fa 100644 --- a/examples/relay_answer_and_welcome.rb +++ b/examples/relay_answer_and_welcome.rb @@ -17,7 +17,7 @@ client = SignalWire::Relay::Client.new(contexts: ['default']) # Handle inbound calls -client.on_call do |call| +client.on_call(nil) do |call| puts "Incoming call from #{call.device.dig('params', 'from_number') || 'unknown'}" puts " Call ID: #{call.call_id}" puts " Direction: #{call.direction}" @@ -53,7 +53,7 @@ end # Handle inbound messages (optional) -client.on_message do |msg| +client.on_message(nil) do |msg| puts "Incoming message from #{msg.from_number}: #{msg.body}" end diff --git a/examples/session_and_state_demo.rb b/examples/session_and_state_demo.rb index 5508db49..d680e900 100644 --- a/examples/session_and_state_demo.rb +++ b/examples/session_and_state_demo.rb @@ -54,7 +54,7 @@ description: 'Look up an order by order ID', parameters: { 'order_id' => { 'type' => 'string', 'description' => 'The order ID to look up' } - } + }, handler: nil ) do |args, _raw_data| order_id = args['order_id'] || 'unknown' SignalWire::Swaig::FunctionResult.new( @@ -69,7 +69,7 @@ parameters: { 'delivery_window' => { 'type' => 'string', 'description' => 'Preferred window: morning, afternoon, evening' }, 'sms_updates' => { 'type' => 'boolean', 'description' => 'Enable SMS delivery updates' } - } + }, handler: nil ) do |args, _raw_data| result = SignalWire::Swaig::FunctionResult.new( "Preferences updated: delivery window=#{args['delivery_window']}, " \ @@ -87,7 +87,7 @@ # --- Summary callback --- -agent.on_summary do |summary, raw_data| +agent.on_summary(nil) do |summary, raw_data| puts "\n=== Call Summary ===" puts "Summary: #{summary}" call_id = raw_data&.dig('call', 'call_id') || 'unknown' diff --git a/examples/simple_agent.rb b/examples/simple_agent.rb index f0e4dfc0..fd25c5e9 100644 --- a/examples/simple_agent.rb +++ b/examples/simple_agent.rb @@ -34,7 +34,7 @@ description: 'Get the current weather for a city', parameters: { 'city' => { 'type' => 'string', 'description' => 'The city to look up' } - } + }, handler: nil ) do |args, _raw_data| city = args['city'] || 'unknown' # In production, call a real weather API here @@ -48,7 +48,7 @@ description: 'Get a 3-day forecast for a city', parameters: { 'city' => { 'type' => 'string', 'description' => 'The city to look up' } - } + }, handler: nil ) do |args, _raw_data| city = args['city'] || 'unknown' SignalWire::Swaig::FunctionResult.new( diff --git a/examples/simple_dynamic_agent.rb b/examples/simple_dynamic_agent.rb index 2c8696ed..93c1a9c4 100644 --- a/examples/simple_dynamic_agent.rb +++ b/examples/simple_dynamic_agent.rb @@ -17,7 +17,7 @@ # Register a dynamic config callback. # This runs for every incoming SWML request, receiving an ephemeral copy # of the agent that you can safely modify. -agent.set_dynamic_config_callback do |query_params, body_params, headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, body_params, headers, ephemeral| # Customise based on query parameters tenant = query_params['tenant'] || 'default' @@ -56,7 +56,7 @@ agent.define_tool( name: 'get_company_info', description: 'Get information about the company', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| # In production, global_data would be populated per-request SignalWire::Swaig::FunctionResult.new( diff --git a/examples/simple_dynamic_enhanced.rb b/examples/simple_dynamic_enhanced.rb index 05ee9dc3..b513cb17 100644 --- a/examples/simple_dynamic_enhanced.rb +++ b/examples/simple_dynamic_enhanced.rb @@ -19,7 +19,7 @@ record_call: true ) -agent.set_dynamic_config_callback do |query_params, _body_params, _headers, clone| +agent.set_dynamic_config_callback(nil) do |query_params, _body_params, _headers, clone| is_vip = query_params['vip'].to_s.downcase == 'true' department = (query_params['department'] || 'general').downcase customer_id = query_params['customer_id'] || '' diff --git a/examples/step_function_inheritance_demo.rb b/examples/step_function_inheritance_demo.rb index 7e679d73..e919ff1b 100644 --- a/examples/step_function_inheritance_demo.rb +++ b/examples/step_function_inheritance_demo.rb @@ -47,19 +47,19 @@ agent.define_tool( name: 'lookup_account', description: 'Look up customer account details by account number', - parameters: { 'account_number' => { 'type' => 'string' } } + parameters: { 'account_number' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'looked up' } } agent.define_tool( name: 'process_payment', description: 'Process a payment for the current customer', - parameters: { 'amount' => { 'type' => 'number' } } + parameters: { 'amount' => { 'type' => 'number' } }, handler: nil ) { |_args, _raw| { 'response' => 'payment processed' } } agent.define_tool( name: 'send_receipt', description: 'Email a receipt to the customer', - parameters: { 'email' => { 'type' => 'string' } } + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'sent' } } # Build the contexts. diff --git a/examples/survey_agent_example.rb b/examples/survey_agent_example.rb index 55eb48e6..570ed49d 100644 --- a/examples/survey_agent_example.rb +++ b/examples/survey_agent_example.rb @@ -61,7 +61,7 @@ agent.define_tool( name: 'start_survey', description: 'Start the survey and present the first question', - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| survey.handle_start(args, raw_data) end @@ -71,7 +71,7 @@ description: 'Record the answer to the current survey question', parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's response" } - } + }, handler: nil ) do |args, raw_data| survey.handle_submit(args, raw_data) end @@ -79,7 +79,7 @@ agent.define_tool( name: 'get_survey_summary', description: 'Get the final survey summary and thank the caller', - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| survey.handle_summary(args, raw_data) end diff --git a/examples/swml_service_routing_example.rb b/examples/swml_service_routing_example.rb index ea0fd000..3e797e00 100644 --- a/examples/swml_service_routing_example.rb +++ b/examples/swml_service_routing_example.rb @@ -20,7 +20,7 @@ service.hangup # Customer route callback -service.register_routing_callback('/customer') do |request_data| +service.register_routing_callback(nil, '/customer') do |request_data| doc = SignalWire::SWML::Document.new doc.add_verb('answer', {}) @@ -35,7 +35,7 @@ end # Product route callback -service.register_routing_callback('/product') do |request_data| +service.register_routing_callback(nil, '/product') do |request_data| doc = SignalWire::SWML::Document.new doc.add_verb('answer', {}) diff --git a/examples/swmlservice_ai_sidecar.rb b/examples/swmlservice_ai_sidecar.rb index 286c2118..3f98e027 100644 --- a/examples/swmlservice_ai_sidecar.rb +++ b/examples/swmlservice_ai_sidecar.rb @@ -82,7 +82,7 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', # 3. (Optional) Mount an event sink for ai_sidecar lifecycle events # at POST /sales-sidecar/events. Comment this out if you don't # need it. The sidecar POSTs each event as JSON. - register_routing_callback('/events') do |request_data| + register_routing_callback(nil, '/events') do |request_data| event_type = request_data && request_data['type'] warn "[sidecar event] type=#{event_type.inspect} body=#{request_data.inspect}" { 'ok' => true } diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index fa6a8436..e5b6f199 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -332,7 +332,7 @@ def set_prompt_pom(pom) # @param numbered_bullets [Boolean] render bullets as numbered # @param subsections [Array, nil] optional pre-rendered # subsection hashes (each ``{title:, body:, bullets:}``) - def prompt_add_section(title, body = nil, bullets: nil, + def prompt_add_section(title, body = '', bullets: nil, numbered: false, numbered_bullets: false, subsections: nil) @prompt_text = nil @@ -344,7 +344,8 @@ def prompt_add_section(title, body = nil, bullets: nil, def build_section(title, body, **opts) section = { 'title' => title } - section['body'] = body if body + # See prompt_add_subsection: `''` is truthy in Ruby, falsy in python. + section['body'] = body unless body.nil? || body.empty? section['bullets'] = opts[:bullets] if opts[:bullets] section['numbered'] = true if opts[:numbered] section['numbered_bullets'] = true if opts[:numbered_bullets] @@ -408,11 +409,15 @@ def append_section_bullets(sec, bullet, bullets) end # Add a subsection under a parent section. - def prompt_add_subsection(parent_title, title, body = nil, bullets: nil) + def prompt_add_subsection(parent_title, title, body = '', bullets: nil) parent = find_or_create_section(parent_title) parent['subsections'] ||= [] sub = { 'title' => title } - sub['body'] = body if body + # An EMPTY body is omitted, not emitted as "". Ruby's `''` is truthy where + # python's is falsy, so a bare `if body` would emit `"body": ""` for the + # default where the reference (`if self.body:` in pom.Section.to_dict) + # omits the key entirely. + sub['body'] = body unless body.nil? || body.empty? sub['bullets'] = bullets if bullets parent['subsections'] << sub self @@ -703,9 +708,16 @@ def get_contexts # runtime but is accepted for signature compatibility) # @param swaig_fields [Hash, nil] additional fields merged into # the SWAIG function definition - # @yield [args, raw_data] tool handler body (alternative to - # passing ``handler:``) - def define_tool(name:, description:, parameters: {}, handler: nil, + # @yield [args, raw_data] tool handler body (takes precedence over an + # explicit ``handler:``, which must still be supplied — pass ``nil``) + # + # ``parameters:`` and ``handler:`` are REQUIRED, matching the reference + # (``define_tool(name, description, parameters, handler, ...)``). They + # previously defaulted to ``{}`` / ``nil``, so a call that named no + # parameters and registered no handler was silently accepted here while every + # other port rejected it. A tool with no parameters states ``parameters: {}`` + # explicitly; a block-bodied tool states ``handler: nil`` and passes the block. + def define_tool(name:, description:, parameters:, handler:, secure: true, fillers: nil, wait_file: nil, wait_file_loops: nil, webhook_url: nil, required: nil, @@ -790,7 +802,7 @@ def validate_tool_token(function_name, token, call_id) end # Dispatch a function call to the registered handler. - def on_function_call(name, args, raw_data) + def on_function_call(name, args, raw_data = nil) tool = @tools[name] return { 'response' => "Function '#{name}' not found" } unless tool return { 'response' => 'Invalid or expired token' } unless secure_token_ok?(name, tool, raw_data) @@ -852,61 +864,32 @@ def add_hints(hints) # Add a complex (pattern-matched) hint. # - # Two call shapes are supported: the positional form - # ``add_pattern_hint(hint, pattern, replace, ignore_case: false)`` and - # the legacy keyword form ``add_pattern_hint(pattern, hint:, language:)`` - # (kept for backward compat). + # ``hint``, ``pattern`` and ``replace`` are REQUIRED, matching the reference + # (``add_pattern_hint(hint, pattern, replace, ignore_case=False)``). The + # legacy ``add_pattern_hint(pattern, hint:, language:)`` overload was removed: + # it had no reference counterpart AND emitted a different wire shape + # (``{pattern, hint, language}`` instead of + # ``{hint, pattern, replace, ignore_case}``), so it was port-invented surface + # rather than an idiomatic spelling of the reference call. # - # @overload add_pattern_hint(hint, pattern, replace, ignore_case: false) - # @param hint [String] hint to match - # @param pattern [String] regex pattern - # @param replace [String] replacement text - # @param ignore_case [Boolean] match without regard to case - # @overload add_pattern_hint(pattern, hint:, language: 'en-US') - # Legacy Ruby form — pattern + optional hint string and language. - def add_pattern_hint(*args, hint: nil, pattern: nil, replace: nil, - ignore_case: false, language: 'en-US') - @hints << build_pattern_hint(args, hint: hint, pattern: pattern, replace: replace, - ignore_case: ignore_case, language: language) + # @param hint [String] hint to match + # @param pattern [String] regex pattern + # @param replace [String] replacement text + # @param ignore_case [Boolean] match without regard to case + def add_pattern_hint(hint, pattern, replace, ignore_case: false) + @hints << { 'hint' => hint, 'pattern' => pattern, + 'replace' => replace, 'ignore_case' => ignore_case } self end - def build_pattern_hint(args, **opts) - # Three positional args = Python positional shape. - return replace_hint(*args, opts[:ignore_case]) if args.length == 3 - # Single positional ≡ legacy add_pattern_hint(pattern, hint:, language:). - return legacy_pattern_hint(args.first, opts[:hint], opts[:language]) if legacy_hint_form?(args, opts) - # Pure-keyword form (Python-named keywords). - return replace_hint(opts[:hint], opts[:pattern], opts[:replace], opts[:ignore_case]) if keyword_hint_form?(opts) - - raise ArgumentError, - 'add_pattern_hint: pass either (hint, pattern, replace) or use legacy (pattern, hint:, language:) form' - end - - def legacy_hint_form?(args, opts) - args.length == 1 && opts[:pattern].nil? && opts[:replace].nil? - end - - def keyword_hint_form?(opts) - opts[:pattern] && opts[:hint] && opts[:replace] - end - - def replace_hint(hint, pattern, replace, ignore_case) - { 'hint' => hint, 'pattern' => pattern, 'replace' => replace, 'ignore_case' => ignore_case } - end - - def legacy_pattern_hint(pattern, hint, language) - entry = { 'pattern' => pattern } - entry['hint'] = hint if hint - entry['language'] = language if language - entry - end - # Add a language configuration. # - # Two call shapes are supported: the positional shape - # ``add_language(name, code, voice, speech_fillers:, function_fillers:, - # engine:, model:)`` and the original ``add_language(config)`` hash form. + # ``name``, ``code`` and ``voice`` are REQUIRED, matching the reference + # (``add_language(name, code, voice, ...)``). The preformed-hash shapes this + # method used to also accept (``add_language(config_hash)`` and the braceless + # ``add_language('name' => …, 'code' => …)``) had no reference counterpart — + # the reference spells that capability #set_languages, which takes the list of + # config hashes — so they were removed rather than kept as port-only surface. # # Voice argument can be either a simple voice id (``"en-US-Neural2-F"``) # or a combined ``"engine.voice:model"`` string @@ -914,42 +897,23 @@ def legacy_pattern_hint(pattern, hint, language) # parsed into ``engine``/``voice``/``model`` keys when ``engine`` # and ``model`` aren't supplied explicitly. # - # @overload add_language(config) - # @param config [Hash] preformed language config - # @overload add_language(name, code, voice, speech_fillers: nil, - # function_fillers: nil, engine: nil, model: nil, params: nil) - # @param name [String] language name (e.g. ``"English"``) - # @param code [String] BCP47 language code (e.g. ``"en-US"``) - # @param voice [String] voice id or ``engine.voice:model`` string - # @param speech_fillers [Array, nil] filler phrases for - # natural speech - # @param function_fillers [Array, nil] filler phrases - # during function calls - # @param engine [String, nil] explicit engine override - # @param model [String, nil] explicit model override - # @param params [Hash, nil] optional per-language params (engine- - # specific tuning, voice settings, etc.). Emitted as the language - # object's ``params`` key in SWML; the key is only emitted when - # non-empty so existing entries stay byte-identical. - # @param opts [Hash] a braceless hash passed as the whole config — - # ``add_language('name' => 'English', 'code' => 'en-US', - # 'voice' => '…')``. Ruby routes a trailing braceless hash toward - # keywords, so this shape arrives here (not as +name_or_config+); it is - # unfolded back into the hash config form. - def add_language(name_or_config = nil, code = nil, voice = nil, + # @param name [String] language name (e.g. ``"English"``) + # @param code [String] BCP47 language code (e.g. ``"en-US"``) + # @param voice [String] voice id or ``engine.voice:model`` string + # @param speech_fillers [Array, nil] filler phrases for + # natural speech + # @param function_fillers [Array, nil] filler phrases + # during function calls + # @param engine [String, nil] explicit engine override + # @param model [String, nil] explicit model override + # @param params [Hash, nil] optional per-language params (engine- + # specific tuning, voice settings, etc.). Emitted as the language + # object's ``params`` key in SWML; the key is only emitted when + # non-empty so existing entries stay byte-identical. + def add_language(name, code, voice, speech_fillers: nil, function_fillers: nil, - engine: nil, model: nil, params: nil, **opts) - # Braceless hash form: `add_language('name' => …, 'code' => …)` — Ruby - # collects the trailing pairs into **opts, leaving no positional. Re-route - # to the hash config form so the documented one-liner call just works. - name_or_config = braceless_config(name_or_config, opts) - - # Hash form (legacy / direct config) - return (@languages << name_or_config) && self if hash_language_form?(name_or_config, code, voice) - - require_language_args!(name_or_config, code, voice) - - lang = { 'name' => name_or_config, 'code' => code } + engine: nil, model: nil, params: nil) + lang = { 'name' => name, 'code' => code } apply_language_voice(lang, voice, engine, model) apply_language_fillers(lang, speech_fillers, function_fillers) # Only emit params when non-empty so SWML isn't polluted with empty objects. @@ -958,25 +922,6 @@ def add_language(name_or_config = nil, code = nil, voice = nil, self end - # When no positional name was given but keyword-style pairs arrived (a - # braceless hash routed to **opts), fold them back into a string-keyed - # config hash; otherwise pass the positional name through unchanged. - def braceless_config(name_or_config, opts) - return name_or_config unless name_or_config.nil? && !opts.empty? - - opts.transform_keys(&:to_s) - end - - def require_language_args!(name, code, voice) - return unless name.nil? || code.nil? || voice.nil? - - raise ArgumentError, 'add_language: name, code, voice are required (or pass a Hash)' - end - - def hash_language_form?(name_or_config, code, voice) - name_or_config.is_a?(Hash) && code.nil? && voice.nil? - end - # Resolve the voice/engine/model triple onto `lang`. Explicit engine/model # win; otherwise an "engine.voice:model" string is split; else bare voice. def apply_language_voice(lang, voice, engine, model) @@ -1242,7 +1187,7 @@ def clear_pre_answer_verbs self end - def add_answer_verb(config) + def add_answer_verb(config = nil) @answer_config = config self end @@ -1287,6 +1232,11 @@ def clear_post_ai_verbs # @param contexts [SignalWire::Contexts::ContextBuilder, Hash, nil] # optional override # @return [SignalWire::Contexts::ContextBuilder] the active builder + # ``contexts`` is OPTIONAL here, matching the reference's AgentBase-facing + # ``PromptMixin.define_contexts(contexts=None)`` — the no-argument call is the + # documented "get or create the builder" shape. The reference's OTHER + # ``define_contexts``, on PromptManager, does require it; Ruby's + # PromptManager#define_contexts matches that separately. def define_contexts(contexts = nil) return (@context_builder = attach_context_builder(contexts)) if contexts.is_a?(Contexts::ContextBuilder) return (@context_builder = build_context_builder_from_hash(contexts)) if contexts.is_a?(Hash) @@ -1346,14 +1296,17 @@ def list_tool_names # ================================================================== # Load and register a skill by name. - def add_skill(skill_name, params = {}) + def add_skill(skill_name, params = nil) # Ensure builtins are registered Skills::SkillRegistry.register_builtins! factory = Skills::SkillRegistry.get_factory(skill_name) raise ArgumentError, "Unknown skill: '#{skill_name}'" unless factory - skill = factory.call(params) + # The default is `nil` to match the reference (`params: dict | None = None`), + # but every registered factory is a block that INDEXES the params hash, so + # the nil is normalised here rather than pushed onto each factory. + skill = factory.call(params || {}) @skill_manager.load(skill.instance_key, skill) @loaded_skills[skill_name] = skill @@ -1375,8 +1328,10 @@ def define_skill_tool(tool_def) td_handler = sym_or_str(tool_def, :handler) return unless td_name && td_handler + # `handler:` is a required keyword; the skill's handler is passed as the + # block, so the explicit slot is nil. define_tool(name: td_name, description: sym_or_str(tool_def, :description) || '', - parameters: sym_or_str(tool_def, :parameters) || {}, &td_handler) + parameters: sym_or_str(tool_def, :parameters) || {}, handler: nil, &td_handler) end # Read a key from a hash that may use symbol or string keys. @@ -1419,8 +1374,14 @@ def has_skill?(skill_name) # Web / HTTP configuration # ================================================================== - def set_dynamic_config_callback(callable = nil, &block) - @dynamic_config_callback = callable || block + # The callback is REQUIRED, matching the reference + # (``set_dynamic_config_callback(self, callback)``); the block is the + # idiomatic spelling of the same slot and passing neither raises. + def set_dynamic_config_callback(callable, &block) + callback = callable || block + raise ArgumentError, 'set_dynamic_config_callback requires a callback (block or callable)' if callback.nil? + + @dynamic_config_callback = callback self end @@ -1526,7 +1487,7 @@ def enable_sip_routing(auto_map: true, path: '/sip') # SIP username from the request body and returns nil (matched → this agent # handles the call so dispatch renders SWML; unmatched → routing # continues) — exactly Python's sip_routing_callback. - register_routing_callback(path) { |body, _headers| sip_routing_callback(body) } + register_routing_callback(nil, path) { |body, _headers| sip_routing_callback(body) } auto_map_sip_usernames if auto_map self @@ -1776,15 +1737,20 @@ def mcp_error(req_id, code, message) # # 1. **Registration** — pass a block to install a callback. The block # receives ``(summary, raw_data)`` when a summary is delivered. - # ``on_summary { |sum, raw| ... }`` + # ``on_summary(nil) { |sum, raw| ... }`` # 2. **Override** — subclass and override # ``on_summary(summary, raw_data = nil)``. Default implementation # calls the registered block (if any) and otherwise no-ops. # + # ``summary`` is REQUIRED, matching the reference + # (``on_summary(self, summary: PostPromptData | None, raw_data=None)``): the + # slot is nullABLE, not omittABLE, so a caller states `nil` explicitly rather + # than relying on a port-invented default the other nine ports do not have. + # # @param summary [Hash, nil] the post-prompt summary # @param raw_data [Hash, nil] the complete raw POST data # @yield [summary, raw_data] optional callback registration - def on_summary(summary = nil, raw_data = nil, &block) + def on_summary(summary, raw_data = nil, &block) if block @summary_callback = block return self @@ -1794,8 +1760,14 @@ def on_summary(summary = nil, raw_data = nil, &block) nil end - def on_debug_event(&block) - @debug_event_callback = block + # Register the debug-event handler. REQUIRED, matching the reference + # (``on_debug_event(self, handler)``); the block is the idiomatic spelling of + # the same slot and passing neither raises. + def on_debug_event(handler, &block) + callback = block || handler + raise ArgumentError, 'on_debug_event requires a handler (block or callable)' if callback.nil? + + @debug_event_callback = callback self end @@ -2720,15 +2692,14 @@ def unauthorized # methods span multiple public/private regions above. private :add_context_step, :add_pom_section, :append_section_bullets, :apply_compound_voice private :apply_dynamic_config, :apply_language_fillers, :apply_language_voice, :attach_context_builder - private :braceless_config, :require_language_args! - private :basic_auth_source, :build_context_builder_from_hash, :build_pattern_hint, :build_section + private :basic_auth_source, :build_context_builder_from_hash, :build_section private :build_subsection, :build_subsections, :build_tool_definition, :build_tool_param_schema private :coerce_function_result, :compound_voice?, :define_skill_tool, :find_or_create_section - private :hash_language_form?, :invoke_debug_event_callback, :invoke_summary_callback, :join_rack_body - private :keyword_hint_form?, :legacy_hint_form?, :legacy_pattern_hint, :log_server_startup + private :invoke_debug_event_callback, :invoke_summary_callback, :join_rack_body + private :log_server_startup private :matches_env_auth?, :mcp_input_schema, :mcp_tool_entry, :merge_skill_hints_and_data private :merge_skill_prompt_sections, :optional_tool_fields, :rack_env, :register_no_vowels_variation - private :register_skill_tools, :replace_hint, :sanitize_sip_username, :section_pom_kwargs + private :register_skill_tools, :sanitize_sip_username, :section_pom_kwargs private :secure_token_ok?, :sym_or_str, :verb_entries, :warn_unexpected_function_result private :warn_unknown_filler_name, :warn_unknown_filler_names, :webrick_opts private :answer_entry, :record_call_entry, :webrick_handler diff --git a/lib/signalwire/core/agent/tools/registry.rb b/lib/signalwire/core/agent/tools/registry.rb index ad2d4670..4a135b91 100644 --- a/lib/signalwire/core/agent/tools/registry.rb +++ b/lib/signalwire/core/agent/tools/registry.rb @@ -64,7 +64,10 @@ def initialize(agent = nil) # @param swaig_fields [Hash, nil] extra fields merged into the def # @raise [ArgumentError] if the tool name already exists # @return [Hash] the stored definition - def define_tool(name:, description:, parameters: {}, handler: nil, + # ``parameters:`` and ``handler:`` are REQUIRED, matching the reference + # (``define_tool(name, description, parameters, handler, ...)``). A tool + # with no parameters states ``parameters: {}`` explicitly. + def define_tool(name:, description:, parameters:, handler:, secure: true, fillers: nil, wait_file: nil, wait_file_loops: nil, webhook_url: nil, required: nil, diff --git a/lib/signalwire/prefabs/info_gatherer.rb b/lib/signalwire/prefabs/info_gatherer.rb index 97515d80..26de6024 100644 --- a/lib/signalwire/prefabs/info_gatherer.rb +++ b/lib/signalwire/prefabs/info_gatherer.rb @@ -108,7 +108,7 @@ def global_data # Tool handler: start_questions. Reads the current question index from the # request's global_data and returns the corresponding question. - def handle_start(_args, raw_data = {}) + def handle_start(_args, raw_data) gd = request_global_data(raw_data) questions = gd['questions'] index = gd['question_index'] @@ -126,7 +126,7 @@ def handle_start(_args, raw_data = {}) # Tool handler: submit_answer. Real state machine — records the answer, # advances the index, and returns the next question (or completion), # persisting the updated state back into global_data. - def handle_submit(args, raw_data = {}) + def handle_submit(args, raw_data) answer = args['answer'] || '' gd = request_global_data(raw_data) questions = gd['questions'] diff --git a/lib/signalwire/relay/call.rb b/lib/signalwire/relay/call.rb index bd6477b9..471c0e5e 100644 --- a/lib/signalwire/relay/call.rb +++ b/lib/signalwire/relay/call.rb @@ -83,9 +83,16 @@ def call_gone_error?(error) # ------------------------------------------------------------------ # Register an event listener for this call. - def on(event_type, &handler) + # + # The handler is REQUIRED, matching the reference + # (``on(self, event_type: str, handler: EventHandler)``). Ruby's block IS + # the handler; supplying neither registers nothing and raises. + def on(event_type, handler, &block) + callback = block || handler + raise ArgumentError, 'on requires a handler (block or callable)' if callback.nil? + @mutex.synchronize do - (@listeners[event_type] ||= []) << handler + (@listeners[event_type] ||= []) << callback end end @@ -233,7 +240,7 @@ def wait_for(event_type, predicate: nil, timeout: nil) state = { result: nil, satisfied: false } handler = one_shot_handler(mutex, cv, state, predicate) - on(event_type, &handler) + on(event_type, handler) with_one_shot_listener(event_type, handler) do mutex.synchronize { block_until(cv, mutex, timeout) { state[:satisfied] } } state[:result] diff --git a/lib/signalwire/relay/client.rb b/lib/signalwire/relay/client.rb index 705fa9e6..de0b8013 100644 --- a/lib/signalwire/relay/client.rb +++ b/lib/signalwire/relay/client.rb @@ -202,13 +202,22 @@ def inspect alias to_s inspect # Register inbound call handler. - def on_call(&block) - @on_call_handler = block + # + # ``handler`` is REQUIRED, matching the reference + # (``on_call(self, handler: CallHandler)``) and every other port. Ruby + # cannot let a block satisfy a required positional, so the callable is + # passed explicitly — ``client.on_call(->(call) { ... })``. A block is still + # accepted and takes precedence when both are given, which keeps + # ``on_call(nil) { |call| ... }`` working for callers who prefer the block + # body; what is NOT accepted is omitting the argument entirely, because + # that registers nothing and every other port rejects it. + def on_call(handler, &block) + @on_call_handler = require_handler(handler, block, 'on_call') end - # Register inbound message handler. - def on_message(&block) - @on_message_handler = block + # Register inbound message handler. See #on_call for the handler contract. + def on_message(handler, &block) + @on_message_handler = require_handler(handler, block, 'on_message') end # Register a generic inbound-event handler. Called for every @@ -309,15 +318,21 @@ def stop # ------------------------------------------------------------------ # Dial outbound call(s). Returns a Call object. - def dial(devices, timeout: 120, tag: nil, **kwargs) + # Keyword names and defaults mirror the reference + # (``tag=None, max_duration=None, dial_timeout=None``): ``dial_timeout`` + # defaults to nil and the 120s fallback is applied at the wait, exactly + # where python applies it (`dial_timeout if dial_timeout is not None else + # 120.0`). ``max_duration`` is an explicit keyword, not a **kwargs + # passenger, and reaches the wire only when truthy. + def dial(devices, tag: nil, max_duration: nil, dial_timeout: nil) dial_tag = tag || SecureRandom.uuid # Register pending dial BEFORE sending RPC entry = { mutex: Mutex.new, cv: ConditionVariable.new, call: nil, error: nil } @dials_mutex.synchronize { @pending_dials[dial_tag] = entry } - send_dial_rpc(dial_tag, devices, kwargs) - await_dial(dial_tag, entry, timeout) + send_dial_rpc(dial_tag, devices, max_duration) + await_dial(dial_tag, entry, dial_timeout.nil? ? 120.0 : dial_timeout) @dials_mutex.synchronize { @pending_dials.delete(dial_tag) } raise RelayError.new(-1, entry[:error]) if entry[:error] @@ -365,7 +380,7 @@ def unreceive(contexts) # Send a JSON-RPC request and wait for the response. # Returns the result hash. Raises RelayError on error. - def execute(method, params = {}) + def execute(method, params) id = SecureRandom.uuid entry = { mutex: Mutex.new, cv: ConditionVariable.new, result: nil, error: nil } @pending_mutex.synchronize { @pending[id] = entry } @@ -386,6 +401,17 @@ def execute(method, params = {}) private + # The handler slot for a ``on_*`` registration: the block if one was given, + # else the explicit callable. Raises when neither is supplied — the + # reference declares the handler REQUIRED, so a registration that registers + # nothing must fail loudly rather than leave a silently-dead callback. + def require_handler(handler, block, method_name) + callback = block || handler + raise ArgumentError, "#{method_name} requires a handler (block or callable)" if callback.nil? + + callback + end + def connect_and_run_guarded connect_and_run rescue StandardError => e @@ -426,9 +452,9 @@ def validate_message_payload(body, media) raise ArgumentError, 'body or media is required' end - def send_dial_rpc(dial_tag, devices, kwargs) + def send_dial_rpc(dial_tag, devices, max_duration) params = { 'tag' => dial_tag, 'devices' => devices } - kwargs.each { |k, v| params[k.to_s] = v } + params['max_duration'] = max_duration if max_duration execute('calling.dial', params) rescue StandardError @dials_mutex.synchronize { @pending_dials.delete(dial_tag) } diff --git a/lib/signalwire/relay/message.rb b/lib/signalwire/relay/message.rb index 4780cda4..d4e1f977 100644 --- a/lib/signalwire/relay/message.rb +++ b/lib/signalwire/relay/message.rb @@ -82,8 +82,15 @@ def _set_on_completed(callback) end # Register an event listener for state changes. - def on_event(&handler) - @listeners << handler + # + # The handler is REQUIRED, matching the reference + # (``Message.on(self, handler: Callable[[RelayEvent], Any])``). Ruby's + # block IS the handler; supplying neither registers nothing and raises. + def on_event(handler, &block) + callback = block || handler + raise ArgumentError, 'on_event requires a handler (block or callable)' if callback.nil? + + @listeners << callback end def done? diff --git a/lib/signalwire/server/agent_server.rb b/lib/signalwire/server/agent_server.rb index 6d38acce..26530e64 100644 --- a/lib/signalwire/server/agent_server.rb +++ b/lib/signalwire/server/agent_server.rb @@ -200,7 +200,11 @@ def setup_sip_routing(route: '/sip', auto_map: true) # @param callback_fn [#call, nil] the routing callback (Proc/lambda) # @param path [String] the path to register the callback at # @return [self] - def register_global_routing_callback(callback_fn = nil, path:, &block) + # ``callback_fn`` and ``path`` are both REQUIRED, matching the reference + # (``register_global_routing_callback(callback_fn, path)``). The block is the + # idiomatic spelling of ``callback_fn``; pass ``nil`` in its slot when using + # the block form. + def register_global_routing_callback(callback_fn, path, &block) callback = block || callback_fn raise ArgumentError, 'a callback (block or callable) is required' if callback.nil? @@ -210,7 +214,7 @@ def register_global_routing_callback(callback_fn = nil, path:, &block) agents = @mutex.synchronize { @agents.values } agents.each do |agent| - agent.register_routing_callback(path, &callback) if agent.respond_to?(:register_routing_callback) + agent.register_routing_callback(callback, path) if agent.respond_to?(:register_routing_callback) end @logger&.info("Registered global routing callback at #{path} on all agents") @@ -240,7 +244,7 @@ def _lookup_sip_route(username) # @param directory [String] absolute or relative path to the directory # @param route [String] the URL prefix to serve files at # @return [self] - def serve_static_files(directory, route) + def serve_static_files(directory, route = '/') route = "/#{route}" unless route.start_with?('/') route = route.chomp('/') resolved = File.expand_path(directory) diff --git a/lib/signalwire/skills/skill_base.rb b/lib/signalwire/skills/skill_base.rb index 772bc1e0..c35c964c 100644 --- a/lib/signalwire/skills/skill_base.rb +++ b/lib/signalwire/skills/skill_base.rb @@ -67,8 +67,10 @@ def define_tool(name:, description:, parameters: {}, **kwargs, &handler) raise 'skill has no agent to define tools on' unless @agent merged = (@swaig_fields || {}).merge(kwargs) + # `handler:` is a required keyword; the block IS the handler here, so the + # explicit slot is nil unless the caller's merged kwargs already set it. @agent.define_tool(name: name, description: description, - parameters: parameters, **merged, &handler) + parameters: parameters, handler: nil, **merged, &handler) end # Speech recognition hints. diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index f3e80d66..96990381 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -95,7 +95,7 @@ def define_tools # Dispatch a function call to the registered handler. Default plain # implementation — AgentBase overrides with token validation. - def on_function_call(name, args, raw_data) + def on_function_call(name, args, raw_data = nil) tool = @tools[name] return nil unless tool && tool[:handler] @@ -279,10 +279,22 @@ def get_full_url(include_auth: false) # Register a routing callback at +path+. The path is normalized for # consistent lookup — trailing slash stripped, leading slash ensured # (so "/sip/" and "sip" both store as "/sip"). - def register_routing_callback(path, &block) + # + # Parameter ORDER and defaults mirror the reference + # (``register_routing_callback(callback_fn, path="/sip")``): the CALLBACK + # comes first and is required, +path+ second and defaulted. Ruby's block is + # the idiomatic spelling of ``callback_fn``, so + # ``register_routing_callback('/sip') { ... }`` would put the path in the + # callback slot — pass the path as the second argument + # (``register_routing_callback(nil, '/sip') { ... }``) or rely on the + # "/sip" default. + def register_routing_callback(callback_fn, path = '/sip', &block) + callback = block || callback_fn + raise ArgumentError, 'register_routing_callback requires a callback (block or callable)' if callback.nil? + normalized = path.to_s.chomp('/') normalized = "/#{normalized}" unless normalized.start_with?('/') - @routing_callbacks[normalized] = block + @routing_callbacks[normalized] = callback end # Framework-free request-dispatch core — the primitive dispatch surface diff --git a/port_signatures.json b/port_signatures.json index 8f6157c9..3192cd3f 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -194,13 +194,11 @@ { "name": "callback_fn", "type": "callable,dict>,optional>", - "required": false, - "default": null + "required": true }, { "name": "path", "type": "string", - "kind": "keyword", "required": true }, { @@ -283,7 +281,8 @@ { "name": "route", "type": "string", - "required": true + "required": false, + "default": "/" } ], "returns": "any" @@ -567,14 +566,14 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": 10 }, { "name": "read_idle_timeout", "type": "any", "kind": "keyword", "required": false, - "default": null + "default": 60 } ], "returns": "void" @@ -1071,8 +1070,7 @@ { "name": "contexts", "type": "union,any>", - "required": false, - "default": null + "required": true } ], "returns": "any" @@ -1136,8 +1134,9 @@ { "name": "body", "type": "string", + "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -1189,8 +1188,9 @@ { "name": "body", "type": "string", + "kind": "keyword", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -1213,12 +1213,6 @@ "type": "string", "required": true }, - { - "name": "body_arg", - "type": "any", - "required": false, - "default": null - }, { "name": "body", "type": "optional", @@ -1353,15 +1347,13 @@ "name": "parameters", "type": "dict", "kind": "keyword", - "required": false, - "default": {} + "required": true }, { "name": "handler", "type": "callable,any>", "kind": "keyword", - "required": false, - "default": null + "required": true }, { "name": "secure", @@ -1418,13 +1410,6 @@ "kind": "keyword", "required": false, "default": null - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null } ], "returns": "any" @@ -1473,8 +1458,8 @@ "kind": "self" }, { - "name": "func_def", - "type": "any", + "name": "function_dict", + "type": "dict", "required": true } ], @@ -1717,7 +1702,8 @@ { "name": "config", "type": "optional>", - "required": true + "required": false, + "default": null } ], "returns": "any" @@ -2127,6 +2113,11 @@ "name": "self", "kind": "self" }, + { + "name": "handler", + "type": "callable,any>", + "required": true + }, { "name": "block", "type": "any", @@ -2146,8 +2137,7 @@ { "name": "summary", "type": "optional", - "required": false, - "default": null + "required": true }, { "name": "raw_data", @@ -4809,7 +4799,7 @@ "type": "optional", "kind": "keyword", "required": false, - "default": null + "default": "The payment status is ${pay_result}, do not mention anything else about collecting payment if successful." } ], "returns": "any" @@ -4869,14 +4859,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "wav" }, { "name": "direction", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "both" }, { "name": "terminators", @@ -5402,14 +5392,14 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "both" }, { "name": "codec", "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "PCMU" }, { "name": "rtp_ptime", @@ -5654,22 +5644,19 @@ "kind": "self" }, { - "name": "name_or_config", - "type": "any", - "required": false, - "default": null + "name": "name", + "type": "string", + "required": true }, { "name": "code", "type": "string", - "required": false, - "default": null + "required": true }, { "name": "voice", "type": "string", - "required": false, - "default": null + "required": true }, { "name": "speech_fillers", @@ -5705,13 +5692,6 @@ "kind": "keyword", "required": false, "default": null - }, - { - "name": "opts", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null } ], "returns": "any" @@ -5757,33 +5737,20 @@ "name": "self", "kind": "self" }, - { - "name": "args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null - }, { "name": "hint", "type": "string", - "kind": "keyword", - "required": false, - "default": null + "required": true }, { "name": "pattern", "type": "string", - "kind": "keyword", - "required": false, - "default": null + "required": true }, { "name": "replace", "type": "string", - "kind": "keyword", - "required": false, - "default": null + "required": true }, { "name": "ignore_case", @@ -5791,13 +5758,6 @@ "kind": "keyword", "required": false, "default": false - }, - { - "name": "language", - "type": "any", - "kind": "keyword", - "required": false, - "default": "en-US" } ], "returns": "any" @@ -6171,7 +6131,7 @@ }, { "name": "contexts", - "type": "union,any>", + "type": "optional,class:signalwire.core.contexts.ContextBuilder>>", "required": false, "default": null } @@ -6211,7 +6171,7 @@ "name": "body", "type": "string", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -6264,7 +6224,7 @@ "name": "body", "type": "string", "required": false, - "default": null + "default": "" }, { "name": "bullets", @@ -6429,7 +6389,7 @@ "name": "params", "type": "optional>", "required": false, - "default": {} + "default": null } ], "returns": "any" @@ -6533,15 +6493,13 @@ "name": "parameters", "type": "dict", "kind": "keyword", - "required": false, - "default": {} + "required": true }, { "name": "handler", "type": "callable,any>", "kind": "keyword", - "required": false, - "default": null + "required": true }, { "name": "secure", @@ -6559,14 +6517,14 @@ }, { "name": "wait_file", - "type": "optional", + "type": "any", "kind": "keyword", "required": false, "default": null }, { "name": "wait_file_loops", - "type": "optional", + "type": "any", "kind": "keyword", "required": false, "default": null @@ -6628,7 +6586,8 @@ { "name": "raw_data", "type": "optional>", - "required": true + "required": false, + "default": null } ], "returns": "any" @@ -6758,10 +6717,16 @@ "name": "self", "kind": "self" }, + { + "name": "callback_fn", + "type": "callable,dict>,optional>", + "required": true + }, { "name": "path", "type": "string", - "required": true + "required": false, + "default": "/sip" }, { "name": "block", @@ -6849,8 +6814,7 @@ { "name": "callback", "type": "callable,dict,dict,class:signalwire.core.agent_base.AgentBase>,void>", - "required": false, - "default": null + "required": true }, { "name": "block", @@ -11309,7 +11273,7 @@ }, { "name": "name", - "type": "string", + "type": "any", "required": true } ], @@ -11377,7 +11341,7 @@ }, { "name": "name", - "type": "string", + "type": "any", "required": true } ], @@ -11471,7 +11435,8 @@ { "name": "raw_data", "type": "any", - "required": true + "required": false, + "default": null } ], "returns": "any" @@ -11556,10 +11521,16 @@ "name": "self", "kind": "self" }, + { + "name": "callback_fn", + "type": "callable,dict>,optional>", + "required": true + }, { "name": "path", "type": "string", - "required": true + "required": false, + "default": "/sip" }, { "name": "block", @@ -11607,7 +11578,7 @@ }, { "name": "name", - "type": "string", + "type": "any", "required": true } ], @@ -20415,8 +20386,7 @@ { "name": "raw_data", "type": "dict", - "required": false, - "default": {} + "required": true } ], "returns": "any" @@ -20435,8 +20405,7 @@ { "name": "raw_data", "type": "dict", - "required": false, - "default": {} + "required": true } ], "returns": "any" @@ -20487,7 +20456,7 @@ "type": "string", "kind": "keyword", "required": false, - "default": null + "default": "rime.spore" }, { "name": "_opts", @@ -20653,7 +20622,7 @@ "type": "int", "kind": "keyword", "required": false, - "default": null + "default": 2 }, { "name": "name", @@ -21762,6 +21731,11 @@ { "name": "handler", "type": "class:signalwire.relay.call.EventHandler", + "required": true + }, + { + "name": "block", + "type": "any", "kind": "keyword", "required": false, "default": null @@ -23215,23 +23189,23 @@ "required": true }, { - "name": "timeout", - "type": "any", + "name": "tag", + "type": "optional", "kind": "keyword", "required": false, - "default": 120 + "default": null }, { - "name": "tag", - "type": "optional", + "name": "max_duration", + "type": "optional", "kind": "keyword", "required": false, "default": null }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "dial_timeout", + "type": "optional", + "kind": "keyword", "required": false, "default": null } @@ -23252,8 +23226,7 @@ { "name": "params", "type": "dict", - "required": false, - "default": {} + "required": true } ], "returns": "any" @@ -23300,6 +23273,11 @@ "name": "self", "kind": "self" }, + { + "name": "handler", + "type": "class:signalwire.relay.client.CallHandler", + "required": true + }, { "name": "block", "type": "any", @@ -23332,6 +23310,11 @@ "name": "self", "kind": "self" }, + { + "name": "handler", + "type": "class:signalwire.relay.client.MessageHandler", + "required": true + }, { "name": "block", "type": "any", @@ -26587,6 +26570,11 @@ { "name": "handler", "type": "callable,any>", + "required": true + }, + { + "name": "block", + "type": "any", "kind": "keyword", "required": false, "default": null @@ -39885,7 +39873,7 @@ "type": "any", "kind": "keyword", "required": false, - "default": null + "default": "string" } ], "returns": "any" diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 19ec2bb3..b42bb95c 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -1268,7 +1268,28 @@ def collect(raw: dict) -> dict: out_modules.setdefault(target_mod, {}) out_modules[target_mod].setdefault("classes", {}) out_modules[target_mod]["classes"].setdefault(target_cls, {"methods": {}}) - out_modules[target_mod]["classes"][target_cls]["methods"].update(present) + target_methods = out_modules[target_mod]["classes"][target_cls]["methods"] + # A projection FILLS a method the target class does not declare; it + # must never CLOBBER one the target really has. PromptManager is the + # case that proved it: Ruby declares its own + # ``PromptManager#define_contexts(contexts)`` — required, matching the + # reference's PromptManager — but the projection overwrote it with + # AgentBase's ``define_contexts(contexts = nil)``, whose reference + # counterpart (PromptMixin) is deliberately OPTIONAL. The two + # reference methods genuinely differ, so overwriting reported the + # correct Ruby method as a required-flip against a signature it does + # not have. Only project the names the target is actually missing. + target_methods.update( + {m: sig for m, sig in present.items() if m not in target_methods} + ) + # The AgentBase donor copy is popped for EVERY name this projection + # CLAIMS -- both the ones it filled in and the ones the target already + # declared. Claiming is what says "this member's reference home is the + # target class, not AgentBase"; whether Ruby happened to also declare + # it on the target does not change where the reference records it. + # (Popping only the filled ones stranded ``set_prompt_pom`` on + # AgentBase, where the reference has no counterpart -> a bogus + # missing-reference drift.) projected.update(present) for n in projected: ab_methods.pop(n, None) diff --git a/scripts/signature_dump.rb b/scripts/signature_dump.rb index 2fb47d75..e4842f3e 100755 --- a/scripts/signature_dump.rb +++ b/scripts/signature_dump.rb @@ -49,9 +49,27 @@ # Sentinel distinguishing "no static value recoverable" from a literal ``nil`` # default. ``def f(x = nil)`` genuinely defaults to nil and must be recorded as -# such; ``def f(x = CONST)`` must not be recorded at all. +# such; a default that is neither a literal nor a resolvable CONSTANT must not be +# recorded at all. NO_STATIC_DEFAULT = Object.new.freeze +# A CONSTANT reference used as a default (``def f(fmt: RecordFormat::WAV)``). +# +# This is NOT a "non-static expression" -- a constant is exactly as fixed as an +# inline literal; writing ``format: RecordFormat::WAV`` instead of +# ``format: 'wav'`` is a readability choice, not a behavioural one. Dropping it +# reported five FunctionResult params (``record_call`` format/direction, ``tap`` +# direction/codec, ``pay`` ai_response) as having no default when the reference +# records "wav"/"both"/"PCMU"/the pay prompt -- a correct port reading as drift. +# +# Resolution is DEFERRED rather than done during the source parse because the +# parse walks files with no lexical-scope tracking, so a bare ``WAV`` has no +# namespace to resolve against. The reflection side does: ``Method#owner`` is the +# exact module the ``def`` was written in, which is the lexical scope Ruby itself +# would use. So the parse records the reference and ``resolve_const_refs`` +# resolves it against the owner's namespace chain (see ``const_lookup``). +ConstRef = Struct.new(:path) + # Convert a Ripper value sexp to its literal Ruby value, or NO_STATIC_DEFAULT # when it is not a static literal. # @@ -65,7 +83,12 @@ def ripper_literal(node) case node[0] when :@int then ripper_integer(node[1]) when :@float then ripper_float(node[1]) - when :var_ref, :vcall then ripper_keyword_literal(node[1]) + # ``true``/``false``/``nil`` arrive as :var_ref/:vcall over a :@kw token; a + # :var_ref over a :@const is a CONSTANT and falls through to the arm below. + when :vcall then ripper_keyword_literal(node[1]) + when :var_ref + kw = ripper_keyword_literal(node[1]) + kw.equal?(NO_STATIC_DEFAULT) ? ripper_const_ref(node) : kw when :string_literal then ripper_string_literal(node[1]) when :symbol_literal then ripper_symbol_literal(node[1]) # A bare word inside a %w[] / %i[] list -- Ripper emits the raw token with @@ -73,10 +96,38 @@ def ripper_literal(node) when :@tstring_content then node[1] when :array then ripper_array_literal(node[1]) when :hash then ripper_hash_literal(node[1]) + # A namespaced CONSTANT (``RecordFormat::WAV`` / ``A::B::C`` / ``::A::B``) -- + # recorded as a deferred reference, resolved later against the owning module. + when :const_path_ref, :top_const_ref then ripper_const_ref(node) else NO_STATIC_DEFAULT end end +# Flatten a constant sexp to a dotted path, or NO_STATIC_DEFAULT when the node is +# not a pure constant chain. Only :@const links are accepted -- ``foo::BAR`` (a +# method call on the left) resolves at call time and is not statically known. +def ripper_const_ref(node) + parts = flatten_const_path(node) + return NO_STATIC_DEFAULT if parts.nil? + + ConstRef.new(parts) +end + +def flatten_const_path(node) + return nil unless node.is_a?(Array) + + case node[0] + when :@const then [node[1]] + when :var_ref, :top_const_ref then flatten_const_path(node[1]) + when :const_path_ref + left = flatten_const_path(node[1]) + right = flatten_const_path(node[2]) + return nil if left.nil? || right.nil? + + left + right + end +end + # Integer()/Float() rather than to_i/to_f: they honour 0x/0o/0b radix prefixes # and ``_`` separators, where a bare to_i would silently turn "0x1f" into 0. # (Kernel#Integer / Kernel#Float are METHODS, not callable objects -- they cannot @@ -276,8 +327,73 @@ def realpath_or_self(path) path end +# Replace every deferred ConstRef with the constant's VALUE, resolved against the +# module the method was defined in. A reference that does not resolve, or that +# resolves to something that is not a JSON-representable scalar/collection (a +# Class, a Proc, an arbitrary object), is dropped back to NO_STATIC_DEFAULT -- +# unrecovered rather than fabricated. +def resolve_const_refs(defaults, owner) + out = {} + defaults.each do |pname, val| + resolved = val.is_a?(ConstRef) ? const_lookup(val.path, owner) : val + out[pname] = resolved unless resolved.equal?(NO_STATIC_DEFAULT) + end + out +end + +# Resolve a dotted constant path the way Ruby's own lexical lookup would: try the +# owning module first, then each enclosing namespace, then top level. +# +# ``Module#const_get`` with inherit:true already walks the ancestry, so the extra +# work here is walking OUTWARD through the enclosing namespaces -- which is what +# makes a bare ``WAV`` written inside ``SignalWire::Swaig::FunctionResult`` +# resolve to ``SignalWire::Swaig::RecordFormat::WAV``'s sibling scope. +def const_lookup(path, owner) + joined = path.join('::') + namespaces_for(owner).each do |ns| + return json_scalar(ns.const_get(joined)) + rescue NameError, TypeError + next + end + NO_STATIC_DEFAULT +end + +# [owner, each enclosing namespace ..., Object] for a module, by name. +def namespaces_for(owner) + out = [] + name = owner.is_a?(Module) ? owner.name : nil + if name + parts = name.split('::') + parts.length.downto(1) do |i| + out << Object.const_get(parts[0, i].join('::')) + rescue NameError, TypeError + next + end + end + out << Object + out +end + +# A constant's value, only when it is a plain JSON-representable value. Anything +# else (Class, Module, Proc, Struct, arbitrary object) has no meaningful default +# representation and is rejected rather than stringified. +def json_scalar(val) + case val + when String, Integer, Float, true, false, nil then val + when Symbol then val.to_s + when Array then if val.all? { |v| json_scalar(v) != NO_STATIC_DEFAULT } + val.map do |v| + json_scalar(v) + end + else + NO_STATIC_DEFAULT + end + else NO_STATIC_DEFAULT + end +end + def method_entry(meth, name, is_constructor:, is_static:) - defaults = defaults_for(meth) + defaults = resolve_const_refs(defaults_for(meth), meth.owner) parameters = meth.parameters.map do |kind, pname| entry = { kind: kind.to_s, name: pname.to_s } # Emit ``default`` ONLY when a literal was actually recovered. Its ABSENCE diff --git a/tests/agent_test.rb b/tests/agent_test.rb index a166ce6e..b80defac 100644 --- a/tests/agent_test.rb +++ b/tests/agent_test.rb @@ -194,7 +194,7 @@ class AgentConstructionSummaryTest < Minitest::Test def test_on_summary_block_registration_and_invocation agent = SignalWire::AgentBase.new received = [] - agent.on_summary { |sum, raw| received << [sum, raw] } + agent.on_summary(nil) { |sum, raw| received << [sum, raw] } summary = { 'topic' => 'billing' } raw = { 'call_id' => 'abc' } @@ -222,7 +222,7 @@ class AgentConstructionToolsAndLanguagesTest < Minitest::Test def test_define_tool_with_wait_file_and_loops agent = SignalWire::AgentBase.new agent.define_tool(name: 'play_tune', description: 'play a tune', parameters: {}, - wait_file: 'https://example.com/wait.mp3', wait_file_loops: 3) do |_args, _raw| + wait_file: 'https://example.com/wait.mp3', wait_file_loops: 3, handler: nil) do |_args, _raw| { 'response' => 'ok' } end tool = agent.define_tools.find { |d| d['function'] == 'play_tune' } @@ -238,7 +238,7 @@ def test_define_tool_with_webhook_url name: 'lookup', description: 'lookup', parameters: {}, - webhook_url: 'https://example.com/swaig' + webhook_url: 'https://example.com/swaig', handler: nil ) { |_args, _raw| {} } defs = agent.define_tools tool = defs.find { |d| d['function'] == 'lookup' } @@ -252,7 +252,7 @@ def test_define_tool_with_required_array name: 'verify', description: 'verify', parameters: { 'type' => 'object', 'properties' => { 'a' => { 'type' => 'string' } } }, - required: ['a'] + required: ['a'], handler: nil ) { |_args, _raw| {} } defs = agent.define_tools tool = defs.find { |d| d['function'] == 'verify' } @@ -266,7 +266,7 @@ def test_define_tool_is_typed_handler_marker name: 't', description: 'd', parameters: {}, - is_typed_handler: true + is_typed_handler: true, handler: nil ) { |_args, _raw| {} } defs = agent.define_tools tool = defs.find { |d| d['function'] == 't' } @@ -290,13 +290,24 @@ def test_add_pattern_hint_python_positional assert_equal true, entry['ignore_case'] end - def test_add_pattern_hint_legacy_form_still_works + # The legacy single-positional form (`add_pattern_hint('foo')`) was removed: + # it had no reference counterpart and emitted a different wire shape. All + # three of hint/pattern/replace are now required, matching the reference. + def test_add_pattern_hint_requires_hint_pattern_and_replace agent = SignalWire::AgentBase.new - agent.add_pattern_hint('foo') # legacy single positional - # Pattern stored in hints + + assert_raises(ArgumentError) { agent.add_pattern_hint('foo') } + assert_raises(ArgumentError) { agent.add_pattern_hint('foo', 'bar') } + end + + # ignore_case defaults to false — asserted WITHOUT passing it, so the default + # itself is under test (passing it explicitly would prove nothing). + def test_add_pattern_hint_ignore_case_defaults_to_false + agent = SignalWire::AgentBase.new + agent.add_pattern_hint('hello', '\\bhi\\b', 'hello there') hint = agent.instance_variable_get(:@hints).first - assert_equal 'foo', hint['pattern'] + assert_equal false, hint['ignore_case'] end end @@ -348,9 +359,19 @@ def test_add_language_speech_and_function_fillers assert_equal ['one moment'], lang['function_fillers'] end - def test_add_language_legacy_hash_form + # The preformed-hash form (`add_language(config_hash)`) was removed: the + # reference spells that capability #set_languages. name/code/voice are now all + # required, matching the reference's `add_language(name, code, voice, ...)`. + def test_add_language_requires_name_code_and_voice + agent = SignalWire::AgentBase.new + + assert_raises(ArgumentError) { agent.add_language('Spanish') } + assert_raises(ArgumentError) { agent.add_language('Spanish', 'es-ES') } + end + + def test_set_languages_is_the_hash_config_path agent = SignalWire::AgentBase.new - agent.add_language({ 'name' => 'Spanish', 'code' => 'es-ES', 'voice' => 'voice' }) + agent.set_languages([{ 'name' => 'Spanish', 'code' => 'es-ES', 'voice' => 'voice' }]) lang = agent.instance_variable_get(:@languages).first assert_equal 'Spanish', lang['name'] @@ -504,7 +525,8 @@ def setup def test_define_tool_with_block @agent.define_tool(name: 'greet', description: 'Say hello', - parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } }) do |args, _raw| + parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } }, + handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Hello, #{args['name']}!") end tools = @agent.define_tools @@ -529,7 +551,7 @@ def test_on_function_call_dispatch @agent.define_tool( name: 'echo', description: 'Echo back', - parameters: {} + parameters: {}, handler: nil ) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['text']}") end @@ -549,7 +571,7 @@ def test_tool_with_fillers @agent.define_tool( name: 'slow_op', description: 'Slow operation', - fillers: { 'en-US' => ['Please wait...', 'Working on it...'] } + fillers: { 'en-US' => ['Please wait...', 'Working on it...'] }, parameters: {}, handler: nil ) { |_, _| SignalWire::Swaig::FunctionResult.new('Done') } tools = @agent.define_tools @@ -558,7 +580,7 @@ def test_tool_with_fillers end def test_define_tool_returns_self - result = @agent.define_tool(name: 'x', description: 'x') { |_, _| } + result = @agent.define_tool(name: 'x', description: 'x', parameters: {}, handler: nil) { |_, _| } assert_same @agent, result end @@ -591,7 +613,7 @@ def test_add_hints end def test_add_language - @agent.add_language({ 'name' => 'English', 'code' => 'en-US', 'voice' => 'rachel' }) + @agent.add_language('English', 'en-US', 'rachel') swml = @agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -741,7 +763,7 @@ def test_set_post_prompt_llm_params end def test_add_pattern_hint - @agent.add_pattern_hint('SW.*', hint: 'SignalWire', language: 'en-US') + @agent.add_pattern_hint('SignalWire', 'SW.*', 'SignalWire') swml = @agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] pattern_hint = ai['hints'].find { |h| h.is_a?(Hash) } @@ -942,7 +964,7 @@ def test_record_call def test_with_tools agent = SignalWire::AgentBase.new - agent.define_tool(name: 'foo', description: 'Foo tool') { |_, _| } + agent.define_tool(name: 'foo', description: 'Foo tool', parameters: {}, handler: nil) { |_, _| } ai = rendered_ai(agent) assert ai.key?('SWAIG') @@ -1003,7 +1025,7 @@ class AgentRenderSwmlUrlsTest < Minitest::Test def test_webhook_url_in_swml agent = SignalWire::AgentBase.new(basic_auth: %w[u p]) - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] default_url = ai['SWAIG']['defaults']['web_hook_url'] @@ -1024,7 +1046,7 @@ def test_post_prompt_url_in_swml def test_web_hook_url_override agent = SignalWire::AgentBase.new agent.set_web_hook_url('https://custom.example.com/hook') - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -1051,7 +1073,7 @@ class AgentDynamicConfigTest < Minitest::Test def test_dynamic_config_callback_applied agent = SignalWire::AgentBase.new agent.set_prompt_text('Original') - agent.set_dynamic_config_callback do |_query, _body, _headers, ephemeral| + agent.set_dynamic_config_callback(nil) do |_query, _body, _headers, ephemeral| ephemeral.set_prompt_text('Modified') end swml = agent.render_swml @@ -1063,7 +1085,7 @@ def test_dynamic_config_callback_applied def test_original_not_mutated agent = SignalWire::AgentBase.new agent.set_prompt_text('Original') - agent.set_dynamic_config_callback do |_query, _body, _headers, ephemeral| + agent.set_dynamic_config_callback(nil) do |_query, _body, _headers, ephemeral| ephemeral.set_prompt_text('Modified') ephemeral.add_hint('NewHint') end @@ -1078,8 +1100,9 @@ def test_original_not_mutated def test_dynamic_config_can_add_tools agent = SignalWire::AgentBase.new - agent.set_dynamic_config_callback do |_q, _b, _h, ephemeral| - ephemeral.define_tool(name: 'dynamic_tool', description: 'Added dynamically') { |_, _| } + agent.set_dynamic_config_callback(nil) do |_q, _b, _h, ephemeral| + ephemeral.define_tool(name: 'dynamic_tool', description: 'Added dynamically', + parameters: {}, handler: nil) { |_, _| } end swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -1101,10 +1124,10 @@ class AgentRackTest < Minitest::Test def app @agent = SignalWire::AgentBase.new(basic_auth: %w[testuser testpass]) @agent.set_prompt_text('Hello') - @agent.define_tool(name: 'echo', description: 'Echo') do |args, _raw| + @agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['msg']}") end - @agent.on_summary do |summary, _raw| + @agent.on_summary(nil) do |summary, _raw| @last_summary = summary end @agent.rack_app @@ -1283,8 +1306,8 @@ class AgentMethodChainingTest < Minitest::Test ->(a) { a.prompt_add_subsection('T', 'S', 'B') }, ->(a) { a.add_hint('x') }, ->(a) { a.add_hints(['x']) }, - ->(a) { a.add_pattern_hint('p') }, - ->(a) { a.add_language({ 'name' => 'E', 'code' => 'en' }) }, + ->(a) { a.add_pattern_hint('h', 'p', 'r') }, + ->(a) { a.add_language('E', 'en', 'v') }, ->(a) { a.set_languages([]) }, ->(a) { a.add_pronunciation('a', 'b') }, ->(a) { a.set_pronunciations([]) }, @@ -1307,7 +1330,7 @@ class AgentMethodChainingTest < Minitest::Test :clear_post_answer_verbs.to_proc, ->(a) { a.add_post_ai_verb('hangup', {}) }, :clear_post_ai_verbs.to_proc, - ->(a) { a.set_dynamic_config_callback { |*| } }, + ->(a) { a.set_dynamic_config_callback(nil) { |*| } }, ->(a) { a.manual_set_proxy_url('x') }, ->(a) { a.set_web_hook_url('x') }, ->(a) { a.set_post_prompt_url('x') }, @@ -1316,8 +1339,8 @@ class AgentMethodChainingTest < Minitest::Test :enable_debug_routes.to_proc, :enable_sip_routing.to_proc, ->(a) { a.register_sip_username('u') }, - ->(a) { a.on_summary {} }, - ->(a) { a.on_debug_event {} }, + ->(a) { a.on_summary(nil) {} }, + ->(a) { a.on_debug_event(nil) {} }, ->(a) { a.register_swaig_function({ 'function' => 'x' }) }, ->(a) { a.remove_skill('nonexistent') } ].freeze @@ -1338,7 +1361,7 @@ class AgentProxyUrlTest < Minitest::Test def test_proxy_url_from_env ENV['SWML_PROXY_URL_BASE'] = 'https://proxy.example.com' agent = SignalWire::AgentBase.new - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -1351,7 +1374,7 @@ def test_proxy_url_from_env def test_manual_set_proxy_url agent = SignalWire::AgentBase.new agent.manual_set_proxy_url('https://manual.example.com') - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -1367,7 +1390,7 @@ class AgentSwaigQueryParamsTest < Minitest::Test def test_add_swaig_query_params agent = SignalWire::AgentBase.new(basic_auth: %w[u p]) agent.add_swaig_query_params({ 'tenant' => 'acme' }) - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -1379,7 +1402,7 @@ def test_clear_swaig_query_params agent = SignalWire::AgentBase.new agent.add_swaig_query_params({ 'key' => 'val' }) agent.clear_swaig_query_params - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -1422,7 +1445,7 @@ class AgentDebugEventTest < Minitest::Test def app @agent = SignalWire::AgentBase.new(basic_auth: %w[u p]) @received_event = nil - @agent.on_debug_event do |event_type, data| + @agent.on_debug_event(nil) do |event_type, data| @received_event = [event_type, data] end @agent.rack_app @@ -1620,7 +1643,7 @@ class AgentAsRouterTest < Minitest::Test def build_agent agent = SignalWire::AgentBase.new(basic_auth: %w[testuser testpass]) agent.set_prompt_text('Hello') - agent.define_tool(name: 'echo', description: 'Echo') do |args, _raw| + agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['msg']}") end agent diff --git a/tests/aiconfig_contract_test.rb b/tests/aiconfig_contract_test.rb index f70ef2d3..92beb2e7 100644 --- a/tests/aiconfig_contract_test.rb +++ b/tests/aiconfig_contract_test.rb @@ -30,8 +30,7 @@ def ai_block # Structured pattern hint: pattern + hint + replace(ment) + ignore_case all # survive as a HASH in ai.hints (a bare-string impl drops the structure). def test_pattern_hint_structure_survives_render - @agent.add_pattern_hint(hint: 'SignalWire', pattern: 'sw.*', - replace: 'SignalWire', ignore_case: true) + @agent.add_pattern_hint('SignalWire', 'sw.*', 'SignalWire', ignore_case: true) hint = ai_block['hints'].find { |h| h.is_a?(Hash) } diff --git a/tests/aiconfig_test.rb b/tests/aiconfig_test.rb index 5c2bbca5..4d921906 100644 --- a/tests/aiconfig_test.rb +++ b/tests/aiconfig_test.rb @@ -28,7 +28,7 @@ def test_add_hints end def test_add_pattern_hint - @agent.add_pattern_hint('SW.*', hint: 'SignalWire', language: 'en-US') + @agent.add_pattern_hint('SignalWire', 'SW.*', 'SignalWire') swml = @agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] pattern_hint = ai['hints'].find { |h| h.is_a?(Hash) } @@ -53,7 +53,7 @@ def setup end def test_add_language - @agent.add_language({ 'name' => 'English', 'code' => 'en-US', 'voice' => 'rachel' }) + @agent.add_language('English', 'en-US', 'rachel') swml = @agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -73,28 +73,18 @@ def test_set_languages assert_equal 2, ai['languages'].length end - # #34 regression (RED on the pre-fix code, which raised ArgumentError - # "wrong number of arguments (given 0)"). A braceless string-keyed hash — - # `add_language('name' => …, 'code' => …, 'voice' => …)` — is routed by Ruby - # toward keywords; it must be accepted as the hash config form. - def test_add_language_braceless_string_keyed_hash - @agent.add_language('name' => 'English', 'code' => 'en-US', 'voice' => 'rachel') - langs = @agent.instance_variable_get(:@languages) - - assert_equal 1, langs.length - assert_equal 'English', langs[0]['name'] - assert_equal 'en-US', langs[0]['code'] - assert_equal 'rachel', langs[0]['voice'] - end - - # The braceless symbol-keyed shape must also work, with keys stringified to - # match SWML's string-keyed language config. - def test_add_language_braceless_symbol_keyed_hash - @agent.add_language(name: 'French', code: 'fr-FR', voice: 'amelie') - langs = @agent.instance_variable_get(:@languages) - - assert_equal 'French', langs[0]['name'] - assert_equal 'fr-FR', langs[0]['code'] + # The hash-config shapes #34 added (`add_language(config_hash)` and the + # braceless `add_language('name' => …)`) were removed — the reference's + # `add_language` takes three REQUIRED positionals and spells the hash-config + # capability #set_languages. A hash in the `name` slot is now just a name. + def test_add_language_rejects_hash_config_shapes + assert_raises(ArgumentError) do + @agent.add_language('name' => 'English', 'code' => 'en-US', 'voice' => 'rachel') + end + assert_raises(ArgumentError) { @agent.add_language(name: 'French', code: 'fr-FR', voice: 'amelie') } + assert_raises(ArgumentError) do + @agent.add_language({ 'name' => 'English', 'code' => 'en-US', 'voice' => 'rachel' }) + end end # The positional form remains supported (no regression). @@ -376,8 +366,8 @@ def test_hint_and_language_setters_return_self assert_same agent, agent.add_hint('x') assert_same agent, agent.add_hints(['x']) - assert_same agent, agent.add_pattern_hint('p') - assert_same agent, agent.add_language({ 'name' => 'E', 'code' => 'en' }) + assert_same agent, agent.add_pattern_hint('h', 'p', 'r') + assert_same agent, agent.add_language('E', 'en', 'v') assert_same agent, agent.set_languages([]) assert_same agent, agent.add_pronunciation('a', 'b') assert_same agent, agent.set_pronunciations([]) diff --git a/tests/bedrock_agent_test.rb b/tests/bedrock_agent_test.rb index 866bea05..2c83dbd3 100644 --- a/tests/bedrock_agent_test.rb +++ b/tests/bedrock_agent_test.rb @@ -53,7 +53,7 @@ def test_system_prompt_constructor_arg def test_bedrock_object_keys_present_with_tool_and_post_prompt agent = SignalWire::Agents::BedrockAgent.new agent.set_prompt_text('Hi') - agent.define_tool(name: 't', description: 'd') { |_a, _r| {} } + agent.define_tool(name: 't', description: 'd', parameters: {}, handler: nil) { |_a, _r| {} } agent.set_post_prompt('summarize') ab = bedrock_verb(agent) diff --git a/tests/behavior_bundle_test.rb b/tests/behavior_bundle_test.rb index b8ceb909..b61838d4 100644 --- a/tests/behavior_bundle_test.rb +++ b/tests/behavior_bundle_test.rb @@ -139,7 +139,8 @@ class SummaryExtractionOrderTest < Minitest::Test def setup @agent = SignalWire::AgentBase.new @received = nil - @agent.on_summary { |summary, _raw| @received = summary } + # `summary` is required (reference parity); a registration states it as nil. + @agent.on_summary(nil) { |summary, _raw| @received = summary } end def test_prefers_top_level_summary_key diff --git a/tests/cli_test.rb b/tests/cli_test.rb index 203af05f..aaf36de1 100644 --- a/tests/cli_test.rb +++ b/tests/cli_test.rb @@ -212,7 +212,7 @@ def define_greet_tool(agent) agent.define_tool( name: 'greet', description: 'Greet someone by name', - parameters: { 'name' => { 'type' => 'string', 'description' => 'Person name' } } + parameters: { 'name' => { 'type' => 'string', 'description' => 'Person name' } }, handler: nil ) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Hello, #{args['name']}!") end diff --git a/tests/function_result_test.rb b/tests/function_result_test.rb index 7f693a7f..2a884fe4 100644 --- a/tests/function_result_test.rb +++ b/tests/function_result_test.rb @@ -905,3 +905,54 @@ def test_metadata_writer_mirrors_setter "expected a set_meta_data action, got #{actions.inspect}") end end + +# DEFAULT VALUES that come from CONSTANT references in the source +# (RecordFormat::WAV, TapDirection::BOTH, Codec::PCMU). scripts/signature_dump.rb +# resolves those constants, so the enumerated default must equal the reference's +# literal ("wav"/"both"/"PCMU") rather than being recorded as null. +class FunctionResultConstantDefaultsTest < Minitest::Test + include FunctionResultTestHelpers + + # Proven by equivalence: the wire produced when the params are OMITTED must + # equal the wire produced when they are passed EXPLICITLY as the default + # values, and must DIFFER for any other value. Asserting only the explicit + # call would not cover the default at all. + def test_tap_direction_and_codec_defaults_are_both_and_pcmu + omitted = swml_main_verb(FR.new.tap('rtp://10.0.0.1:9000'), 'tap') + explicit = swml_main_verb( + FR.new.tap('rtp://10.0.0.1:9000', direction: 'both', codec: 'PCMU'), 'tap' + ) + + assert_equal omitted, explicit + + other = swml_main_verb( + FR.new.tap('rtp://10.0.0.1:9000', direction: 'speak', codec: 'PCMA'), 'tap' + ) + + refute_equal omitted, other + end + + def test_record_call_format_and_direction_defaults_are_wav_and_both + omitted = swml_main_verb(FR.new.record_call, 'record_call') + explicit = swml_main_verb(FR.new.record_call(format: 'wav', direction: 'both'), 'record_call') + + assert_equal omitted, explicit + + other = swml_main_verb(FR.new.record_call(format: 'mp3', direction: 'speak'), 'record_call') + + refute_equal omitted, other + end + + # ai_response's DEFAULT (PAY_DEFAULT_AI_RESPONSE) IS emitted on the wire (the + # `set` verb), so the exact reference string is assertable directly — with + # ai_response NOT passed. + def test_pay_ai_response_default_matches_the_reference_string + main = swml_main_section(FR.new.pay(payment_connector_url: 'https://pay.example.com')) + + assert_equal( + 'The payment status is ${pay_result}, do not mention anything else ' \ + 'about collecting payment if successful.', + main[0]['set']['ai_response'] + ) + end +end diff --git a/tests/handle_request_core_test.rb b/tests/handle_request_core_test.rb index 43c77773..faafad77 100644 --- a/tests/handle_request_core_test.rb +++ b/tests/handle_request_core_test.rb @@ -78,7 +78,7 @@ def test_proxy_detected_from_x_forwarded_headers class HandleRequestCoreRoutingTest < HandleRequestCoreTestBase def test_routing_callback_returns_redirect seen = {} - @svc.register_routing_callback('/sip') { |body, headers| seen.merge!(body:, headers:) && '/redirected' } + @svc.register_routing_callback(nil, '/sip') { |body, headers| seen.merge!(body:, headers:) && '/redirected' } status, headers, body = @svc.handle_request('POST', 'http://host/sip', auth_headers, { 'call_id' => 'abc' }) assert_equal 307, status @@ -89,7 +89,7 @@ def test_routing_callback_returns_redirect end def test_routing_callback_returning_nil_falls_through - @svc.register_routing_callback('/sip') { |_body, _headers| nil } + @svc.register_routing_callback(nil, '/sip') { |_body, _headers| nil } status, = @svc.handle_request('POST', 'http://host/sip', auth_headers, { 'x' => 1 }) assert_equal 200, status @@ -97,7 +97,7 @@ def test_routing_callback_returning_nil_falls_through def test_single_arg_routing_callback_still_supported got = nil - @svc.register_routing_callback('/sip') do |body| + @svc.register_routing_callback(nil, '/sip') do |body| got = body '/legacy' end @@ -110,7 +110,7 @@ def test_single_arg_routing_callback_still_supported def test_get_does_not_trigger_routing_callback ran = false - @svc.register_routing_callback('/sip') do |_body, _headers| + @svc.register_routing_callback(nil, '/sip') do |_body, _headers| ran = true '/nope' end @@ -142,7 +142,7 @@ def test_agent_base_missing_auth_is_unauthorized def test_agent_base_routing_redirect agent = SignalWire::AgentBase.new(name: 'a', basic_auth: %w[u p]) - agent.register_routing_callback('/sip') { |_body, _headers| '/elsewhere' } + agent.register_routing_callback(nil, '/sip') { |_body, _headers| '/elsewhere' } status, headers, = agent.handle_request( 'POST', 'http://host/sip', auth_headers, { 'call_id' => 'z' } ) diff --git a/tests/lambda_agent_test.rb b/tests/lambda_agent_test.rb index 78ad1633..d33bb910 100644 --- a/tests/lambda_agent_test.rb +++ b/tests/lambda_agent_test.rb @@ -32,7 +32,7 @@ def test_lambda_url_used_when_no_proxy_base_root_route ENV['AWS_REGION'] = 'us-east-1' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -48,7 +48,7 @@ def test_lambda_url_used_when_no_proxy_base_non_root_route ENV['AWS_REGION'] = 'eu-west-2' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/my-agent') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -62,7 +62,7 @@ def test_aws_lambda_function_url_takes_precedence_over_derived ENV['AWS_LAMBDA_FUNCTION_URL'] = 'https://abc.lambda-url.us-west-2.on.aws' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -75,7 +75,7 @@ def test_region_defaults_to_us_east_1_when_not_set # AWS_REGION intentionally unset agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -85,7 +85,7 @@ def test_region_defaults_to_us_east_1_when_not_set def test_not_lambda_means_no_lambda_url # No Lambda env vars set; must fall back to the local server URL. agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -112,7 +112,7 @@ def test_proxy_base_with_non_root_route_on_lambda_preserves_route ENV['SWML_PROXY_URL_BASE'] = 'https://xyz.lambda-url.us-east-1.on.aws' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/my-agent') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -130,7 +130,7 @@ def test_proxy_base_without_route_still_works ENV['SWML_PROXY_URL_BASE'] = 'https://proxy.example.com' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -142,7 +142,7 @@ def test_proxy_base_with_trailing_slash_is_normalised ENV['SWML_PROXY_URL_BASE'] = 'https://proxy.example.com/' agent = SignalWire::AgentBase.new(basic_auth: %w[u p], route: '/my-agent') - agent.define_tool(name: 'test', description: 'test') { |_, _| } + agent.define_tool(name: 'test', description: 'test', parameters: {}, handler: nil) { |_, _| } url = default_swaig_url(agent) @@ -172,7 +172,7 @@ def setup def _define_echo_tool(agent) agent.define_tool(name: 'echo', description: 'Echo back a message', - parameters: { 'message' => { 'type' => 'string' } }) do |args, _raw| + parameters: { 'message' => { 'type' => 'string' } }, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("echo: #{args['message']}") end end diff --git a/tests/mcp_test.rb b/tests/mcp_test.rb index fa79e4f9..4349567b 100644 --- a/tests/mcp_test.rb +++ b/tests/mcp_test.rb @@ -25,7 +25,7 @@ def define_weather_tool(agent) description: 'Get the weather for a location', parameters: { 'location' => { 'type' => 'string', 'description' => 'City name' } - } + }, handler: nil ) do |args, _raw| loc = args['location'] || 'unknown' SignalWire::Swaig::FunctionResult.new("72F sunny in #{loc}") diff --git a/tests/parameter_schema_test.rb b/tests/parameter_schema_test.rb index c2e1f70e..307bfa4d 100644 --- a/tests/parameter_schema_test.rb +++ b/tests/parameter_schema_test.rb @@ -44,7 +44,7 @@ class ParameterSchemaTestBase < Minitest::Test def handwritten(parameters, required: nil) agent = SignalWire::AgentBase.new agent.define_tool(name: 't', description: 'd', - parameters: parameters, required: required) { |_, _| } + parameters: parameters, required: required, handler: nil) { |_, _| } agent.define_tools[0]['parameters'] end @@ -276,7 +276,7 @@ def setup def _define_lookup_tool @agent.define_tool(name: 'lookup', description: 'Look up a service', - parameters: @params) do |args, _raw| + parameters: @params, handler: nil) do |args, _raw| @invoked_with = args SignalWire::Swaig::FunctionResult.new("Looked up #{args['service']}") end diff --git a/tests/reference_required_and_defaults_test.rb b/tests/reference_required_and_defaults_test.rb new file mode 100644 index 00000000..6d3fc98f --- /dev/null +++ b/tests/reference_required_and_defaults_test.rb @@ -0,0 +1,394 @@ +# frozen_string_literal: true + +require 'minitest/autorun' + +ENV['SIGNALWIRE_LOG_MODE'] = 'off' + +require_relative '../lib/signalwire' +require_relative '../lib/signalwire/relay/client' + +# Pins the `required`-ness and DEFAULT VALUES that the cross-port signature +# checker compares against the Python reference. +# +# Two properties are under test, and both are easy to "cover" vacuously: +# +# * REQUIRED-ness — proven by asserting the call RAISES when the argument is +# omitted. A test that always passes the argument proves nothing about +# whether it could have been omitted. +# * DEFAULT VALUE — proven by exercising the path that USES the default, i.e. +# by NOT passing the argument. Passing it explicitly and asserting the value +# came back only proves the parameter is wired, not what it defaults to. +# +# Every assertion below therefore either omits the argument or asserts a raise. +# +# BEHAVIOUR IS NOT ENOUGH for required-ness, and this was proven by mutation: +# reverting `on_call(handler)` to `on_call(handler = nil)` left every behavioural +# assertion GREEN, because the method raises from its own guard either way. What +# the cross-port checker actually compares is the SIGNATURE (`:req` vs `:opt`), +# so the required-ness assertions below read `Method#parameters` directly. The +# behavioural raise-tests are kept alongside them — they cover the runtime +# contract; the signature assertions cover the declared one. + +# Assertion helpers over Ruby's parameter reflection — the same source the +# signature enumerator reads. +module ParameterKindAssertions + # The [kind, name] pairs for an instance method, e.g. [[:req, :handler]]. + def params_of(klass, meth) + klass.instance_method(meth).parameters + end + + def assert_required_positional(klass, meth, name) + assert_includes params_of(klass, meth), [:req, name], + "#{klass}##{meth} must declare #{name} as a REQUIRED positional " \ + '(the reference requires it; an optional-with-guard is a different signature)' + end + + def assert_required_keyword(klass, meth, name) + assert_includes params_of(klass, meth), [:keyreq, name], + "#{klass}##{meth} must declare #{name}: as a REQUIRED keyword" + end + + def assert_optional_positional(klass, meth, name) + assert_includes params_of(klass, meth), [:opt, name], + "#{klass}##{meth} must declare #{name} as OPTIONAL (the reference defaults it)" + end +end + +class ReferenceRequiredArgumentsTest < Minitest::Test + include ParameterKindAssertions + + AB = SignalWire::AgentBase + REGISTRY = SignalWire::Core::Agent::Tools::ToolRegistry + SERVICE = SignalWire::SWML::Service + + def setup + @agent = AB.new + end + + # --- handler/callback slots the reference declares REQUIRED -------- + + def test_define_tool_requires_parameters_and_handler + assert_required_keyword(AB, :define_tool, :parameters) + assert_required_keyword(AB, :define_tool, :handler) + + assert_raises(ArgumentError) { @agent.define_tool(name: 't', description: 'd') } + assert_raises(ArgumentError) { @agent.define_tool(name: 't', description: 'd', parameters: {}) } + assert_raises(ArgumentError) { @agent.define_tool(name: 't', description: 'd', handler: nil) } + end + + def test_tool_registry_define_tool_requires_parameters_and_handler + assert_required_keyword(REGISTRY, :define_tool, :parameters) + assert_required_keyword(REGISTRY, :define_tool, :handler) + + reg = REGISTRY.new + + assert_raises(ArgumentError) { reg.define_tool(name: 't', description: 'd') } + assert_raises(ArgumentError) { reg.define_tool(name: 't', description: 'd', parameters: {}) } + end + + def test_on_debug_event_requires_a_handler + assert_required_positional(AB, :on_debug_event, :handler) + + assert_raises(ArgumentError) { @agent.on_debug_event } + # nil in the slot with no block is a registration of nothing -> also raises. + assert_raises(ArgumentError) { @agent.on_debug_event(nil) } + end + + def test_set_dynamic_config_callback_requires_a_callback + assert_required_positional(AB, :set_dynamic_config_callback, :callable) + + assert_raises(ArgumentError) { @agent.set_dynamic_config_callback } + assert_raises(ArgumentError) { @agent.set_dynamic_config_callback(nil) } + end + + def test_on_summary_requires_the_summary_slot + assert_required_positional(AB, :on_summary, :summary) + + assert_raises(ArgumentError) { @agent.on_summary } + end + + def test_register_routing_callback_requires_a_callback + assert_required_positional(SERVICE, :register_routing_callback, :callback_fn) + + assert_raises(ArgumentError) { @agent.register_routing_callback } + assert_raises(ArgumentError) { @agent.register_routing_callback(nil) } + end + + def test_register_global_routing_callback_requires_callback_and_path + server = SignalWire::AgentServer.new + + assert_required_positional(SignalWire::AgentServer, :register_global_routing_callback, :callback_fn) + assert_required_positional(SignalWire::AgentServer, :register_global_routing_callback, :path) + + assert_raises(ArgumentError) { server.register_global_routing_callback(->(_b, _h) {}) } + assert_raises(ArgumentError) { server.register_global_routing_callback(nil, '/x') } + end + + # --- AI-config slots the reference declares REQUIRED --------------- + + def test_add_language_requires_name_code_and_voice + %i[name code voice].each { |p| assert_required_positional(AB, :add_language, p) } + + assert_raises(ArgumentError) { @agent.add_language('English') } + assert_raises(ArgumentError) { @agent.add_language('English', 'en-US') } + end + + def test_add_pattern_hint_requires_hint_pattern_and_replace + %i[hint pattern replace].each { |p| assert_required_positional(AB, :add_pattern_hint, p) } + + assert_raises(ArgumentError) { @agent.add_pattern_hint('h') } + assert_raises(ArgumentError) { @agent.add_pattern_hint('h', 'p') } + end + + # `add_pattern_hint`'s ignore_case DEFAULT is false (reference parity). + # Exercised by NOT passing it. + def test_add_pattern_hint_ignore_case_defaults_to_false + @agent.add_pattern_hint('SignalWire', 'sw.*', 'SignalWire') + + assert_equal false, @agent.instance_variable_get(:@hints).first['ignore_case'] + end +end + +class ReferenceRequiredRelayArgumentsTest < Minitest::Test + include ParameterKindAssertions + + RC = SignalWire::Relay::Client + + def client + RC.new(project: 'p', token: 't', host: 'example') + end + + def test_on_call_and_on_message_require_a_handler + assert_required_positional(RC, :on_call, :handler) + assert_required_positional(RC, :on_message, :handler) + + c = client + + assert_raises(ArgumentError) { c.on_call } + assert_raises(ArgumentError) { c.on_call(nil) } + assert_raises(ArgumentError) { c.on_message } + assert_raises(ArgumentError) { c.on_message(nil) } + end + + def test_execute_requires_params + assert_required_positional(RC, :execute, :params) + + assert_raises(ArgumentError) { client.execute('calling.dial') } + end + + def test_call_on_requires_a_handler + assert_required_positional(SignalWire::Relay::Call, :on, :handler) + + call = SignalWire::Relay::Call.new(client, call_id: 'c1', node_id: 'n1') + + assert_raises(ArgumentError) { call.on('calling.call.state') } + assert_raises(ArgumentError) { call.on('calling.call.state', nil) } + end + + def test_message_on_event_requires_a_handler + assert_required_positional(SignalWire::Relay::Message, :on_event, :handler) + + msg = SignalWire::Relay::Message.new(message_id: 'm1') + + assert_raises(ArgumentError) { msg.on_event } + assert_raises(ArgumentError) { msg.on_event(nil) } + end +end + +class ReferenceDefaultValuesTest < Minitest::Test + include ParameterKindAssertions + + def setup + @agent = SignalWire::AgentBase.new + end + + # --- prompt body defaults to "" (reference: `body: str = ""`) ------ + + # The default is exercised by NOT passing body. "" and nil must both leave the + # 'body' key OFF the section, matching the reference's `if self.body:` omit. + # The default VALUE is "" (not nil). Both produce the same wire (the key is + # omitted either way), so a key-absence assertion cannot distinguish them — a + # mutation to `body = nil` survived exactly such an assertion. The value is + # therefore captured directly: call the method with body OMITTED and read back + # what the parameter was bound to. + # + # `build_section` receives `body` verbatim, so a probe on it observes the + # default value the caller never supplied. + def observed_default_body + seen = :not_called + agent = SignalWire::AgentBase.new + agent.singleton_class.send(:define_method, :build_section) do |title, body, **opts| + seen = body + super(title, body, **opts) + end + agent.prompt_add_section('Role') + seen + end + + def test_prompt_add_section_body_defaults_to_empty_string_not_nil + assert_equal '', observed_default_body, + 'reference is `body: str = ""`; a nil default is a different contract' + end + + def test_prompt_add_section_omits_an_empty_default_body_from_the_wire + @agent.prompt_add_section('Role') + section = @agent.instance_variable_get(:@pom_sections).first + + refute section.key?('body'), 'an empty default body must not be emitted' + assert_equal 'Role', section['title'] + end + + # `prompt_add_subsection` builds its hash inline, so its default is observed + # the same way the signature enumerator sees it: off the parameter list. + def test_prompt_add_subsection_body_defaults_to_empty_string_not_nil + assert_equal '', default_of(:prompt_add_subsection, :body), + 'reference is `body: str = ""`; a nil default is a different contract' + end + + # The literal default expression for a positional param, read from the source + # line the method is defined on. This is the ONLY way Ruby exposes a default + # VALUE (Method#parameters reports only that one exists) and is precisely what + # scripts/signature_dump.rb parses. + def default_of(meth, param) + file, line = SignalWire::AgentBase.instance_method(meth).source_location + sig = File.readlines(file)[line - 1] + m = /\b#{param}\s*=\s*('[^']*'|"[^"]*"|nil)/.match(sig) + + refute_nil m, "no default found for #{param} in: #{sig.strip}" + eval(m[1]) # rubocop:disable Security/Eval -- a single matched literal from our own source + end + + def test_prompt_add_subsection_omits_an_empty_default_body_from_the_wire + @agent.prompt_add_section('Parent') + @agent.prompt_add_subsection('Parent', 'Child') + parent = @agent.instance_variable_get(:@pom_sections).first + sub = parent['subsections'].first + + refute sub.key?('body'), 'an empty default body must not be emitted' + assert_equal 'Child', sub['title'] + end + + # --- add_skill params defaults to nil (reference: `= None`) -------- + + # Exercised by NOT passing params. The nil must reach the factory normalised to + # {} — a factory that indexes params must not see a NoMethodError on nil. + # A minimal registered skill whose factory records the params it received. + class ParamsProbeSkill < SignalWire::Skills::SkillBase + class << self + attr_accessor :seen_params + end + + def name = 'p2_default_probe' + def description = 'records the params its factory was handed' + def setup = true + def register_tools = [] + end + + def test_add_skill_params_defaults_to_nil_and_normalises_for_the_factory + ParamsProbeSkill.seen_params = :never_called + SignalWire::Skills::SkillRegistry.register('p2_default_probe') do |params| + ParamsProbeSkill.seen_params = params + ParamsProbeSkill.new(nil, params) + end + + @agent.add_skill('p2_default_probe') + + # The DEFAULT (nil) is normalised to {} before the factory sees it, so a + # factory that indexes params never meets a nil. + assert_equal({}, ParamsProbeSkill.seen_params) + + # ...but the DECLARED default must still be nil, matching the reference + # (`params: dict | None = None`). The normalisation makes nil and {} + # behaviourally identical downstream — proven by mutation: changing the + # default to {} left the factory assertion above GREEN — so the declared + # value is asserted directly. This is the value the signature enumerator + # records and the cross-port checker compares. + assert_nil default_of(:add_skill, :params), + 'reference is `params: dict | None = None`; a {} default is a different contract' + end + + # --- AgentBase#define_contexts contexts defaults to nil ------------ + + # The reference's AgentBase-facing define_contexts (PromptMixin) defaults it; + # exercised by calling with NO argument, which must build/return the builder. + def test_define_contexts_contexts_defaults_to_nil + builder = @agent.define_contexts + + assert_kind_of SignalWire::Contexts::ContextBuilder, builder + assert_same builder, @agent.define_contexts + end + + # --- routing-callback path defaults to "/sip" ---------------------- + + # Exercised by NOT passing the path: the callback must land on "/sip". + def test_register_routing_callback_path_defaults_to_sip + @agent.register_routing_callback(->(_body, _headers) { '/elsewhere' }) + paths = @agent.instance_variable_get(:@routing_callbacks).keys + + assert_equal ['/sip'], paths + end + + # --- reverse direction: params the reference makes OPTIONAL -------- + + # `add_answer_verb` config is optional in the reference; the no-argument call + # must be accepted (it was REQUIRED here, which was the flip). + def test_add_answer_verb_config_is_optional + assert_optional_positional(SignalWire::AgentBase, :add_answer_verb, :config) + assert_same @agent, @agent.add_answer_verb + end + + # `on_function_call` raw_data is optional in the reference. + def test_on_function_call_raw_data_is_optional + assert_optional_positional(SignalWire::AgentBase, :on_function_call, :raw_data) + assert_optional_positional(SignalWire::SWML::Service, :on_function_call, :raw_data) + + @agent.define_tool(name: 'echo', description: 'e', parameters: {}, handler: nil) do |_a, _r| + SignalWire::Swaig::FunctionResult.new('ok') + end + + assert_equal 'ok', @agent.on_function_call('echo', {})['response'] + end + + # `serve_static_files` route is optional in the reference (default "/"). + def test_serve_static_files_route_defaults_to_root + assert_optional_positional(SignalWire::AgentServer, :serve_static_files, :route) + + server = SignalWire::AgentServer.new + server.serve_static_files(__dir__) + routes = server.instance_variable_get(:@static_routes).keys + + assert_equal [''], routes + end + + # AgentBase#define_contexts is the PromptMixin analog -> OPTIONAL. Ruby's own + # PromptManager#define_contexts is the PromptManager analog -> REQUIRED. The + # two reference methods genuinely differ; both sides are pinned here so a + # future "unify them" edit cannot silently reintroduce the drift. + def test_define_contexts_required_ness_differs_by_class + assert_optional_positional(SignalWire::AgentBase, :define_contexts, :contexts) + assert_includes SignalWire::Core::Agent::Prompt::PromptManager + .instance_method(:define_contexts).parameters, + %i[req contexts] + end +end + +class ReferenceDialKeywordsTest < Minitest::Test + # `dial` mirrors the reference's `(devices, *, tag=None, max_duration=None, + # dial_timeout=None)`. The old Ruby spelling was `timeout: 120` plus a + # **kwargs passenger for max_duration; both are gone. + def test_dial_rejects_the_removed_timeout_keyword + c = SignalWire::Relay::Client.new(project: 'p', token: 't', host: 'example') + + assert_raises(ArgumentError) { c.dial([[{ 'type' => 'phone' }]], timeout: 5) } + end + + def test_dial_accepts_the_reference_keywords + params = SignalWire::Relay::Client.instance_method(:dial).parameters + + keywords = params.filter_map { |kind, name| name if kind == :key } + + assert_equal %i[tag max_duration dial_timeout], keywords + # No **kwargs passenger: every keyword the reference names is explicit. + refute_includes params.map(&:first), :keyrest + end +end diff --git a/tests/relay/actions_mock_test.rb b/tests/relay/actions_mock_test.rb index df267e14..04edb910 100644 --- a/tests/relay/actions_mock_test.rb +++ b/tests/relay/actions_mock_test.rb @@ -40,7 +40,7 @@ def teardown def answered_inbound_call(call_id = 'act-call-1') captured_q = Queue.new handler_done = Queue.new - @client.on_call { |call| _capture_answered_call(call, captured_q, handler_done) } + @client.on_call(nil) { |call| _capture_answered_call(call, captured_q, handler_done) } @mock.inbound_call(call_id: call_id, auto_states: ['created']) Timeout.timeout(5) { handler_done.pop } call = Timeout.timeout(5) { captured_q.pop } diff --git a/tests/relay/convenience_mock_test.rb b/tests/relay/convenience_mock_test.rb index 4e489156..dff882e3 100644 --- a/tests/relay/convenience_mock_test.rb +++ b/tests/relay/convenience_mock_test.rb @@ -52,7 +52,7 @@ def phone_device(to: '+15551112222', frm: '+15553334444') def dial_call(tag:, call_id:, states: %w[created answered]) @mock.arm_dial(tag: tag, winner_call_id: call_id, states: states, node_id: 'node-mock-1', device: phone_device) - call = @client.dial([[phone_device]], tag: tag, timeout: 5) + call = @client.dial([[phone_device]], tag: tag, dial_timeout: 5) assert_kind_of SignalWire::Relay::Call, call assert_equal call_id, call.call_id diff --git a/tests/relay/event_dispatch_mock_test.rb b/tests/relay/event_dispatch_mock_test.rb index cc0bfbb2..a66e794d 100644 --- a/tests/relay/event_dispatch_mock_test.rb +++ b/tests/relay/event_dispatch_mock_test.rb @@ -36,7 +36,7 @@ def teardown def answered_call(call_id = 'evt-call-1') captured_q = Queue.new handler_done = Queue.new - @client.on_call { |call| _answer_and_signal(call, captured_q, handler_done) } + @client.on_call(nil) { |call| _answer_and_signal(call, captured_q, handler_done) } @mock.inbound_call(call_id: call_id, auto_states: ['created']) Timeout.timeout(5) { handler_done.pop } call = Timeout.timeout(5) { captured_q.pop } @@ -218,7 +218,7 @@ def test_event_ack_sent_back_to_server def test_dial_event_routes_via_tag_when_no_top_level_call_id arm_tag_dial('ec-tag-route', 'WINTAG') device = { 'type' => 'phone', 'params' => { 'to_number' => '+1', 'from_number' => '+2' } } - call = @client.dial([[device]], tag: 'ec-tag-route', timeout: 5) + call = @client.dial([[device]], tag: 'ec-tag-route', dial_timeout: 5) assert_equal 'WINTAG', call.call_id sends = @mock.journal_send(event_type: 'calling.call.dial') @@ -296,7 +296,7 @@ def test_call_state_event_updates_state def test_call_listener_fires_on_event call = answered_call('ec-list') fired_q = Queue.new - call.on('calling.call.play') { |event| fired_q.push(event) } + call.on('calling.call.play', nil) { |event| fired_q.push(event) } params = { 'call_id' => 'ec-list', 'control_id' => 'x', 'state' => 'playing' } @mock.push(bare_event_frame('calling.call.play', params)) event = Timeout.timeout(2) { fired_q.pop } diff --git a/tests/relay/inbound_call_mock_test.rb b/tests/relay/inbound_call_mock_test.rb index c567ad7e..77c0a9ee 100644 --- a/tests/relay/inbound_call_mock_test.rb +++ b/tests/relay/inbound_call_mock_test.rb @@ -67,7 +67,7 @@ def state_push_frame(call_id, call_state, tag: '', direction: 'inbound') def receive_inbound(call_id:, **, &mapper) mapper ||= ->(call) { call } queue = Queue.new - @client.on_call { |call| queue.push(mapper.call(call)) } + @client.on_call(nil) { |call| queue.push(mapper.call(call)) } @mock.inbound_call(call_id: call_id, auto_states: ['created'], **) Timeout.timeout(TIMEOUT) { queue.pop } end @@ -173,7 +173,7 @@ def test_pass_in_handler_journals_calling_pass def test_multiple_inbound_calls_in_sequence_each_unique_object seen_q = Queue.new - @client.on_call { |call| seen_q.push(call) } + @client.on_call(nil) { |call| seen_q.push(call) } fire_inbound('c-seq-1') sleep 0.1 fire_inbound('c-seq-2') @@ -213,7 +213,7 @@ def answer_two_inbound_calls(id1, id2) # answers it, and signals completion on the returned Queue. def register_answering_handler(store, mutex) pushed = Queue.new - @client.on_call do |call| + @client.on_call(nil) do |call| mutex.synchronize { store[call.call_id] = call } call.answer pushed.push(true) @@ -264,7 +264,7 @@ def test_handler_exception_does_not_crash_client # call, and wait for the handler to fire. def fire_handler_that_raises(call_id) fired_q = Queue.new - @client.on_call do |_call| + @client.on_call(nil) do |_call| fired_q.push(true) raise 'intentional from handler' end @@ -293,7 +293,7 @@ def test_scenario_play_full_inbound_flow def register_capturing_answer_handler captured_q = Queue.new started_q = Queue.new - @client.on_call do |call| + @client.on_call(nil) do |call| captured_q.push(call) call.answer started_q.push(true) diff --git a/tests/relay/messaging_mock_test.rb b/tests/relay/messaging_mock_test.rb index 121ba306..d5d155dd 100644 --- a/tests/relay/messaging_mock_test.rb +++ b/tests/relay/messaging_mock_test.rb @@ -172,7 +172,7 @@ class RelayMessagingInboundMockTest < Minitest::Test def test_inbound_message_fires_on_message_handler received_q = Queue.new - @client.on_message { |m| received_q.push(m) } + @client.on_message(nil) { |m| received_q.push(m) } push_event('messaging.receive', inbound_message_params) Timeout.timeout(5) { @inbound = received_q.pop } diff --git a/tests/relay/outbound_call_mock_test.rb b/tests/relay/outbound_call_mock_test.rb index 8baf768a..2205d054 100644 --- a/tests/relay/outbound_call_mock_test.rb +++ b/tests/relay/outbound_call_mock_test.rb @@ -42,7 +42,7 @@ def phone_device(to: '+15551112222', frm: '+15553334444') def arm_and_dial(tag:, winner:, states: %w[created answered], arm: {}, dial: {}, devices: nil) @mock.arm_dial(tag: tag, winner_call_id: winner, states: states, node_id: 'node-mock-1', device: phone_device, **arm) - @client.dial(devices || [[phone_device]], tag: tag, timeout: 5, **dial) + @client.dial(devices || [[phone_device]], tag: tag, dial_timeout: 5, **dial) end # The single calling.dial frame's params (asserts exactly one was sent). @@ -103,7 +103,7 @@ def test_dial_auto_generates_uuid_tag_when_omitted seen_tag = Queue.new pusher = Thread.new { push_winner_for_pending_dial(seen_tag) } - call = @client.dial([[phone_device]], timeout: 5) + call = @client.dial([[phone_device]], dial_timeout: 5) pusher.join(5) tag = seen_tag.pop @@ -143,7 +143,7 @@ def test_dial_failed_raises_relay_error @mock.push(call_dial_event('t-fail', 'failed', {})) end err = assert_raises(SignalWire::Relay::RelayError) do - @client.dial([[phone_device]], tag: 't-fail', timeout: 5) + @client.dial([[phone_device]], tag: 't-fail', dial_timeout: 5) end pusher.join(5) @@ -152,7 +152,7 @@ def test_dial_failed_raises_relay_error def test_dial_timeout_when_no_dial_event err = assert_raises(SignalWire::Relay::ActionTimeoutError) do - @client.dial([[phone_device]], tag: 't-timeout', timeout: 0.5) + @client.dial([[phone_device]], tag: 't-timeout', dial_timeout: 0.5) end assert_match(/timed out/i, err.message) end diff --git a/tests/relay/tier3_typed_objects_test.rb b/tests/relay/tier3_typed_objects_test.rb index ea8cff6f..3bf95f9e 100644 --- a/tests/relay/tier3_typed_objects_test.rb +++ b/tests/relay/tier3_typed_objects_test.rb @@ -57,7 +57,7 @@ def phone_device_hash(to: '+15551112222', frm: '+15553334444') def dial_call(tag:, call_id:, devices:, states: %w[created answered]) @mock.arm_dial(tag: tag, winner_call_id: call_id, states: states, node_id: 'node-mock-1', device: phone_device_hash) - call = @client.dial(devices, tag: tag, timeout: 5) + call = @client.dial(devices, tag: tag, dial_timeout: 5) assert_kind_of R::Call, call assert_equal call_id, call.call_id @@ -364,7 +364,7 @@ def test_call_state_event_terminal_accessor_agrees_over_real_event call = dial_call(tag: 't-cs', call_id: 'C-CS', devices: [[phone_device_hash]]) captured = [] - call.on(R::EVENT_CALL_STATE) { |e| captured << e } + call.on(R::EVENT_CALL_STATE, nil) { |e| captured << e } # Dispatch a real ended state event (same path RelayClient uses). call._dispatch_event('event_type' => 'calling.call.state', 'params' => { 'call_id' => 'C-CS', 'call_state' => 'ended' }) diff --git a/tests/relay_test.rb b/tests/relay_test.rb index c0b8ab14..80d0a524 100644 --- a/tests/relay_test.rb +++ b/tests/relay_test.rb @@ -486,7 +486,7 @@ def test_call_dispatch_state_event def test_call_event_listener events_received = [] - @call.on('calling.call.state') { |e| events_received << e } + @call.on('calling.call.state', nil) { |e| events_received << e } @call._dispatch_event(payload('calling.call.state', 'call_id' => 'call-1', 'call_state' => 'ending')) assert_equal 1, events_received.length @@ -674,7 +674,7 @@ def test_message_event_listener msg = SignalWire::Relay::Message.new(message_id: 'msg-5', state: 'queued') events = [] - msg.on_event { |e| events << e } + msg.on_event(nil) { |e| events << e } msg._dispatch_event(message_state('msg-5', 'sent')) assert_equal 1, events.length diff --git a/tests/render_test.rb b/tests/render_test.rb index 8cf7f63c..dcd3f4b2 100644 --- a/tests/render_test.rb +++ b/tests/render_test.rb @@ -59,7 +59,7 @@ class RenderWithToolsTest < Minitest::Test def test_tools_rendered agent = SignalWire::AgentBase.new - agent.define_tool(name: 'foo', description: 'Foo tool') { |_, _| } + agent.define_tool(name: 'foo', description: 'Foo tool', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = ai_section(swml) diff --git a/tests/rest_relay_parity_test.rb b/tests/rest_relay_parity_test.rb index abe5b45c..b110f797 100644 --- a/tests/rest_relay_parity_test.rb +++ b/tests/rest_relay_parity_test.rb @@ -170,8 +170,9 @@ def initialize @registered = [] end - def register_routing_callback(path, &block) - @registered << [path, block] + # Reference param order: (callback_fn, path="/sip"). + def register_routing_callback(callback_fn = nil, path = '/sip', &block) + @registered << [path, block || callback_fn] end end @@ -185,7 +186,7 @@ def setup def test_registers_callback_on_every_agent cb = ->(_req, _data) { 'route' } - @server.register_global_routing_callback(cb, path: '/sw') + @server.register_global_routing_callback(cb, '/sw') [@a1, @a2].each do |agent| assert_equal 1, agent.registered.length @@ -197,24 +198,24 @@ def test_registers_callback_on_every_agent end def test_normalizes_path_leading_and_trailing_slash - @server.register_global_routing_callback(->(_r, _d) {}, path: 'webhook/') + @server.register_global_routing_callback(->(_r, _d) {}, 'webhook/') assert_equal '/webhook', @a1.registered.first[0] end def test_accepts_block_form block = proc { 'x' } - @server.register_global_routing_callback(path: '/blk', &block) + @server.register_global_routing_callback(nil, '/blk', &block) assert_same block, @a1.registered.first[1] end def test_returns_self_for_chaining - assert_same @server, @server.register_global_routing_callback(->(_r, _d) {}, path: '/c') + assert_same @server, @server.register_global_routing_callback(->(_r, _d) {}, '/c') end def test_requires_a_callback - assert_raises(ArgumentError) { @server.register_global_routing_callback(path: '/none') } + assert_raises(ArgumentError) { @server.register_global_routing_callback(nil, '/none') } end end diff --git a/tests/schema_utils_test.rb b/tests/schema_utils_test.rb index 9f8585b2..619145d5 100644 --- a/tests/schema_utils_test.rb +++ b/tests/schema_utils_test.rb @@ -62,7 +62,7 @@ def test_parameter_normalisation agent.define_tool( name: 'test', description: 'Test', - parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } } + parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } }, handler: nil ) { |_, _| } tools = agent.define_tools @@ -74,7 +74,7 @@ def test_parameter_normalisation def test_empty_parameters_normalised agent = SignalWire::AgentBase.new - agent.define_tool(name: 'test', description: 'Test', parameters: {}) { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } tools = agent.define_tools params = tools[0]['parameters'] diff --git a/tests/secure_default_test.rb b/tests/secure_default_test.rb index 9abbaefe..f6ccb093 100644 --- a/tests/secure_default_test.rb +++ b/tests/secure_default_test.rb @@ -21,8 +21,8 @@ def setup # The SDK-recorded flag: a default define_tool is secure; secure:false is not. def test_define_tool_defaults_secure_true - @agent.define_tool(name: 'a', description: 'd', parameters: {}) { |_a, _r| nil } - @agent.define_tool(name: 'b', description: 'd', parameters: {}, secure: false) { |_a, _r| nil } + @agent.define_tool(name: 'a', description: 'd', parameters: {}, handler: nil) { |_a, _r| nil } + @agent.define_tool(name: 'b', description: 'd', parameters: {}, secure: false, handler: nil) { |_a, _r| nil } tools = @agent.instance_variable_get(:@tools) @@ -33,9 +33,9 @@ def test_define_tool_defaults_secure_true # The wire manifestation: with a call_id, the secure tool's webhook carries a # __token; the insecure tool's does not. def test_secure_tool_webhook_carries_token_with_call_id - @agent.define_tool(name: 'sd_default_secure', description: 'd', parameters: {}) { |_a, _r| nil } + @agent.define_tool(name: 'sd_default_secure', description: 'd', parameters: {}, handler: nil) { |_a, _r| nil } @agent.define_tool(name: 'sd_explicit_insecure', description: 'd', - parameters: {}, secure: false) { |_a, _r| nil } + parameters: {}, secure: false, handler: nil) { |_a, _r| nil } fns = swaig_functions(@agent.send(:_render_swml_internal, call_id: CALL_ID)) by_name = fns.to_h { |f| [f['function'], f] } @@ -48,7 +48,7 @@ def test_secure_tool_webhook_carries_token_with_call_id # Without a call_id, no token is minted (the render is call-agnostic). def test_no_token_without_call_id - @agent.define_tool(name: 'sd_default_secure', description: 'd', parameters: {}) { |_a, _r| nil } + @agent.define_tool(name: 'sd_default_secure', description: 'd', parameters: {}, handler: nil) { |_a, _r| nil } fns = swaig_functions(@agent.send(:_render_swml_internal)) entry = fns.find { |f| f['function'] == 'sd_default_secure' } || {} diff --git a/tests/served_routing_redirect_test.rb b/tests/served_routing_redirect_test.rb index 3c63b1d3..206999f5 100644 --- a/tests/served_routing_redirect_test.rb +++ b/tests/served_routing_redirect_test.rb @@ -20,7 +20,7 @@ class ServedRoutingRedirectTest < Minitest::Test def app @agent = SignalWire::AgentBase.new(name: 'a', basic_auth: %w[u p]) @agent.set_prompt_text('Hello') - @agent.register_routing_callback('/sip') { |_body, _headers| '/redirected' } + @agent.register_routing_callback(nil, '/sip') { |_body, _headers| '/redirected' } @agent.rack_app end diff --git a/tests/serverless_dispatch_test.rb b/tests/serverless_dispatch_test.rb index 051eb5bc..1d5be3e6 100644 --- a/tests/serverless_dispatch_test.rb +++ b/tests/serverless_dispatch_test.rb @@ -32,7 +32,7 @@ def build_agent agent = SignalWire::AgentBase.new(name: 'sless', route: '/', basic_auth: %w[u p]) agent.set_prompt_text('Hello from serverless') agent.define_tool(name: 'echo', description: 'echo', - parameters: { 'message' => { 'type' => 'string' } }) do |args, _raw| + parameters: { 'message' => { 'type' => 'string' } }, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("echo: #{args['message']}") end agent diff --git a/tests/simulate_serverless_test.rb b/tests/simulate_serverless_test.rb index 21841ce6..e6843e05 100644 --- a/tests/simulate_serverless_test.rb +++ b/tests/simulate_serverless_test.rb @@ -58,7 +58,7 @@ def tool_source(tool) AGENT.define_tool( name: #{tool[:name].inspect}, description: #{tool[:description].inspect}, - parameters: #{tool.fetch(:parameters, {}).inspect} + parameters: #{tool.fetch(:parameters, {}).inspect}, handler: nil ) do |args, raw| #{tool.fetch(:body, "SignalWire::Swaig::FunctionResult.new('ok')")} end diff --git a/tests/sip_served_routing_test.rb b/tests/sip_served_routing_test.rb index db3a3a93..6dc083ea 100644 --- a/tests/sip_served_routing_test.rb +++ b/tests/sip_served_routing_test.rb @@ -91,7 +91,7 @@ def test_served_sip_redirects_when_callback_returns_location @agent = build_agent # Register a SIP-path routing callback that redirects on a parsed username — # the same wiring enable_sip_routing uses, exercising the redirect branch. - @agent.register_routing_callback('/sip') do |body, _headers| + @agent.register_routing_callback(nil, '/sip') do |body, _headers| user = SignalWire::AgentBase.extract_sip_username_from_request(body) user ? "/agents/#{user}" : nil end diff --git a/tests/swml_service_swaig_test.rb b/tests/swml_service_swaig_test.rb index 56cd943d..e4aa21cb 100644 --- a/tests/swml_service_swaig_test.rb +++ b/tests/swml_service_swaig_test.rb @@ -164,7 +164,7 @@ def _register_sidecar_tool def _register_event_sink events_seen = [] - @svc.register_routing_callback('/events') do |body| + @svc.register_routing_callback(nil, '/events') do |body| events_seen << (body && body['type']) { 'ok' => true } end diff --git a/tests/swml_strict_render_test.rb b/tests/swml_strict_render_test.rb index a8ef4ab1..0edcd90b 100644 --- a/tests/swml_strict_render_test.rb +++ b/tests/swml_strict_render_test.rb @@ -128,7 +128,9 @@ def test_ai_params_subobject_stays_open def test_dangling_function_ref_raises agent = strict_agent - agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}) { |_a, _r| nil } + agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}, handler: nil) do |_a, _r| + nil + end contexts = agent.define_contexts step = contexts.add_context('default').add_step('help') step.set_text('help the caller') @@ -140,7 +142,9 @@ def test_dangling_function_ref_raises def test_registered_function_ref_renders agent = strict_agent - agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}) { |_a, _r| nil } + agent.define_tool(name: 'order_status', description: 'look up an order', parameters: {}, handler: nil) do |_a, _r| + nil + end contexts = agent.define_contexts step = contexts.add_context('default').add_step('help') step.set_text('help the caller') diff --git a/tests/swml_test.rb b/tests/swml_test.rb index e742819b..ebbc2179 100644 --- a/tests/swml_test.rb +++ b/tests/swml_test.rb @@ -593,7 +593,7 @@ def test_post_with_json_body # -- Routing callback --------------------------------------------------- def test_routing_callback - @service.register_routing_callback('/custom') do |data| + @service.register_routing_callback(nil, '/custom') do |data| { 'custom' => true, 'received' => data } end diff --git a/tests/tool_registry_test.rb b/tests/tool_registry_test.rb index 9cdb2b6d..d8350c4f 100644 --- a/tests/tool_registry_test.rb +++ b/tests/tool_registry_test.rb @@ -13,7 +13,7 @@ def setup def test_define_tool_and_get @registry.define_tool(name: 'greet', description: 'Say hi', - parameters: { 'name' => { 'type' => 'string' } }) + parameters: { 'name' => { 'type' => 'string' } }, handler: nil) fn = @registry.get_function('greet') refute_nil fn @@ -22,7 +22,7 @@ def test_define_tool_and_get end def test_has_function - @registry.define_tool(name: 'a', description: 'd') + @registry.define_tool(name: 'a', description: 'd', parameters: {}, handler: nil) assert @registry.has_function('a') refute @registry.has_function('missing') @@ -34,7 +34,7 @@ def test_get_function_missing_returns_nil def test_define_tool_normalises_parameters_into_object_schema @registry.define_tool(name: 't', description: 'd', - parameters: { 'city' => { 'type' => 'string' } }) + parameters: { 'city' => { 'type' => 'string' } }, handler: nil) schema = @registry.get_function('t')['parameters'] assert_equal 'object', schema['type'] @@ -44,7 +44,7 @@ def test_define_tool_normalises_parameters_into_object_schema def test_define_tool_injects_required @registry.define_tool(name: 't', description: 'd', parameters: { 'city' => { 'type' => 'string' } }, - required: ['city']) + required: ['city'], handler: nil) schema = @registry.get_function('t')['parameters'] assert_includes schema['required'], 'city' @@ -54,7 +54,7 @@ def test_define_tool_optional_fields @registry.define_tool(name: 't', description: 'd', wait_file: 'https://x/w.mp3', wait_file_loops: 2, webhook_url: 'https://x/hook', - fillers: { 'en-US' => ['wait'] }) + fillers: { 'en-US' => ['wait'] }, parameters: {}, handler: nil) fn = @registry.get_function('t') assert_equal 'https://x/w.mp3', fn['wait_file'] @@ -64,15 +64,16 @@ def test_define_tool_optional_fields end def test_define_tool_swaig_fields_merged - @registry.define_tool(name: 't', description: 'd', swaig_fields: { 'meta_data' => { 'k' => 'v' } }) + @registry.define_tool(name: 't', description: 'd', swaig_fields: { 'meta_data' => { 'k' => 'v' } }, parameters: {}, + handler: nil) assert_equal({ 'k' => 'v' }, @registry.get_function('t')['meta_data']) end def test_define_tool_duplicate_raises - @registry.define_tool(name: 'dup', description: 'd') + @registry.define_tool(name: 'dup', description: 'd', parameters: {}, handler: nil) - assert_raises(ArgumentError) { @registry.define_tool(name: 'dup', description: 'd2') } + assert_raises(ArgumentError) { @registry.define_tool(name: 'dup', description: 'd2', parameters: {}, handler: nil) } end def test_register_swaig_function @@ -100,7 +101,7 @@ def test_register_swaig_function_duplicate_raises end def test_get_all_functions_returns_copy - @registry.define_tool(name: 'a', description: 'd') + @registry.define_tool(name: 'a', description: 'd', parameters: {}, handler: nil) @registry.register_swaig_function({ 'function' => 'b' }) all = @registry.get_all_functions @@ -112,7 +113,7 @@ def test_get_all_functions_returns_copy end def test_remove_function - @registry.define_tool(name: 'a', description: 'd') + @registry.define_tool(name: 'a', description: 'd', parameters: {}, handler: nil) assert @registry.remove_function('a') refute @registry.has_function('a') diff --git a/tests/tool_test.rb b/tests/tool_test.rb index 0ba04412..3aeaf412 100644 --- a/tests/tool_test.rb +++ b/tests/tool_test.rb @@ -13,7 +13,8 @@ def setup def test_define_tool_with_block @agent.define_tool(name: 'greet', description: 'Say hello', - parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } }) do |args, _raw| + parameters: { 'name' => { 'type' => 'string', 'description' => 'Name' } }, + handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Hello, #{args['name']}!") end @@ -25,14 +26,14 @@ def test_define_tool_with_block end def test_define_tool_returns_self - result = @agent.define_tool(name: 'x', description: 'x') { |_, _| } + result = @agent.define_tool(name: 'x', description: 'x', parameters: {}, handler: nil) { |_, _| } assert_same @agent, result end def test_define_multiple_tools 3.times do |i| - @agent.define_tool(name: "tool_#{i}", description: "Tool #{i}") { |_, _| } + @agent.define_tool(name: "tool_#{i}", description: "Tool #{i}", parameters: {}, handler: nil) { |_, _| } end assert_equal 3, @agent.define_tools.length @@ -42,7 +43,7 @@ def test_tool_with_fillers @agent.define_tool( name: 'slow_op', description: 'Slow operation', - fillers: { 'en-US' => ['Please wait...', 'Working on it...'] } + fillers: { 'en-US' => ['Please wait...', 'Working on it...'] }, parameters: {}, handler: nil ) { |_, _| SignalWire::Swaig::FunctionResult.new('Done') } tools = @agent.define_tools @@ -60,7 +61,7 @@ def test_on_function_call_dispatch @agent.define_tool( name: 'echo', description: 'Echo back', - parameters: {} + parameters: {}, handler: nil ) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['text']}") end @@ -77,7 +78,7 @@ def test_on_function_call_unknown end def test_on_function_call_error_handling - @agent.define_tool(name: 'bad', description: 'Raises') do |_, _| + @agent.define_tool(name: 'bad', description: 'Raises', parameters: {}, handler: nil) do |_, _| raise 'intentional error' end @@ -133,9 +134,9 @@ def weather_datamap class DefineToolsOrderingTest < Minitest::Test def test_tools_appear_before_swaig_functions agent = SignalWire::AgentBase.new - agent.define_tool(name: 'tool_a', description: 'A') { |_, _| } + agent.define_tool(name: 'tool_a', description: 'A', parameters: {}, handler: nil) { |_, _| } agent.register_swaig_function({ 'function' => 'dm_b', 'description' => 'B' }) - agent.define_tool(name: 'tool_c', description: 'C') { |_, _| } + agent.define_tool(name: 'tool_c', description: 'C', parameters: {}, handler: nil) { |_, _| } tools = agent.define_tools names = tools.map { |t| t['function'] } diff --git a/tests/tool_token_test.rb b/tests/tool_token_test.rb index 5de7c680..e0fc9cbf 100644 --- a/tests/tool_token_test.rb +++ b/tests/tool_token_test.rb @@ -20,7 +20,7 @@ def make_agent_with_tool(secure: true) name: 'test_tool', description: 't', parameters: {}, - secure: secure + secure: secure, handler: nil ) { |_args, _raw| { 'response' => 'ok' } } agent end diff --git a/tests/web_test.rb b/tests/web_test.rb index d6150e7f..c033130e 100644 --- a/tests/web_test.rb +++ b/tests/web_test.rb @@ -9,7 +9,7 @@ class WebhookUrlTest < Minitest::Test def test_webhook_url_in_swml agent = SignalWire::AgentBase.new(basic_auth: %w[u p]) - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] default_url = ai['SWAIG']['defaults']['web_hook_url'] @@ -21,7 +21,7 @@ def test_webhook_url_in_swml def test_web_hook_url_override agent = SignalWire::AgentBase.new agent.set_web_hook_url('https://custom.example.com/hook') - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -52,7 +52,7 @@ class ProxyUrlTest < Minitest::Test def test_proxy_url_from_env ENV['SWML_PROXY_URL_BASE'] = 'https://proxy.example.com' agent = SignalWire::AgentBase.new - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -65,7 +65,7 @@ def test_proxy_url_from_env def test_manual_set_proxy_url agent = SignalWire::AgentBase.new agent.manual_set_proxy_url('https://manual.example.com') - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -78,7 +78,7 @@ class SwaigQueryParamsTest < Minitest::Test def test_add_swaig_query_params agent = SignalWire::AgentBase.new(basic_auth: %w[u p]) agent.add_swaig_query_params({ 'tenant' => 'acme' }) - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -90,7 +90,7 @@ def test_clear_swaig_query_params agent = SignalWire::AgentBase.new agent.add_swaig_query_params({ 'key' => 'val' }) agent.clear_swaig_query_params - agent.define_tool(name: 'test', description: 'Test') { |_, _| } + agent.define_tool(name: 'test', description: 'Test', parameters: {}, handler: nil) { |_, _| } swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] url = ai['SWAIG']['defaults']['web_hook_url'] @@ -103,7 +103,7 @@ class DynamicConfigIsolationTest < Minitest::Test def test_dynamic_config_callback_applied agent = SignalWire::AgentBase.new agent.set_prompt_text('Original') - agent.set_dynamic_config_callback do |_query, _body, _headers, ephemeral| + agent.set_dynamic_config_callback(nil) do |_query, _body, _headers, ephemeral| ephemeral.set_prompt_text('Modified') end swml = agent.render_swml @@ -115,7 +115,7 @@ def test_dynamic_config_callback_applied def test_original_not_mutated agent = SignalWire::AgentBase.new agent.set_prompt_text('Original') - agent.set_dynamic_config_callback do |_query, _body, _headers, ephemeral| + agent.set_dynamic_config_callback(nil) do |_query, _body, _headers, ephemeral| ephemeral.set_prompt_text('Modified') ephemeral.add_hint('NewHint') end @@ -126,8 +126,9 @@ def test_original_not_mutated def test_dynamic_config_can_add_tools agent = SignalWire::AgentBase.new - agent.set_dynamic_config_callback do |_q, _b, _h, ephemeral| - ephemeral.define_tool(name: 'dynamic_tool', description: 'Added dynamically') { |_, _| } + agent.set_dynamic_config_callback(nil) do |_q, _b, _h, ephemeral| + ephemeral.define_tool(name: 'dynamic_tool', description: 'Added dynamically', + parameters: {}, handler: nil) { |_, _| } end swml = agent.render_swml ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] @@ -142,7 +143,7 @@ class WebChainingTest < Minitest::Test def test_web_methods_return_self agent = SignalWire::AgentBase.new - assert_same(agent, agent.set_dynamic_config_callback { |*| }) + assert_same(agent, agent.set_dynamic_config_callback(nil) { |*| }) assert_same agent, agent.manual_set_proxy_url('x') assert_same agent, agent.set_web_hook_url('x') assert_same agent, agent.set_post_prompt_url('x') From ea630dab1d3639e9644dfc23efc529a57e1aebc1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 03:15:31 -0400 Subject: [PATCH 11/90] fold(skills): rename SkillRegistry.get_factory -> get_skill_class in the signature adapter MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Retires the last rename-carried omission in PORT_SIGNATURE_OMISSIONS.md. Per the standing rule, a rename is reconciled in the ADAPTER rename table, never an omission — an omission is a permanent blind spot; a rename keeps comparing. The omission's rationale said the shape "does not match 1:1" so the Ruby name was carried signature-side. That was suppressing BOTH sides of the pair: `get_factory` sat in EXCUSED while the reference's `get_skill_class` sat in live DRIFT as missing-port. enumerate_surface.rb has renamed this surface-side all along (SURFACE_METHOD_ALIASES); only the signature adapter lacked the mirror entry. Same capability, verified on both sides: given a skill name, return the instantiable handle for that skill or nil. Python returns the CLASS (`type[SkillBase] | None`, instantiated `skill_class(agent, params)`, skill_manager.py:48); Ruby's registry stores factory lambdas rather than classes, so it returns the Proc (`factory.call(params)`, agent_base.rb:1303). Same single argument, same nil-on-miss, same role at the sole call site in each port. The rename also lets the reference-type projection attach the concrete type, so `skill_name` sharpens from `any` to `string` — the comparison the omission was preventing. Measured with diff_port_signatures.py --omissions on both sides, both runs against a freshly regenerated artifact (SETS, not counts): DRIFT 89 -> 88 removed: SkillRegistry.get_skill_class (missing-port) EXCUSED 1107 -> 1106 removed: SkillRegistry.get_factory (missing-reference) added: ZERO on both sides The symbol now compares EQUAL rather than moving to another drift kind. Param-property drift stays at ZERO. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- PORT_SIGNATURE_OMISSIONS.md | 1 - port_signatures.json | 24 ++++++++++++------------ scripts/enumerate_signatures.py | 10 ++++++++++ 3 files changed, 22 insertions(+), 13 deletions(-) diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 33860995..80e08ea6 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -226,7 +226,6 @@ signalwire.relay.dial_state.valid: port-only: Layer A suffix-stripped spelling o signalwire.relay.event.RelayEvent.eql: port-only: Ruby value-equality (`eql?`) so same-data events are interchangeable Hash keys; inherited by every typed event subclass signalwire.relay.message_state.terminal: port-only: Layer A suffix-stripped spelling of `MessageState.terminal?` signalwire.relay.message_state.valid: port-only: Layer A suffix-stripped spelling of `MessageState.valid?` -signalwire.skills.registry.SkillRegistry.get_factory: rename-carried: the Ruby name for the reference `get_skill_class`. enumerate_surface.rb renames it surface-side (SURFACE-DIFF passes); the signature oracle records `get_skill_class` with a shape the Ruby method does not match 1:1, so the Ruby name is carried here signature-side rather than renamed. The reference HAS the counterpart — not invented surface. signalwire.skills.registry.SkillRegistry.register_builtins: port-only: same as SkillRegistry.register_builtins! - signature audit strips Ruby ?/! suffixes signalwire.skills.registry.SkillRegistry.registered: port-only: same as SkillRegistry.registered? - signature audit strips Ruby ?/! suffixes signalwire.skills.registry.SkillRegistry.reset: port-only: same as SkillRegistry.reset! - signature audit strips Ruby ?/! suffixes diff --git a/port_signatures.json b/port_signatures.json index 3192cd3f..6ac1a72e 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -2467,7 +2467,7 @@ }, { "name": "credentials", - "type": "class:HTTPBasicCredentials", + "type": "class:signalwire.core.auth_handler.BasicCredentials", "required": true } ], @@ -2481,7 +2481,7 @@ }, { "name": "credentials", - "type": "class:HTTPAuthorizationCredentials", + "type": "class:signalwire.core.auth_handler.BearerCredentials", "required": true } ], @@ -39116,16 +39116,6 @@ ], "returns": "any" }, - "get_factory": { - "params": [ - { - "name": "skill_name", - "type": "any", - "required": true - } - ], - "returns": "any" - }, "last_registered": { "params": [ { @@ -39216,6 +39206,16 @@ "reset": { "params": [], "returns": "any" + }, + "get_skill_class": { + "params": [ + { + "name": "skill_name", + "type": "string", + "required": true + } + ], + "returns": "any" } } } diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index b42bb95c..25f9c7e0 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -325,6 +325,16 @@ def _build_ref_method_index() -> dict: ("signalwire.core.skill_manager", "SkillManager"): { "load": "load_skill", "unload": "unload_skill", "get": "get_skill", "loaded": "has_skill", "loaded_keys": "list_loaded_skills"}, + # Same lookup capability, Ruby spelling: given a skill name, return the + # instantiable handle for that skill or nil. Python hands back the CLASS + # (`type[SkillBase] | None`, instantiated `skill_class(agent, params)`); + # Ruby's registry stores factory lambdas rather than classes, so it hands + # back the Proc (`factory.call(params)`). Same argument, same nil-on-miss, + # same role at the single call site (skill_manager.py:48 / + # agent_base.rb:1303). MIRRORS enumerate_surface.rb's + # SURFACE_METHOD_ALIASES, which already renames this surface-side. + ("signalwire.skills.registry", "SkillRegistry"): { + "get_factory": "get_skill_class"}, } From 3245faec9432e7d397c8d63000254a6ff7e9d0c8 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 03:49:53 -0400 Subject: [PATCH 12/90] fix(parity): pin the 7 wire-key remaps; route the nested credential Structs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PART 1 — the seven API-name -> wire-key remaps in relay/call.py. An independent AST audit of the tracked reference (resolving each dict key against its enclosing function's parameters, not grepping) confirms exactly seven remap sites in signalwire/relay/call.py and no eighth: play() media -> "play" play_and_collect() media -> "play" pay() input_method -> "input" join_conference() stream_obj -> "stream" bind_digit() bind_params -> "params" ai() ai_params -> "params" amazon_bedrock() ai_params -> "params" Ruby classification: play / play_and_collect name `media` positionally and re-key it to "play" at the emitter (class i). The other five ride the verbatim `**kwargs` bag, whose keys are stringified unchanged; the wire key collides with no Ruby parameter name at any of the five, so each is reachable by writing the wire key directly (class ii). No site is class (iii) — Ruby has no unreachable knob here, because its bag-local variable is `params` while the bag KEY namespace is separate. Only 2 of the 7 keys were previously asserted on the wire (play, play_and_collect). pay and ai had tests that never passed the remapped key at all (`charge_amount` / `prompt` only), and join_conference / bind_digit / amazon_bedrock had no RELAY wire test whatsoever. Adds RelayRemapWireKeyTest pinning all seven. Mutation-verified, and the FIRST ROUND OF THAT PROOF WAS ITSELF VACUOUS: renaming the `play` key made the mock's schema validator reject the frame UPSTREAM of the assertion (`-32602: 'play' is a required property`), so the test went red as an ERROR with 0 assertions executed — red, but proving only that the mock validates. Re-done with schema-VALID WRONG VALUES and across the whole test file rather than a --name filter: all 7 now fail as clean FAILURES (0 errors) with the diff landing on the remap assertion itself, plus honest sibling collateral where a pre-existing test also covered the key. PART 2 — the 4 credential drifts are a module-ROUTING gap, not a Struct one. porting-sdk dcff742 made BasicCredentials/BearerCredentials real oracle classes, surfacing 4 DRIFT + 6 SURFACE findings. The diagnosis carried in from the prior lane — that enumerate_signatures.py cannot enumerate positional `Struct.new` members — is wrong. signature_dump.rb enumerates both Structs fine, including their field readers. The classes were lost afterwards, two different ways: * SIGNATURES: both are nested inside AuthHandler, so the default namespace derivation routed them to the FABRICATED modules signalwire.core.auth_handler.basic_credentials / .bearer_credentials, which exist nowhere in the reference — so every member silently failed to compare and landed in EXCUSED instead. * SURFACE: both sat in RUBY_EXCLUDED_CLASSES, correct while the reference had no counterpart, obsolete the moment dcff742 published one. Fixed by routing both to signalwire.core.auth_handler in BOTH enumerators, and folding the Struct machinery at the emitter the same way the keyword_init AI-Chat Structs already are — a new POSITIONAL_STRUCT_FIELDS pass (the positional counterpart of AI_CHAT_STRUCT_FIELDS, differing in param KIND and in recording the fields required rather than defaulted) and the existing oracle-gated field-accessor path on the surface side. Both verify the declared fields against the reflected readers, so a real field drop still fails loud rather than shrinking the surface silently — verified by deleting `scheme` and watching the enumerator abort. `BearerCredentials.scheme` was a GENUINE CAPABILITY GAP, not an enumerator artifact: Ruby's Struct had only `:credentials`. FastAPI's HTTPAuthorizationCredentials — which the reference's carrier mirrors — splits the Authorization header on the first space into scheme + credentials. Implemented rather than excused, which exposed a real defect in the Rack bearer path: it built the carrier from `header[7..]` alone, so nothing carried the scheme. Effect, measured as SETS with --omissions passed on BOTH sides: DRIFT 4 -> 0 (all four retired; zero new) EXCUSED 1167 -> 1154 (-13, every one a credential entry; zero new) SURFACE 6 missing -> 0 (gate exit 0) Also deletes the 8 now-dead PORT_SIGNATURE_OMISSIONS entries, which named the fabricated modules and covered machinery that is now folded at the emitter. The committed port_signatures.json was NOT stale before this change: a fresh regen was byte-identical to `git show HEAD:port_signatures.json`. The staleness the prior lane found at c36ddd0 was already repaired by ea630da. Generated paths (scope, not fixed here): ruby's generated calling.rb performs the call_id -> "id" remap at the emitter at 35 sites, matching the reference's 35. Ruby needs no from_ -> "from" remap at all — `from` is not a Ruby reserved word, so the parameter is simply named `from`. Verification: bash scripts/run-tests.sh tests/relay/actions_mock_test.rb -> 43 runs, 0 failures bash scripts/run-tests.sh tests/core_auth_handler_test.rb -> 17 runs, 0 failures diff_port_signatures.py (all 3 allowlist flags) -> exit 0 diff_port_surface.py (both allowlist flags) -> exit 0 bash scripts/run-format.sh -> 1375 files, no offenses Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- PORT_SIGNATURE_OMISSIONS.md | 8 -- lib/signalwire/core/auth_handler.rb | 12 ++- port_signatures.json | 119 ++++++++++++++++++---------- port_surface.json | 10 ++- scripts/enumerate_signatures.py | 67 ++++++++++++++++ scripts/enumerate_surface.rb | 30 ++++++- tests/core_auth_handler_test.rb | 50 +++++++++++- tests/relay/actions_mock_test.rb | 96 ++++++++++++++++++++++ 8 files changed, 333 insertions(+), 59 deletions(-) diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 80e08ea6..79522071 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -191,14 +191,6 @@ signalwire.skills.play_background_file.skill.PlayBackgroundFileSkill.__init__: r signalwire.skills.weather_api.skill.WeatherApiSkill.__init__: reference-oracle gap — the reference surface records this skill class but the signature oracle omits its `__init__` (SURFACE-DIFF PASS) # --- True Ruby-only additions (absent from reference surface too) --- -signalwire.core.auth_handler.basic_credentials.BasicCredentials.inspect: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.basic_credentials.BasicCredentials.keyword_init: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.basic_credentials.BasicCredentials.members: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.basic_credentials.BasicCredentials.new: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.bearer_credentials.BearerCredentials.inspect: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.bearer_credentials.BearerCredentials.keyword_init: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.bearer_credentials.BearerCredentials.members: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) -signalwire.core.auth_handler.bearer_credentials.BearerCredentials.new: port-only: Ruby Struct/Data auto-generated method on a credentials value object; no Python counterpart (reference surface omits it too) signalwire.core.swaig_function.SWAIGFunction.call: reference-oracle gap — port `call` is Ruby's callable primitive (surface reconciles it to `__call__`, which the reference surface records but the signature oracle omits) (SURFACE-DIFF PASS) signalwire.core.swml_builder.SWMLBuilder.method_missing: reference-oracle gap — port `method_missing` is Ruby's dynamic-dispatch primitive (surface reconciles it to `__getattr__`, which the reference surface records but the signature oracle omits) (SURFACE-DIFF PASS) signalwire.core.swml_service.SWMLService.function: port-only: Ruby SWMLService `function` DSL helper; absent from the reference surface + signature oracle diff --git a/lib/signalwire/core/auth_handler.rb b/lib/signalwire/core/auth_handler.rb index 4a68f06a..b5e6a979 100644 --- a/lib/signalwire/core/auth_handler.rb +++ b/lib/signalwire/core/auth_handler.rb @@ -30,8 +30,12 @@ module Core class AuthHandler # Lightweight credential carriers for HTTP Basic and Bearer # authorization. + # + # These carry the fields parsed out of the +Authorization+ header. The + # bearer header is split on the FIRST space: the first part is the + # +scheme+ ("Bearer"), the second the +credentials+ (the token itself). BasicCredentials = Struct.new(:username, :password) - BearerCredentials = Struct.new(:credentials) + BearerCredentials = Struct.new(:scheme, :credentials) attr_reader :security_config, :auth_methods @@ -148,7 +152,11 @@ def bearer_env_ok?(env) header = env['HTTP_AUTHORIZATION'].to_s return false unless header.start_with?('Bearer ') - verify_bearer_token(BearerCredentials.new(header[7..])) + # Split on the FIRST space only: scheme, then the token verbatim (a + # token may itself contain no space, but splitting on all of them + # would silently truncate a malformed one instead of failing compare). + scheme, credentials = header.split(' ', 2) + verify_bearer_token(BearerCredentials.new(scheme, credentials)) end def api_key_env_ok?(env) diff --git a/port_signatures.json b/port_signatures.json index 6ac1a72e..3a1592e2 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -2488,30 +2488,29 @@ "returns": "any" } } - } - } - }, - "signalwire.core.auth_handler.basic_credentials": { - "classes": { + }, "BasicCredentials": { "methods": { - "inspect": { - "params": [], - "returns": "any" - }, - "keyword_init": { - "params": [], - "returns": "any" - }, - "members": { - "params": [], - "returns": "any" - }, - "new": { - "params": [], - "returns": "any" + "__init__": { + "params": [ + { + "name": "self", + "kind": "self" + }, + { + "name": "username", + "type": "string", + "required": true + }, + { + "name": "password", + "type": "string", + "required": true + } + ], + "returns": "void" }, - "password": { + "username": { "params": [ { "name": "self", @@ -2520,7 +2519,7 @@ ], "returns": "any" }, - "username": { + "password": { "params": [ { "name": "self", @@ -2529,40 +2528,50 @@ ], "returns": "any" } - } - } - } - }, - "signalwire.core.auth_handler.bearer_credentials": { - "classes": { + }, + "dataclass": true + }, "BearerCredentials": { "methods": { - "credentials": { + "__init__": { "params": [ { "name": "self", "kind": "self" + }, + { + "name": "scheme", + "type": "string", + "required": true + }, + { + "name": "credentials", + "type": "string", + "required": true } ], - "returns": "any" - }, - "inspect": { - "params": [], - "returns": "any" - }, - "keyword_init": { - "params": [], - "returns": "any" + "returns": "void" }, - "members": { - "params": [], + "scheme": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], "returns": "any" }, - "new": { - "params": [], + "credentials": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], "returns": "any" } - } + }, + "dataclass": true } } }, @@ -41051,6 +41060,30 @@ } } }, + "signalwire.core.auth_handler.BasicCredentials": { + "params": { + "password": { + "type": "string", + "required": true + }, + "username": { + "type": "string", + "required": true + } + } + }, + "signalwire.core.auth_handler.BearerCredentials": { + "params": { + "credentials": { + "type": "string", + "required": true + }, + "scheme": { + "type": "string", + "required": true + } + } + }, "signalwire.core.config_loader.ConfigLoader": { "params": { "config_paths": { diff --git a/port_surface.json b/port_surface.json index d023b0a7..cedf634d 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 30050b53cb20672ba296852b008f91f58132e889", + "generated_from": "signalwire-ruby @ ea630dab1d3639e9644dfc23efc529a57e1aebc1", "modules": { "signalwire": { "classes": {}, @@ -209,6 +209,14 @@ "verify_api_key", "verify_basic_auth", "verify_bearer_token" + ], + "BasicCredentials": [ + "password", + "username" + ], + "BearerCredentials": [ + "credentials", + "scheme" ] }, "functions": [] diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 25f9c7e0..f135982f 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -475,6 +475,63 @@ def apply_sig_free_function_projections(out_modules: dict) -> None: } +# POSITIONAL ``Struct.new(:a, :b)`` value carriers — the counterpart of +# AI_CHAT_STRUCT_FIELDS above, which handles the ``keyword_init: true`` form. +# +# Both forms hit the SAME reflection blind spot: a Struct's constructor params +# are invisible to ``Method#parameters`` (``new`` reflects as ``*args``), the +# fields surface only as zero-arg READERS, and Ruby auto-generates machinery +# (``new`` / ``members`` / ``keyword_init?`` / ``inspect`` / ``[]``) plus a +# WRITER per field that the reference class does not have. The difference is +# only the ``__init__`` param KIND: a positional Struct's fields are positional +# (canonical: no explicit ``kind``), matching how the oracle records this +# dataclass — so these cannot ride AI_CHAT_STRUCT_FIELDS, which hard-codes +# ``kind: keyword``. +# +# Unlike the keyword_init case, a positional Struct field IS required at the +# oracle (the reference dataclass declares it with no default), and Ruby's +# positional Struct does accept the same positional call — so ``required: True`` +# with no default is the accurate record here, not ``default: None``. +# +# Keyed (module, class) -> ordered field names (Struct field order = the +# reference ``__init__`` positional order). The declared fields are VERIFIED +# against the reflected readers, so a real field drop/rename still surfaces as +# drift rather than being papered over by this table. +POSITIONAL_STRUCT_FIELDS: dict[tuple, list[str]] = { + # The oracle's structural filler for FastAPI's HTTPBasicCredentials / + # HTTPAuthorizationCredentials (porting-sdk dcff742). FastAPI splits the + # Authorization header on the first space: scheme, then credentials. + ("signalwire.core.auth_handler", "BasicCredentials"): ["username", "password"], + ("signalwire.core.auth_handler", "BearerCredentials"): ["scheme", "credentials"], +} + + +def synth_positional_struct_inits(out_modules: dict) -> None: + """Rebuild each POSITIONAL Struct value carrier to the single ``__init__`` + the reference records — params = the reflected field readers, positional and + required — keep the readers, and drop the Struct machinery and the Ruby + auto-generated ``field=`` writers. In place.""" + for (mod, cls), fields in POSITIONAL_STRUCT_FIELDS.items(): + entry = out_modules.get(mod, {}).get("classes", {}).get(cls) + if not entry: + continue + methods = entry.get("methods", {}) + # Verify each declared field is present as a reflected zero-arg reader — + # a real Struct field drop/rename then re-surfaces as drift here. + readers = [ + f for f in fields + if f in methods and not _has_value_params(methods[f]) + ] + params = [{"name": "self", "kind": "self"}] + [ + {"name": f, "type": "any", "required": True} for f in readers + ] + new_methods = {"__init__": {"params": params, "returns": "void"}} + for f in readers: + new_methods[f] = methods[f] + entry["methods"] = new_methods + entry["dataclass"] = True + + def synth_ai_chat_struct_inits(out_modules: dict) -> None: """Rebuild the AI-Chat Struct value models to a single keyword ``__init__`` (params = the reflected Struct field readers) and drop the Struct machinery; @@ -677,6 +734,15 @@ def apply(key: tuple, sig: dict) -> None: # gates route these classes to the same reference module. "SignalWire::Swaig::SWAIGFunction": "signalwire.core.swaig_function", "SignalWire::Core::AuthHandler": "signalwire.core.auth_handler", + # The two credential carriers are nested INSIDE AuthHandler in Ruby, so the + # default namespace derivation would route them to the fabricated modules + # signalwire.core.auth_handler.basic_credentials / .bearer_credentials — + # which exist nowhere in the oracle, so every member silently failed to + # compare. The oracle publishes both as module-level classes of + # signalwire.core.auth_handler (porting-sdk dcff742, the structural filler + # for FastAPI's HTTPBasicCredentials / HTTPAuthorizationCredentials). + "SignalWire::Core::AuthHandler::BasicCredentials": "signalwire.core.auth_handler", + "SignalWire::Core::AuthHandler::BearerCredentials": "signalwire.core.auth_handler", "SignalWire::Core::ConfigLoader": "signalwire.core.config_loader", "SignalWire::Core::SecurityConfig": "signalwire.core.security_config", "SignalWire::Core::PomBuilder": "signalwire.core.pom_builder", @@ -1315,6 +1381,7 @@ def collect(raw: dict) -> dict: apply_sig_method_donors(out_modules) apply_sig_free_function_projections(out_modules) synth_ai_chat_struct_inits(out_modules) + synth_positional_struct_inits(out_modules) apply_hand_param_renames(out_modules) project_reference_param_types(out_modules) normalize_request_options_param_kind(out_modules) diff --git a/scripts/enumerate_surface.rb b/scripts/enumerate_surface.rb index f0b72fa9..9e408172 100755 --- a/scripts/enumerate_surface.rb +++ b/scripts/enumerate_surface.rb @@ -181,6 +181,7 @@ def abort_missing_python_surface(path) signalwire.core.post_prompt_generated signalwire.core.swaig_request_generated signalwire.ai_chat.client + signalwire.core.auth_handler ].freeze # Load the oracle's per-class recorded surface members for the generated-payload @@ -260,6 +261,16 @@ def load_oracle_all_members(python_surface_path) # Item-I implemented subsystems: route the new Ruby classes to their # reference core modules (class name matches the reference leaf verbatim). 'SignalWire::Core::AuthHandler' => 'signalwire.core.auth_handler', + # The two credential carriers are nested INSIDE AuthHandler in Ruby, so the + # default namespace derivation would route them to the fabricated modules + # signalwire.core.auth_handler.basic_credentials / .bearer_credentials, which + # exist nowhere in the oracle. The oracle publishes both as module-level + # classes of signalwire.core.auth_handler (porting-sdk dcff742, the structural + # filler for FastAPI's HTTPBasicCredentials / HTTPAuthorizationCredentials). + # Kept in lockstep with RUBY_TO_PYTHON_MODULE_OVERRIDES in + # scripts/enumerate_signatures.py. + 'SignalWire::Core::AuthHandler::BasicCredentials' => 'signalwire.core.auth_handler', + 'SignalWire::Core::AuthHandler::BearerCredentials' => 'signalwire.core.auth_handler', 'SignalWire::Core::ConfigLoader' => 'signalwire.core.config_loader', 'SignalWire::Core::SecurityConfig' => 'signalwire.core.security_config', 'SignalWire::Core::PomBuilder' => 'signalwire.core.pom_builder', @@ -442,8 +453,6 @@ def load_oracle_all_members(python_surface_path) SignalWire::Relay::MessageSerialization SignalWire::REST::Namespaces::Generated SignalWire::REST::Namespaces::Generated::ResourceTree - SignalWire::Core::AuthHandler::BasicCredentials - SignalWire::Core::AuthHandler::BearerCredentials SignalWire::REST::EffectiveOptions SignalWire::REST::AbortSignal SignalWire::REST::Attempt @@ -923,6 +932,22 @@ def surface_module?(name, seen_classes) SignalWire::AIChat::ChatLog ].freeze +# The auth credential carriers are the same Struct idiom in the POSITIONAL form +# (`Struct.new(:a, :b)` rather than `keyword_init: true`), so they take the same +# oracle-gated-field-accessor path: emit exactly the readers the oracle records +# (BasicCredentials {username, password} / BearerCredentials {scheme, +# credentials} — porting-sdk dcff742's structural filler for FastAPI's +# HTTPBasicCredentials / HTTPAuthorizationCredentials) and drop the rest of the +# Struct machinery (`new` / `members` / `keyword_init?` / `inspect` / `[]`) and +# the auto-generated `field=` writers. Emission covers the Struct idiom; no +# PORT_ADDITIONS entry per accessor. The oracle gate in +# oracle_gated_field_accessors aborts if a recorded field reader is missing, so a +# real field drop still fails loud rather than silently shrinking the surface. +AUTH_CREDENTIAL_STRUCT_CLASSES = %w[ + SignalWire::Core::AuthHandler::BasicCredentials + SignalWire::Core::AuthHandler::BearerCredentials +].freeze + # Per-[module, class] surface members to DROP: a Ruby-idiom accessor/method that # the reference records as a plain instance ATTRIBUTE (not a surface method), so # there is no reference member to compare against — the idiomatic-Ruby getter is @@ -1003,6 +1028,7 @@ def surface_module?(name, seen_classes) def generated_methodless_class?(ruby_fqn) return true if ruby_fqn.start_with?(GENERATED_TYPES_PREFIX) return true if AI_CHAT_METHODLESS_CLASSES.include?(ruby_fqn) + return true if AUTH_CREDENTIAL_STRUCT_CLASSES.include?(ruby_fqn) GENERATED_PAYLOAD_PREFIXES.each_key { |prefix| return true if ruby_fqn.start_with?(prefix) } false diff --git a/tests/core_auth_handler_test.rb b/tests/core_auth_handler_test.rb index 334015a9..e653293b 100644 --- a/tests/core_auth_handler_test.rb +++ b/tests/core_auth_handler_test.rb @@ -53,14 +53,14 @@ def test_verify_basic_auth_rejects_wrong_password def test_verify_bearer_token h = handler(bearer_token: 'tok123') - assert h.verify_bearer_token(Bearer.new('tok123')) - refute h.verify_bearer_token(Bearer.new('wrong')) + assert h.verify_bearer_token(Bearer.new('Bearer', 'tok123')) + refute h.verify_bearer_token(Bearer.new('Bearer', 'wrong')) end def test_verify_bearer_disabled_without_token h = handler - refute h.verify_bearer_token(Bearer.new('anything')) + refute h.verify_bearer_token(Bearer.new('Bearer', 'anything')) end def test_verify_api_key @@ -164,3 +164,47 @@ def test_rack_dependency_optional_does_not_raise assert_nil result['method'] end end + +# The credential CARRIERS themselves: both must expose exactly the fields the +# reference's carrier does (oracle: signalwire.core.auth_handler.BasicCredentials +# {username, password} / BearerCredentials {scheme, credentials} -- porting-sdk +# dcff742's structural filler for FastAPI's HTTPBasicCredentials / +# HTTPAuthorizationCredentials). `scheme` was absent from the Ruby Struct +# entirely until 2026-07-28, so nothing pinned the header split. +class CoreAuthCredentialsTest < Minitest::Test + Basic = SignalWire::Core::AuthHandler::BasicCredentials + Bearer = SignalWire::Core::AuthHandler::BearerCredentials + + def handler(**) + SignalWire::Core::AuthHandler.new(CoreAuthHandlerTest::FakeConfig.new(**)) + end + + def test_bearer_credentials_carries_scheme_and_credentials + c = Bearer.new('Bearer', 'tok123') + + assert_equal 'Bearer', c.scheme + assert_equal 'tok123', c.credentials + assert_equal %i[scheme credentials], Bearer.members + end + + def test_basic_credentials_carries_username_and_password + c = Basic.new('alice', 'secret') + + assert_equal 'alice', c.username + assert_equal 'secret', c.password + assert_equal %i[username password], Basic.members + end + + # The Rack bearer path must populate scheme from the header, not fold the + # whole header into credentials (which would make the token compare fail). + def test_rack_bearer_path_splits_scheme_from_token + h = handler(bearer_token: 'tok-with-scheme') + dep = h.rack_dependency(optional: true) + result = dep.call({ 'HTTP_AUTHORIZATION' => 'Bearer tok-with-scheme', + 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/', + 'REMOTE_ADDR' => '1.2.3.4' }) + + assert result['authenticated'], 'bearer header must authenticate after the scheme/token split' + assert_equal 'bearer', result['method'] + end +end diff --git a/tests/relay/actions_mock_test.rb b/tests/relay/actions_mock_test.rb index 04edb910..26b57820 100644 --- a/tests/relay/actions_mock_test.rb +++ b/tests/relay/actions_mock_test.rb @@ -547,3 +547,99 @@ def test_concurrent_play_and_record_route_independently refute_predicate record_action, :done? end end + +# ---- API-name -> wire-key REMAP pins --------------------------------- +# +# The reference exposes seven keyword parameters in signalwire/relay/call.py +# under one API name but puts them on the wire under a DIFFERENT key: +# +# play() media -> "play" +# play_and_collect() media -> "play" +# pay() input_method -> "input" +# join_conference() stream_obj -> "stream" +# bind_digit() bind_params -> "params" +# ai() ai_params -> "params" +# amazon_bedrock() ai_params -> "params" +# +# Every construction-level test passes even when a port sends the WRONG key, +# so each remap needs a wire-level assertion on the emitted frame. Ruby names +# `media` positionally on #play / #play_and_collect and re-keys it to "play" +# at the emitter; the other five ride the verbatim `**kwargs` bag, whose keys +# are stringified unchanged — the wire key is a legal bag key at every site +# (no collision with a Ruby parameter name), so each is reachable by writing +# the wire key directly. These tests pin that reachability on the wire. +class RelayRemapWireKeyTest < RelayActionsTestBase + def test_play_media_lands_under_play_key + call = answered_inbound_call('call-remap-play') + call.play([{ 'type' => 'tts', 'params' => { 'text' => 'hi' } }], control_id: 'remap-play') + p = recv('calling.play').last.frame['params'] + + assert_equal 'tts', p.dig('play', 0, 'type') + assert_nil p['media'], 'media must not appear on the wire; the key is "play"' + end + + def test_play_and_collect_media_lands_under_play_key + call = answered_inbound_call('call-remap-pac') + call.play_and_collect([{ 'type' => 'tts', 'params' => { 'text' => 'Press 1' } }], + { 'digits' => { 'max' => 1 } }, control_id: 'remap-pac') + p = recv('calling.play_and_collect').last.frame['params'] + + assert_equal 'tts', p.dig('play', 0, 'type') + assert_nil p['media'], 'media must not appear on the wire; the key is "play"' + end + + def test_pay_input_method_lands_under_input_key + call = answered_inbound_call('call-remap-pay') + call.pay(payment_connector_url: 'https://pay.example/connect', + control_id: 'remap-pay', input: 'dtmf') + p = recv('calling.pay').last.frame['params'] + + assert_equal 'dtmf', p['input'], 'pay input_method must ride the wire key "input"' + assert_nil p['input_method'], 'input_method is the API name, not the wire key' + end + + def test_join_conference_stream_obj_lands_under_stream_key + call = answered_inbound_call('call-remap-conf') + stream = { 'url' => 'wss://stream.example/live' } + call.join_conference(name: 'remap-conf', stream: stream) + p = recv('calling.join_conference').last.frame['params'] + + assert_equal 'remap-conf', p['name'] + assert_equal stream, p['stream'], 'join_conference stream_obj must ride the wire key "stream"' + assert_nil p['stream_obj'], 'stream_obj is the API name, not the wire key' + end + + def test_bind_digit_bind_params_lands_under_params_key + call = answered_inbound_call('call-remap-bind') + bind_params = { 'realm' => 'demo', 'foo' => 'bar' } + call.bind_digit(digits: '123', bind_method: 'calling.play', params: bind_params) + p = recv('calling.bind_digit').last.frame['params'] + + assert_equal '123', p['digits'] + assert_equal 'calling.play', p['bind_method'] + assert_equal bind_params, p['params'], 'bind_digit bind_params must ride the wire key "params"' + assert_nil p['bind_params'], 'bind_params is the API name, not the wire key' + end + + def test_ai_ai_params_lands_under_params_key + call = answered_inbound_call('call-remap-ai') + ai_params = { 'temperature' => 0.7 } + call.ai(prompt: { 'text' => 'You are helpful.' }, control_id: 'remap-ai', params: ai_params) + p = recv('calling.ai').last.frame['params'] + + assert_equal({ 'text' => 'You are helpful.' }, p['prompt']) + assert_equal ai_params, p['params'], 'ai ai_params must ride the wire key "params"' + assert_nil p['ai_params'], 'ai_params is the API name, not the wire key' + end + + def test_amazon_bedrock_ai_params_lands_under_params_key + call = answered_inbound_call('call-remap-bedrock') + ai_params = { 'model' => 'anthropic.claude' } + call.amazon_bedrock(prompt: { 'text' => 'You are helpful.' }, params: ai_params) + p = recv('calling.amazon_bedrock').last.frame['params'] + + assert_equal({ 'text' => 'You are helpful.' }, p['prompt']) + assert_equal ai_params, p['params'], 'amazon_bedrock ai_params must ride the wire key "params"' + assert_nil p['ai_params'], 'ai_params is the API name, not the wire key' + end +end From 3e724869e097db90b63eb8c75d3650786cfba2b6 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 05:23:14 -0400 Subject: [PATCH 13/90] fix(surface): a Struct's inherited constructor satisfies the oracle's __init__ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit porting-sdk 8828dd2 taught the oracle to record a SYNTHESIZED `__init__`, not only a `def`-declared one, so python_surface.json now records the constructor of the five value carriers this port models as Ruby Structs (ChatLog / ChatResponse / ConversationInfo / BasicCredentials / BearerCredentials). The surface enumerator could not express that. Those five take the `generated_methodless_class?` path, which bypasses `enumerate_methods` — and with it the `initialize` -> `__init__` rename — and matches the oracle's member set against `public_instance_methods(false)`. A Struct's constructor is defined on `Struct` itself, so it is neither in that list nor the class's own `initialize`, and `oracle_gated_field_accessors` aborted the whole enumeration: generated model signalwire.core.auth_handler.BearerCredentials is missing oracle-recorded field reader(s) ["__init__"] The constructor is REAL and reachable — `ChatLog.new(messages:, call_timeline:)` constructs, `instance_method(:initialize).owner` is `Struct`, arity -1. So this is a capability the port genuinely publishes and the enumerator was failing to see, not a gap to excuse. `__init__` is partitioned out of the field-reader check and resolved against the class's reachable constructor instead; a missing one still aborts, so a value carrier that really lost its constructor fails just as loud. The signature enumerator already did exactly this for the same five classes (synth_positional_struct_inits / synth_ai_chat_struct_inits) — the surface side simply lagged it. port_surface.json regenerated: 5 symbols added, 0 removed, every one an `__init__`; committed-blob `__init__` count 150 -> 155. SURFACE-DIFF goes from 5 unexcused missing symbols to a clean match (2648 symbols, 21 excused omissions, 450 excused additions) with no ledger entry added. --- port_surface.json | 7 ++++++- scripts/enumerate_surface.rb | 36 ++++++++++++++++++++++++++++++++++-- 2 files changed, 40 insertions(+), 3 deletions(-) diff --git a/port_surface.json b/port_surface.json index cedf634d..62d07035 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ ea630dab1d3639e9644dfc23efc529a57e1aebc1", + "generated_from": "signalwire-ruby @ 3245faec9432e7d397c8d63000254a6ff7e9d0c8", "modules": { "signalwire": { "classes": {}, @@ -70,15 +70,18 @@ "AuthenticationError": [], "ChatInProgressError": [], "ChatLog": [ + "__init__", "call_timeline", "messages" ], "ChatResponse": [ + "__init__", "conversation_id", "text", "user_event" ], "ConversationInfo": [ + "__init__", "id", "initial_message", "status" @@ -211,10 +214,12 @@ "verify_bearer_token" ], "BasicCredentials": [ + "__init__", "password", "username" ], "BearerCredentials": [ + "__init__", "credentials", "scheme" ] diff --git a/scripts/enumerate_surface.rb b/scripts/enumerate_surface.rb index 9e408172..7b27593c 100755 --- a/scripts/enumerate_surface.rb +++ b/scripts/enumerate_surface.rb @@ -1039,17 +1039,49 @@ def generated_methodless_class?(ruby_fqn) # Gated on the ORACLE'S member set (never the full reader list) so scalar wire # fields the reference does not record are not over-emitted. Empty (method-less) # when the class is not one the oracle records field accessors for. +# +# `__init__` is NOT a field reader and is resolved separately (see +# `constructor_member?`): the reference records the CONSTRUCTOR of these value +# carriers, and Ruby's is real but inherited (Struct defines `initialize` on +# `Struct` itself, so `public_instance_methods(false)` never lists it). Matching +# it against the reader set would abort on a capability the port genuinely has — +# `ChatLog.new(messages:, call_timeline:)` works. This mirrors what +# enumerate_signatures.py already does for the same five classes +# (synth_positional_struct_inits / synth_ai_chat_struct_inits). def oracle_gated_field_accessors(klass, target_mod, cls, oracle_generated_members) wanted = oracle_generated_members[[target_mod, cls]] return [] unless wanted readers = klass.public_instance_methods(false).to_set(&:to_s) - missing = wanted.to_a - readers.to_a + ctor, fields = wanted.to_a.partition { |m| m == '__init__' } + assert_oracle_members_present(klass, target_mod, cls, readers, ctor, fields) + (ctor + fields.select { |m| readers.include?(m) }).sort +end + +# Fail loud when the port has dropped something the oracle records: a field +# reader that vanished (a real field drop/rename) or the constructor itself. +def assert_oracle_members_present(klass, target_mod, cls, readers, ctor, fields) + missing = fields - readers.to_a unless missing.empty? abort "generated model #{target_mod}.#{cls} is missing oracle-recorded field " \ "reader(s) #{missing.sort.inspect}; regenerate the model or update the oracle" end - wanted.to_a.select { |m| readers.include?(m) }.sort + return if ctor.empty? || constructor_member?(klass) + + abort "generated model #{target_mod}.#{cls} is missing the oracle-recorded " \ + 'constructor (no reachable `initialize`); regenerate the model or update the oracle' +end + +# True when `klass` has a reachable constructor — its own `initialize` or one +# inherited from a superclass (`Struct`, for the value carriers here). Every +# Ruby class technically inherits `BasicObject#initialize`, so require the owner +# to be something more specific than `BasicObject` for the answer to mean +# "this class defines a real construction contract". +def constructor_member?(klass) + owner = klass.instance_method(:initialize).owner + owner != BasicObject +rescue NameError + false end # Record one Ruby class or module into `modules`. From 7de2304ec7471bca2c9b50998c924d05505191bf Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 06:10:58 -0400 Subject: [PATCH 14/90] chore: declare version 3.0.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Owner ruling 2026-07-28: the whole port fleet lands on a single unreleased 3.0.0. This port was at 3.2.0; nothing in the 3.x range was ever published (ruby's published tags top out at v2.0.0), so the downgrade regresses no artifact. The credential-carrier work removed a public 2-arg verify_basic_auth(username, password) across the OO ports — genuinely breaking — and the fleet absorbs that into one coordinated 3.0.0 rather than staggering majors. Exactly one declaration site: SignalWire::VERSION in lib/signalwire/version.rb. signalwire-sdk.gemspec require_relative's that file and assigns `s.version = SignalWire::VERSION`, so the constant is the thing to change — editing a gemspec literal would be wrong because there isn't one. Both User-Agent strings (REST http_client, ai_chat client) interpolate the same constant, as does agent_server's health payload, so no UA literal needs editing and tests/rest/user_agent_mock_test.rb keeps asserting against the constant. Gemfile.lock self-references the version but is gitignored (a local bundler artifact, regenerated on `bundle install`), so it is not a declaration site and is not committed. The CHANGELOG's "## 3.2.0" heading is a historical release entry, not a declaration site. This sets version INTENT only. No tag, no release. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/version.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/signalwire/version.rb b/lib/signalwire/version.rb index deea8e17..1206771d 100644 --- a/lib/signalwire/version.rb +++ b/lib/signalwire/version.rb @@ -1,5 +1,5 @@ # frozen_string_literal: true module SignalWire - VERSION = '3.2.0' + VERSION = '3.0.0' end From 2b6290b952870d3633f5818db2b0e04c238a73be Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 11:22:23 -0400 Subject: [PATCH 15/90] chore(release): set the SemVer floor to 3.0.0 and re-anchor its surface payload MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per the owner ruling (2026-07-28) every port's release floor becomes 3.0.0. `port_signatures.baseline.json` gets `baseline_version = 3.0.0` AND its recorded surface payload replaced with the current enumeration. Both halves are required. SEMVER-DIFF does not merely compare version numbers — it diffs the surface against the floor's recorded `modules` payload, so bumping `baseline_version` alone leaves `required = 'major'` against a floor whose payload still describes an older surface. Before this change the floor reported: 3.0.2 (3.0.2) -> 3.0.0 actual bump = 'downgrade', required = 'major' [MISMATCH] BREAKING — 21 member(s) removed since last release After the payload swap all 21 breaking removals are gone: 3.0.0 (3.0.0) -> 3.0.0 (lib/signalwire/version.rb) actual bump = 'none' no public surface change since last release. This is a PAYLOAD SWAP, not a file copy: the floor carries release-anchor metadata the current artifact does not. `modules` + `construction` come from a FRESH `python3 scripts/enumerate_signatures.py` (103 -> 105 modules); `baseline_version` is set to 3.0.0; and `generated_from_commit` is re-pointed from the stale anchor to this branch's HEAD 7de2304. No v3.0.0 tag exists yet, so a bare 40-hex commit sha is the correct anchor. Semantics: the floor stops being "the surface as last published" and becomes "the surface as of the 3.0.0 wave". That is coherent because nothing 3.x/4.x ever shipped. SEMVER-DIFF will no longer flag anything already in today's surface; future breaking changes are still caught, measured against the new floor. FOUND WHILE REGENERATING — the committed `port_signatures.json` is STALE and is NOT fixed here (left uncommitted for the lane that owns that artifact). A fresh enumerate differs from the committed blob in 15 params, all of them type REFINEMENTS the committed blob never picked up: handler: class:...relay.call.EventHandler -> callable,void> handler: class:...relay.client.CallHandler -> callable,void> handler: class:...relay.client.MessageHandler -> callable,void> agent: any -> class:signalwire.core.agent_base.AgentBase (x3) (+ `any` -> optional>, x3) This is the "stale blob passes run-ci while masking real drift" failure mode. It is NOT caused by the concurrent lane's uncommitted session_manager.rb — proven by regenerating with that file stashed and getting a byte-identical result, and by the drift touching zero session_manager symbols. THIS floor records the FRESH surface, not the stale blob (verified by content: floor.modules == fresh regen, != HEAD's committed blob). KNOWN, PRE-EXISTING, NOT INTRODUCED HERE: run standalone (without --report-only) semver_diff still exits 1 with `required = 'patch'` despite reporting "no public surface change". That is a defect in the checker, not in this floor: semver_diff.py:495 fires on `if allow:` — the mere EXISTENCE of a non-empty SEMVER_DIFF_ALLOW.md — and overwrites an already-correct `required = 'none'` with 'patch', even when none of the allowlisted symbols appear in the diff. This port's single allowlist entry (HttpClient.__init__) is pre-existing and unrelated to the current diff. run-ci is unaffected: it invokes SEMVER-DIFF with --report-only (the D5 "re-anchor at cut" wave setting), which exits 0. Reported for the owner rather than papered over; no allowlist entry was added. run-ci: real exit 0, 22 gates PASS / 0 FAIL — UNCHANGED from the pre-change baseline. No gate moved. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- port_signatures.baseline.json | 38596 ++++++++++++++++++-------------- 1 file changed, 21850 insertions(+), 16746 deletions(-) diff --git a/port_signatures.baseline.json b/port_signatures.baseline.json index f8717bbf..9e4dfeb4 100644 --- a/port_signatures.baseline.json +++ b/port_signatures.baseline.json @@ -1,157 +1,4799 @@ { - "version": "2", - "generated_from": "signalwire-ruby via Method#parameters reflection", - "generated_from_commit": "f7f8601651e01388b1a55793cfe945226a963379", + "baseline_version": "3.0.0", + "construction": { + "signalwire.agent_server.AgentServer": { + "params": { + "host": { + "required": false, + "type": "string" + }, + "log_level": { + "required": false, + "type": "string" + }, + "port": { + "required": false, + "type": "int" + } + } + }, + "signalwire.agents.bedrock.BedrockAgent": { + "params": { + "max_tokens": { + "required": false, + "type": "int" + }, + "name": { + "required": false, + "type": "string" + }, + "route": { + "required": false, + "type": "string" + }, + "system_prompt": { + "required": false, + "type": "optional" + }, + "temperature": { + "required": false, + "type": "float" + }, + "top_p": { + "required": false, + "type": "float" + }, + "voice_id": { + "required": false, + "type": "string" + } + } + }, + "signalwire.ai_chat.client.AIChatClient": { + "params": { + "connect_timeout": { + "required": false, + "type": "any" + }, + "project": { + "required": false, + "type": "optional" + }, + "read_idle_timeout": { + "required": false, + "type": "any" + }, + "space": { + "required": false, + "type": "optional" + }, + "token": { + "required": false, + "type": "optional" + }, + "url": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.ai_chat.client.AIChatError": { + "params": { + "code": { + "required": true, + "type": "optional" + }, + "message": { + "required": true, + "type": "string" + } + } + }, + "signalwire.ai_chat.client.ChatLog": { + "params": { + "call_timeline": { + "required": false, + "type": "list>" + }, + "messages": { + "required": false, + "type": "list>" + } + } + }, + "signalwire.ai_chat.client.ChatResponse": { + "params": { + "conversation_id": { + "required": false, + "type": "string" + }, + "text": { + "required": false, + "type": "string" + }, + "user_event": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.ai_chat.client.ConversationInfo": { + "params": { + "id": { + "required": false, + "type": "string" + }, + "initial_message": { + "required": false, + "type": "optional" + }, + "status": { + "required": false, + "type": "string" + } + } + }, + "signalwire.core.agent.prompt.manager.PromptManager": { + "params": { + "agent": { + "required": false, + "type": "any" + } + } + }, + "signalwire.core.agent.tools.registry.ToolRegistry": { + "params": { + "agent": { + "required": false, + "type": "any" + } + } + }, + "signalwire.core.agent_base.AgentBase": { + "params": { + "agent_id": { + "required": false, + "type": "optional" + }, + "auto_answer": { + "required": false, + "type": "bool" + }, + "basic_auth": { + "required": false, + "type": "optional>" + }, + "check_for_input_override": { + "required": false, + "type": "bool" + }, + "config_file": { + "required": false, + "type": "optional" + }, + "default_webhook_url": { + "required": false, + "type": "optional" + }, + "enable_post_prompt_override": { + "required": false, + "type": "bool" + }, + "host": { + "required": false, + "type": "string" + }, + "name": { + "required": false, + "type": "string" + }, + "native_functions": { + "required": false, + "type": "optional>" + }, + "port": { + "required": false, + "type": "optional" + }, + "record_call": { + "required": false, + "type": "bool" + }, + "record_format": { + "required": false, + "type": "string" + }, + "record_stereo": { + "required": false, + "type": "bool" + }, + "route": { + "required": false, + "type": "string" + }, + "schema_path": { + "required": false, + "type": "optional" + }, + "schema_validation": { + "required": false, + "type": "bool" + }, + "signing_key": { + "required": false, + "type": "optional" + }, + "suppress_logs": { + "required": false, + "type": "bool" + }, + "token_expiry_secs": { + "required": false, + "type": "int" + }, + "trust_proxy_for_signature": { + "required": false, + "type": "bool" + }, + "use_pom": { + "required": false, + "type": "bool" + } + } + }, + "signalwire.core.auth_error.AuthError": { + "params": { + "response": { + "required": true, + "type": "any" + } + } + }, + "signalwire.core.auth_handler.AuthHandler": { + "params": { + "security_config": { + "required": true, + "type": "class:signalwire.core.security_config.SecurityConfig" + } + } + }, + "signalwire.core.auth_handler.BasicCredentials": { + "params": { + "password": { + "required": true, + "type": "string" + }, + "username": { + "required": true, + "type": "string" + } + } + }, + "signalwire.core.auth_handler.BearerCredentials": { + "params": { + "credentials": { + "required": true, + "type": "string" + }, + "scheme": { + "required": true, + "type": "string" + } + } + }, + "signalwire.core.config_loader.ConfigLoader": { + "params": { + "config_paths": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.core.contexts.Context": { + "params": { + "name": { + "required": true, + "type": "string" + } + } + }, + "signalwire.core.contexts.ContextBuilder": { + "params": { + "agent": { + "required": false, + "type": "any" + } + } + }, + "signalwire.core.contexts.GatherInfo": { + "params": { + "completion_action": { + "required": false, + "type": "optional" + }, + "isolated": { + "required": false, + "type": "bool" + }, + "output_key": { + "required": false, + "type": "optional" + }, + "prompt": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.core.contexts.GatherQuestion": { + "params": { + "confirm": { + "required": false, + "type": "bool" + }, + "functions": { + "required": false, + "type": "optional>" + }, + "isolated": { + "required": false, + "type": "optional" + }, + "key": { + "required": true, + "type": "string" + }, + "prompt": { + "required": false, + "type": "optional" + }, + "question": { + "required": true, + "type": "string" + }, + "type": { + "required": false, + "type": "string" + } + } + }, + "signalwire.core.contexts.Step": { + "params": { + "name": { + "required": true, + "type": "string" + } + } + }, + "signalwire.core.data_map.DataMap": { + "params": { + "function_name": { + "required": true, + "type": "string" + } + } + }, + "signalwire.core.function_result.FunctionResult": { + "params": { + "post_process": { + "required": false, + "type": "bool" + }, + "response": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.core.security.session_manager.SessionManager": { + "params": { + "secret_key": { + "required": false, + "type": "optional" + }, + "token_expiry_secs": { + "required": false, + "type": "int" + } + } + }, + "signalwire.core.security.webhook_middleware.WebhookMiddleware": { + "params": { + "app": { + "required": true, + "type": "any" + }, + "methods": { + "required": false, + "type": "any" + }, + "paths": { + "required": false, + "type": "any" + }, + "signing_key": { + "required": true, + "type": "any" + }, + "trust_proxy": { + "required": false, + "type": "any" + } + } + }, + "signalwire.core.security_config.SecurityConfig": { + "params": { + "config_file": { + "required": false, + "type": "optional" + }, + "service_name": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.core.skill_base.SkillBase": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + "params": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.core.skill_manager.SkillManager": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + } + } + }, + "signalwire.core.swaig_function.SWAIGFunction": { + "params": { + "description": { + "required": true, + "type": "string" + }, + "fillers": { + "required": false, + "type": "optional>>" + }, + "handler": { + "required": true, + "type": "callable,any>" + }, + "is_typed_handler": { + "required": false, + "type": "bool" + }, + "name": { + "required": true, + "type": "string" + }, + "parameters": { + "required": false, + "type": "optional>>" + }, + "required": { + "required": false, + "type": "optional>" + }, + "secure": { + "required": false, + "type": "bool" + }, + "wait_file": { + "required": false, + "type": "optional" + }, + "wait_file_loops": { + "required": false, + "type": "optional" + }, + "webhook_url": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.core.swml_builder.SWMLBuilder": { + "params": { + "service": { + "required": true, + "type": "class:signalwire.core.swml_service.SWMLService" + } + } + }, + "signalwire.core.swml_service.SWMLService": { + "params": { + "basic_auth": { + "required": false, + "type": "optional>" + }, + "config_file": { + "required": false, + "type": "optional" + }, + "host": { + "required": false, + "type": "string" + }, + "name": { + "required": true, + "type": "string" + }, + "port": { + "required": false, + "type": "optional" + }, + "route": { + "required": false, + "type": "string" + }, + "schema_path": { + "required": false, + "type": "optional" + }, + "schema_validation": { + "required": false, + "type": "bool" + } + } + }, + "signalwire.pom.pom.PromptObjectModel": { + "params": { + "debug": { + "required": false, + "type": "bool" + } + } + }, + "signalwire.pom.pom.Section": { + "params": { + "body": { + "required": false, + "type": "string" + }, + "bullets": { + "required": false, + "type": "optional>" + }, + "numbered": { + "required": false, + "type": "optional" + }, + "numberedBullets": { + "required": false, + "type": "bool" + }, + "title": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.prefabs.concierge.ConciergeAgent": { + "params": { + "amenities": { + "required": true, + "type": "dict>" + }, + "hours_of_operation": { + "required": false, + "type": "optional>" + }, + "name": { + "required": false, + "type": "string" + }, + "route": { + "required": false, + "type": "string" + }, + "services": { + "required": true, + "type": "list" + }, + "special_instructions": { + "required": false, + "type": "optional>" + }, + "venue_name": { + "required": true, + "type": "string" + }, + "welcome_message": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.prefabs.faq_bot.FAQBotAgent": { + "params": { + "faqs": { + "required": true, + "type": "list>" + }, + "name": { + "required": false, + "type": "string" + }, + "persona": { + "required": false, + "type": "optional" + }, + "route": { + "required": false, + "type": "string" + }, + "suggest_related": { + "required": false, + "type": "bool" + } + } + }, + "signalwire.prefabs.info_gatherer.InfoGathererAgent": { + "params": { + "name": { + "required": false, + "type": "string" + }, + "questions": { + "required": false, + "type": "optional>>" + }, + "route": { + "required": false, + "type": "string" + } + } + }, + "signalwire.prefabs.receptionist.ReceptionistAgent": { + "params": { + "departments": { + "required": true, + "type": "list>" + }, + "greeting": { + "required": false, + "type": "string" + }, + "name": { + "required": false, + "type": "string" + }, + "route": { + "required": false, + "type": "string" + }, + "voice": { + "required": false, + "type": "string" + } + } + }, + "signalwire.prefabs.survey.SurveyAgent": { + "params": { + "brand_name": { + "required": false, + "type": "optional" + }, + "conclusion": { + "required": false, + "type": "optional" + }, + "introduction": { + "required": false, + "type": "optional" + }, + "max_retries": { + "required": false, + "type": "int" + }, + "name": { + "required": false, + "type": "string" + }, + "questions": { + "required": true, + "type": "list>" + }, + "route": { + "required": false, + "type": "string" + }, + "survey_name": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.AIAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.Action": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + }, + "terminal_event": { + "required": true, + "type": "string" + }, + "terminal_states": { + "required": true, + "type": "tuple" + } + } + }, + "signalwire.relay.call.Call": { + "params": { + "call_id": { + "required": true, + "type": "string" + }, + "client": { + "required": true, + "type": "class:signalwire.relay.client.RelayClient" + }, + "context": { + "required": false, + "type": "string" + }, + "device": { + "required": false, + "type": "optional>" + }, + "direction": { + "required": false, + "type": "string" + }, + "node_id": { + "required": true, + "type": "string" + }, + "project_id": { + "required": false, + "type": "string" + }, + "segment_id": { + "required": false, + "type": "string" + }, + "state": { + "required": false, + "type": "string" + }, + "tag": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.call.CollectAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.DetectAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.FaxAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + }, + "method_prefix": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.PayAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.PlayAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.RecordAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.StandaloneCollectAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.StreamAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.TapAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.call.TranscribeAction": { + "params": { + "call": { + "required": true, + "type": "class:signalwire.relay.call.Call" + }, + "control_id": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.client.RelayClient": { + "params": { + "contexts": { + "required": false, + "type": "optional>" + }, + "host": { + "required": false, + "type": "optional" + }, + "jwt_token": { + "required": false, + "type": "optional" + }, + "max_active_calls": { + "required": false, + "type": "optional" + }, + "project": { + "required": false, + "type": "optional" + }, + "space": { + "required": false, + "type": "any" + }, + "token": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.relay.client.RelayError": { + "params": { + "code": { + "required": true, + "type": "int" + }, + "message": { + "required": true, + "type": "string" + } + } + }, + "signalwire.relay.collect_config.CollectConfig": { + "params": { + "continuous": { + "required": false, + "type": "any" + }, + "digits": { + "required": false, + "type": "any" + }, + "initial_timeout": { + "required": false, + "type": "any" + }, + "partial_results": { + "required": false, + "type": "any" + }, + "send_start_of_input": { + "required": false, + "type": "any" + }, + "speech": { + "required": false, + "type": "any" + }, + "start_input_timers": { + "required": false, + "type": "any" + } + } + }, + "signalwire.relay.device.Device": { + "params": { + "params": { + "required": false, + "type": "any" + }, + "type": { + "required": true, + "type": "any" + } + } + }, + "signalwire.relay.event.CallReceiveEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "call_state": { + "required": false, + "type": "string" + }, + "context": { + "required": false, + "type": "string" + }, + "device": { + "required": false, + "type": "dict" + }, + "direction": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "node_id": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "project_id": { + "required": false, + "type": "string" + }, + "segment_id": { + "required": false, + "type": "string" + }, + "tag": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.CallStateEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "call_state": { + "required": false, + "type": "string" + }, + "device": { + "required": false, + "type": "dict" + }, + "direction": { + "required": false, + "type": "string" + }, + "end_reason": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.CallingErrorEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "code": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "message": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.CollectEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "final": { + "required": false, + "type": "optional" + }, + "params": { + "required": false, + "type": "dict" + }, + "result": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.ConferenceEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "conference_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "name": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "status": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.ConnectEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "connect_state": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "peer": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.DenoiseEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "denoised": { + "required": false, + "type": "bool" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.DetectEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "detect": { + "required": false, + "type": "dict" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.DialEvent": { + "params": { + "call": { + "required": false, + "type": "dict" + }, + "call_id": { + "required": false, + "type": "string" + }, + "dial_state": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "tag": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.EchoEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.FaxEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "fax": { + "required": false, + "type": "dict" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.HoldEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.MessageReceiveEvent": { + "params": { + "body": { + "required": false, + "type": "string" + }, + "call_id": { + "required": false, + "type": "string" + }, + "context": { + "required": false, + "type": "string" + }, + "direction": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "from_number": { + "required": false, + "type": "string" + }, + "media": { + "required": false, + "type": "list" + }, + "message_id": { + "required": false, + "type": "string" + }, + "message_state": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "segments": { + "required": false, + "type": "int" + }, + "tags": { + "required": false, + "type": "list" + }, + "timestamp": { + "required": false, + "type": "float" + }, + "to_number": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.event.MessageStateEvent": { + "params": { + "body": { + "required": false, + "type": "string" + }, + "call_id": { + "required": false, + "type": "string" + }, + "context": { + "required": false, + "type": "string" + }, + "direction": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "from_number": { + "required": false, + "type": "string" + }, + "media": { + "required": false, + "type": "list" + }, + "message_id": { + "required": false, + "type": "string" + }, + "message_state": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "reason": { + "required": false, + "type": "string" + }, + "segments": { + "required": false, + "type": "int" + }, + "tags": { + "required": false, + "type": "list" + }, + "timestamp": { + "required": false, + "type": "float" + }, + "to_number": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.event.PayEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.PlayEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.QueueEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "position": { + "required": false, + "type": "int" + }, + "queue_id": { + "required": false, + "type": "string" + }, + "queue_name": { + "required": false, + "type": "string" + }, + "size": { + "required": false, + "type": "int" + }, + "status": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.RecordEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "duration": { + "required": false, + "type": "float" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "record": { + "required": false, + "type": "dict" + }, + "size": { + "required": false, + "type": "int" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + }, + "url": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.event.ReferEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "sip_notify_response_code": { + "required": false, + "type": "string" + }, + "sip_refer_response_code": { + "required": false, + "type": "string" + }, + "sip_refer_to": { + "required": false, + "type": "string" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.RelayEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.SendDigitsEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.StreamEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "event_type": { + "required": true, + "type": "string" + }, + "name": { + "required": false, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + }, + "url": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.event.TapEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "device": { + "required": false, + "type": "dict" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "state": { + "required": false, + "type": "string" + }, + "tap": { + "required": false, + "type": "dict" + }, + "timestamp": { + "required": false, + "type": "float" + } + } + }, + "signalwire.relay.event.TranscribeEvent": { + "params": { + "call_id": { + "required": false, + "type": "string" + }, + "control_id": { + "required": false, + "type": "string" + }, + "duration": { + "required": false, + "type": "float" + }, + "event_type": { + "required": true, + "type": "string" + }, + "params": { + "required": false, + "type": "dict" + }, + "recording_id": { + "required": false, + "type": "string" + }, + "size": { + "required": false, + "type": "int" + }, + "state": { + "required": false, + "type": "string" + }, + "timestamp": { + "required": false, + "type": "float" + }, + "url": { + "required": false, + "type": "string" + } + } + }, + "signalwire.relay.message.Message": { + "params": { + "body": { + "required": false, + "type": "string" + }, + "context": { + "required": false, + "type": "string" + }, + "direction": { + "required": false, + "type": "string" + }, + "from_number": { + "required": false, + "type": "string" + }, + "media": { + "required": false, + "type": "optional>" + }, + "message_id": { + "required": false, + "type": "string" + }, + "reason": { + "required": false, + "type": "string" + }, + "segments": { + "required": false, + "type": "int" + }, + "state": { + "required": false, + "type": "string" + }, + "tags": { + "required": false, + "type": "optional>" + }, + "to_number": { + "required": false, + "type": "string" + } + } + }, + "signalwire.rest._base.BaseResource": { + "params": { + "base_path": { + "required": true, + "type": "string" + }, + "http": { + "required": true, + "type": "class:signalwire.rest._base.HttpClient" + } + } + }, + "signalwire.rest._base.HttpClient": { + "params": { + "base_url": { + "required": false, + "type": "any" + }, + "ca_file": { + "required": false, + "type": "any" + }, + "host": { + "required": true, + "type": "string" + }, + "project": { + "required": true, + "type": "string" + }, + "request_options": { + "required": false, + "type": "optional" + }, + "token": { + "required": true, + "type": "string" + } + } + }, + "signalwire.rest._base.SignalWireRestError": { + "params": { + "body": { + "required": true, + "type": "any" + }, + "headers": { + "required": false, + "type": "optional>" + }, + "method": { + "required": false, + "type": "string" + }, + "status_code": { + "required": true, + "type": "optional" + }, + "url": { + "required": true, + "type": "string" + } + } + }, + "signalwire.rest._base.SignalWireRestTransportError": { + "params": { + "body": { + "required": true, + "type": "any" + }, + "method": { + "required": false, + "type": "string" + }, + "url": { + "required": true, + "type": "string" + } + } + }, + "signalwire.rest._pagination.PaginatedIterator": { + "params": { + "data_key": { + "required": false, + "type": "string" + }, + "http": { + "required": true, + "type": "class:signalwire.rest._base.HttpClient" + }, + "params": { + "required": false, + "type": "optional>" + }, + "path": { + "required": true, + "type": "string" + }, + "request_options": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.rest._request_options.RequestOptions": { + "params": { + "abort_signal": { + "required": false, + "type": "optional" + }, + "retries": { + "required": false, + "type": "optional" + }, + "retry_backoff": { + "required": false, + "type": "optional" + }, + "retry_on_status": { + "required": false, + "type": "optional>" + }, + "timeout": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.rest.client.RestClient": { + "params": { + "base_url": { + "required": false, + "type": "any" + }, + "ca_file": { + "required": false, + "type": "any" + }, + "host": { + "required": false, + "type": "optional" + }, + "project": { + "required": false, + "type": "optional" + }, + "request_options": { + "required": false, + "type": "optional" + }, + "token": { + "required": false, + "type": "optional" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.DatasphereNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.FabricNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.LogsNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.ProjectNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.RegistryNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces._client_tree_generated.VideoNamespace": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.calling_resources_generated.Calling": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.chat_resources_generated.Chat": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.datasphere_resources_generated.DatasphereDocuments": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.AiAgents": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.CallFlows": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.ConferenceRooms": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.CxmlApplications": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.CxmlScripts": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.CxmlWebhooks": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.FabricAddresses": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.FabricTokens": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.FreeswitchConnectors": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.GenericResources": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.RelayApplications": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.SipEndpoints": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.SipGateways": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.Subscribers": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.SwmlScripts": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fabric_resources_generated.SwmlWebhooks": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.fax_resources_generated.FaxLogs": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.logs_resources_generated.ConferenceLogs": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.message_resources_generated.MessageLogs": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.messages_resources_generated.Messages": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.project_resources_generated.ProjectTokens": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.projects_resources_generated.Projects": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.pubsub_resources_generated.PubSub": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.Addresses": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.ImportedNumbers": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.Lookup": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.Mfa": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.NumberGroups": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.PhoneNumbers": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.Queues": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.Recordings": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.RegistryBrands": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.RegistryCampaigns": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.RegistryNumbers": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.RegistryOrders": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.ShortCodes": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.SipProfile": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.relay_rest_resources_generated.VerifiedCallers": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoConferenceTokens": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoConferences": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoRoomRecordings": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoRoomSessions": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoRoomTokens": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoRooms": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.video_resources_generated.VideoStreams": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.rest.namespaces.voice_resources_generated.VoiceLogs": { + "params": { + "http": { + "required": true, + "type": "any" + } + } + }, + "signalwire.serverless.lambda_handler.LambdaHandler": { + "params": { + "app": { + "required": true, + "type": "any" + } + } + }, + "signalwire.skills.api_ninjas_trivia.skill.ApiNinjasTriviaSkill": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + "params": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.skills.play_background_file.skill.PlayBackgroundFileSkill": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + "params": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.skills.spider.skill.SpiderSkill": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + "params": { + "required": false, + "type": "dict" + } + } + }, + "signalwire.skills.weather_api.skill.WeatherApiSkill": { + "params": { + "agent": { + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + "params": { + "required": false, + "type": "optional>" + } + } + }, + "signalwire.utils.schema_utils.SchemaUtils": { + "params": { + "schema_path": { + "required": false, + "type": "optional" + }, + "schema_validation": { + "required": false, + "type": "bool" + } + } + }, + "signalwire.utils.schema_utils.SchemaValidationError": { + "params": { + "errors": { + "required": true, + "type": "list" + }, + "verb_name": { + "required": true, + "type": "string" + } + } + }, + "signalwire.web.web_service.WebService": { + "params": { + "allowed_extensions": { + "required": false, + "type": "optional>" + }, + "basic_auth": { + "required": false, + "type": "optional>" + }, + "blocked_extensions": { + "required": false, + "type": "optional>" + }, + "config_file": { + "required": false, + "type": "optional" + }, + "directories": { + "required": false, + "type": "optional>" + }, + "enable_cors": { + "required": false, + "type": "bool" + }, + "enable_directory_browsing": { + "required": false, + "type": "bool" + }, + "max_file_size": { + "required": false, + "type": "int" + }, + "port": { + "required": false, + "type": "int" + } + } + } + }, + "generated_from": "signalwire-ruby via Method#parameters reflection @ 7de2304 (v3.0.0 release floor, commit-anchored)", + "generated_from_commit": "7de2304ec7471bca2c9b50998c924d05505191bf", "modules": { "signalwire": { "functions": { - "RestClient": { + "RestClient": { + "params": [ + { + "default": null, + "kind": "var_positional", + "name": "args", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "add_skill_directory": { + "params": [ + { + "name": "path", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "list_skills": { + "params": [], + "returns": "any" + }, + "list_skills_with_params": { + "params": [], + "returns": "any" + }, + "register_skill": { + "params": [ + { + "name": "skill_class", + "required": true, + "type": "class:signalwire.core.skill_base.SkillBase" + } + ], + "returns": "any" + } + } + }, + "signalwire.agent_server": { + "classes": { + "AgentServer": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "0.0.0.0", + "kind": "keyword", + "name": "host", + "required": false, + "type": "string" + }, + { + "default": 3000, + "kind": "keyword", + "name": "port", + "required": false, + "type": "int" + }, + { + "default": "info", + "kind": "keyword", + "name": "log_level", + "required": false, + "type": "string" + } + ], + "returns": "void" + }, + "app": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_agent": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "route", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "get_agents": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "host": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "log_level": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "logger": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "port": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "rack_app": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "register": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "agent", + "required": true, + "type": "class:signalwire.core.agent_base.AgentBase" + }, + { + "default": null, + "kind": "keyword", + "name": "route", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "register_global_routing_callback": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "callback_fn", + "required": true, + "type": "callable,dict>,optional>" + }, + { + "name": "path", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "register_sip_username": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "username", + "required": true, + "type": "string" + }, + { + "name": "route", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "run": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "event", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "context", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "host", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "port", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "serve_static_files": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "directory", + "required": true, + "type": "string" + }, + { + "default": "/", + "name": "route", + "required": false, + "type": "string" + } + ], + "returns": "any" + }, + "setup_sip_routing": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "/sip", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": true, + "kind": "keyword", + "name": "auto_map", + "required": false, + "type": "bool" + } + ], + "returns": "any" + }, + "unregister": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "route", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.agents.bedrock": { + "classes": { + "BedrockAgent": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "bedrock_agent", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/bedrock", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "system_prompt", + "required": false, + "type": "optional" + }, + { + "default": "matthew", + "kind": "keyword", + "name": "voice_id", + "required": false, + "type": "string" + }, + { + "default": 0.7, + "kind": "keyword", + "name": "temperature", + "required": false, + "type": "float" + }, + { + "default": 0.9, + "kind": "keyword", + "name": "top_p", + "required": false, + "type": "float" + }, + { + "default": 1024, + "kind": "keyword", + "name": "max_tokens", + "required": false, + "type": "int" + }, + { + "default": null, + "kind": "var_keyword", + "name": "**", + "required": false, + "type": "any" + } + ], + "returns": "void" + }, + "inspect": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "set_inference_params": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "temperature", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "top_p", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "max_tokens", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "set_llm_model": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "model", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_llm_temperature": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "temperature", + "required": true, + "type": "float" + } + ], + "returns": "any" + }, + "set_post_prompt_llm_params": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "_params", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "set_prompt_llm_params": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "_params", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "set_voice": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "voice_id", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "to_s": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.ai_chat.client": { + "classes": { + "AIChatClient": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "project", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "token", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "space", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "url", + "required": false, + "type": "optional" + }, + { + "default": 10, + "kind": "keyword", + "name": "connect_timeout", + "required": false, + "type": "any" + }, + { + "default": 60, + "kind": "keyword", + "name": "read_idle_timeout", + "required": false, + "type": "any" + } + ], + "returns": "void" + }, + "chat": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + }, + { + "name": "message", + "required": true, + "type": "string" + }, + { + "default": "user", + "kind": "keyword", + "name": "role", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "config_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "user_metadata", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "reinit", + "required": false, + "type": "bool" + } + ], + "returns": "any" + }, + "close": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "create_conversation": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "config_url", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "user_message", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "user_metadata", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "reinit", + "required": false, + "type": "bool" + } + ], + "returns": "any" + }, + "delete": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "end": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "inspect": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "log": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "summarize": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "conversation_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "summary_prompt", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "temperature", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "top_p", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "frequency_penalty", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "presence_penalty", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "max_tokens", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "to_s": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "url": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "AIChatError": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "code", + "required": true, + "type": "optional" + }, + { + "name": "message", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "code": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "message": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "ChatLog": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "messages", + "required": false, + "type": "list>" + }, + { + "default": null, + "kind": "keyword", + "name": "call_timeline", + "required": false, + "type": "list>" + } + ], + "returns": "void" + }, + "call_timeline": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "messages": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "ChatResponse": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "text", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "conversation_id", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "user_event", + "required": false, + "type": "optional>" + } + ], + "returns": "void" + }, + "conversation_id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "text": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "user_event": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "ConversationInfo": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "id", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "status", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "initial_message", + "required": false, + "type": "optional" + } + ], + "returns": "void" + }, + "id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "initial_message": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "status": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.contexts": { + "classes": { + "Contexts": { + "methods": {} + } + } + }, + "signalwire.core.agent.prompt.manager": { + "classes": { + "PromptManager": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "agent", + "required": false, + "type": "any" + } + ], + "returns": "void" + }, + "agent": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "define_contexts": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "contexts", + "required": true, + "type": "union,any>" + } + ], + "returns": "any" + }, + "get_contexts": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_post_prompt": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_prompt": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_raw_prompt": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "pom": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "prompt_add_section": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "numbered", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "numbered_bullets", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "subsections", + "required": false, + "type": "optional>>" + } + ], + "returns": "any" + }, + "prompt_add_subsection": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "parent_title", + "required": true, + "type": "string" + }, + { + "name": "title", + "required": true, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + } + ], + "returns": "any" + }, + "prompt_add_to_section": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "body", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "bullet", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + } + ], + "returns": "any" + }, + "prompt_has_section": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_post_prompt": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "text", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_prompt_pom": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "pom", + "required": true, + "type": "list>" + } + ], + "returns": "any" + }, + "set_prompt_text": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "text", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.agent.tools.registry": { + "classes": { + "ToolRegistry": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "agent", + "required": false, + "type": "any" + } + ], + "returns": "void" + }, + "agent": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "define_tool": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "description", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "parameters", + "required": true, + "type": "dict" + }, + { + "kind": "keyword", + "name": "handler", + "required": true, + "type": "callable,any>" + }, + { + "default": true, + "kind": "keyword", + "name": "secure", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "fillers", + "required": false, + "type": "optional>>" + }, + { + "default": null, + "kind": "keyword", + "name": "wait_file", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "wait_file_loops", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "webhook_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "required", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "is_typed_handler", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "swaig_fields", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "get_all_functions": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_function": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "has_function": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "register_swaig_function": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "function_dict", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "remove_function": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.agent.tools.type_inference": { + "functions": { + "create_typed_handler_wrapper": { + "params": [ + { + "name": "func", + "required": true, + "type": "callable,any>" + }, + { + "name": "has_raw_data", + "required": true, + "type": "bool" + } + ], + "returns": "any" + }, + "infer_schema": { "params": [ { - "name": "args", - "type": "any", - "kind": "var_positional", + "name": "func", + "required": true, + "type": "callable,any>" + }, + { + "default": null, + "kind": "keyword", + "name": "types", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "descriptions", "required": false, - "default": null + "type": "any" + } + ], + "returns": "any" + } + } + }, + "signalwire.core.agent_base": { + "classes": { + "AgentBase": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "agent", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": "0.0.0.0", + "kind": "keyword", + "name": "host", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "port", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "basic_auth", + "required": false, + "type": "optional>" + }, + { + "default": true, + "kind": "keyword", + "name": "use_pom", + "required": false, + "type": "bool" + }, + { + "default": 3600, + "kind": "keyword", + "name": "token_expiry_secs", + "required": false, + "type": "int" + }, + { + "default": true, + "kind": "keyword", + "name": "auto_answer", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "record_call", + "required": false, + "type": "bool" + }, + { + "default": "mp4", + "kind": "keyword", + "name": "record_format", + "required": false, + "type": "string" + }, + { + "default": true, + "kind": "keyword", + "name": "record_stereo", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "default_webhook_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "agent_id", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "native_functions", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "schema_path", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "suppress_logs", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "enable_post_prompt_override", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "check_for_input_override", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "config_file", + "required": false, + "type": "optional" + }, + { + "default": true, + "kind": "keyword", + "name": "schema_validation", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "signing_key", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "trust_proxy_for_signature", + "required": false, + "type": "bool" + } + ], + "returns": "void" + }, + "add_answer_verb": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "config", + "required": false, + "type": "optional>" + } + ], + "returns": "any" + }, + "add_post_ai_verb": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" + }, + { + "name": "config", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "add_post_answer_verb": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" + }, + { + "name": "config", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "add_pre_answer_verb": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" + }, + { + "name": "config", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "add_swaig_query_params": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "params", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "agent_id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "app": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "as_rack_app": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "auto_map_sip_usernames": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "add_skill_directory": { - "params": [ - { - "name": "path", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "list_skills": { - "params": [], - "returns": "any" - }, - "list_skills_with_params": { - "params": [], - "returns": "any" - }, - "register_skill": { - "params": [ - { - "name": "skill_class", - "type": "class:signalwire.core.skill_base.SkillBase", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.agent_server": { - "classes": { - "AgentServer": { - "methods": { - "__init__": { + "basic_auth_credentials": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "host", - "type": "string", + "default": false, + "kind": "keyword", + "name": "include_source", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "build_main_section": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "clear_post_ai_verbs": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "clear_post_answer_verbs": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "clear_pre_answer_verbs": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "clear_swaig_query_params": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "contexts": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "contexts", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "create_tool_token": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "tool_name", + "required": true, + "type": "any" + }, + { + "name": "call_id", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "default_webhook_url": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "define_tools": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "enable_sip_routing": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": true, + "kind": "keyword", + "name": "auto_map", + "required": false, + "type": "bool" + }, + { + "default": "/sip", + "kind": "keyword", + "name": "path", + "required": false, + "type": "string" + } + ], + "returns": "any" + }, + "extract_sip_username": { + "params": [ + { + "name": "sip_uri", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "extract_sip_username_from_request": { + "params": [ + { + "name": "request_data", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "full_url": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": false, + "kind": "keyword", + "name": "include_auth", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "get_full_url": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": false, + "kind": "keyword", + "name": "include_auth", + "required": false, + "type": "bool" + } + ], + "returns": "any" + }, + "get_name": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "handle_additional_route": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "sub_path", + "required": true, + "type": "any" + }, + { + "name": "request_data", + "required": true, + "type": "any" + }, + { + "name": "env", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "handle_request": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "method", + "required": true, + "type": "any" + }, + { + "name": "url", + "required": true, + "type": "any" + }, + { + "name": "headers", + "required": true, + "type": "any" + }, + { + "default": null, + "name": "body", + "required": false, + "type": "any" + }, + { + "default": null, "kind": "keyword", + "name": "request", "required": false, - "default": null + "type": "any" }, { - "name": "port", - "type": "int", - "kind": "keyword", - "required": false, - "default": null - }, + "default": false, + "kind": "keyword", + "name": "skip_auth", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "list_tool_names": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "logger": { + "params": [ { - "name": "log_level", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "app": { + "native_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_agent": { + "on_debug_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "route", - "type": "string", - "required": true + "name": "handler", + "required": true, + "type": "callable,any>" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "get_agents": { + "on_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "summary", + "required": true, + "type": "optional" + }, + { + "default": null, + "name": "raw_data", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "host": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "log_level": { + "post_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "logger": { + "prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "port": { + "prompt_text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -159,169 +4801,113 @@ "rack_app": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register": { + "register_sip_username": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "agent", - "type": "class:signalwire.core.agent_base.AgentBase", - "required": true + "kind": "self", + "name": "self" }, { - "name": "route", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "sip_username", + "required": true, + "type": "string" } ], "returns": "any" }, - "register_global_routing_callback": { + "render_swml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "callback_fn", - "type": "callable,dict>,optional>", + "default": null, + "name": "request_data", "required": false, - "default": null - }, - { - "name": "path", - "type": "string", - "kind": "keyword", - "required": true + "type": "any" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "request", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "register_sip_username": { + "set_post_prompt_url": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "username", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "route", - "type": "string", - "required": true + "name": "url", + "required": true, + "type": "string" } ], "returns": "any" }, - "run": { + "set_web_hook_url": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "context", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "host", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" } ], "returns": "any" }, - "serve_static_files": { + "signing_key": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "directory", - "type": "string", - "required": true - }, - { - "name": "route", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "setup_sip_routing": { + "skill": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "route", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "auto_map", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "skill_name", + "required": true, + "type": "any" } ], "returns": "any" }, - "unregister": { + "skill_manager": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "use_pom": { + "params": [ { - "name": "route", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" @@ -330,460 +4916,409 @@ } } }, - "signalwire.agents.bedrock": { + "signalwire.core.auth_error": { "classes": { - "BedrockAgent": { + "AuthError": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "route", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "system_prompt", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "voice_id", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "temperature", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "response", + "required": true, + "type": "any" + } + ], + "returns": "void" + }, + "response": { + "params": [ { - "name": "top_p", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.auth_handler": { + "classes": { + "AuthHandler": { + "methods": { + "__init__": { + "params": [ { - "name": "max_tokens", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "**", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "security_config", + "required": true, + "type": "class:signalwire.core.security_config.SecurityConfig" } ], "returns": "void" }, - "inspect": { + "auth_methods": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_inference_params": { + "flask_decorator": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "temperature", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "f", + "required": true, + "type": "callable,any>" + } + ], + "returns": "any" + }, + "get_auth_info": { + "params": [ { - "name": "top_p", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_fastapi_dependency": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "max_tokens", - "type": "any", + "default": false, "kind": "keyword", + "name": "optional", "required": false, - "default": null + "type": "bool" } ], "returns": "any" }, - "set_llm_model": { + "rack_dependency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "model", - "type": "any", - "required": true + "default": false, + "kind": "keyword", + "name": "optional", + "required": false, + "type": "any" } ], "returns": "any" }, - "set_llm_temperature": { + "rack_middleware": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "temperature", - "type": "any", - "required": true + "name": "app", + "required": true, + "type": "any" } ], "returns": "any" }, - "set_post_prompt_llm_params": { + "security_config": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_prompt_llm_params": { + "verify_api_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "_params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "api_key", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_voice": { + "verify_basic_auth": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "voice_id", - "type": "any", - "required": true + "name": "credentials", + "required": true, + "type": "class:signalwire.core.auth_handler.BasicCredentials" } ], "returns": "any" }, - "to_s": { + "verify_bearer_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "credentials", + "required": true, + "type": "class:signalwire.core.auth_handler.BearerCredentials" } ], "returns": "any" } } - } - } - }, - "signalwire.contexts": { - "classes": { - "Contexts": { - "methods": {} - } - } - }, - "signalwire.core.agent.prompt.manager": { - "classes": { - "PromptManager": { + }, + "BasicCredentials": { + "dataclass": true, "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "agent", - "type": "any", - "required": false, - "default": null + "name": "username", + "required": true, + "type": "string" + }, + { + "name": "password", + "required": true, + "type": "string" } ], "returns": "void" }, - "define_contexts": { + "password": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "contexts", - "type": "union,any>", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_contexts": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "get_post_prompt": { + } + } + }, + "BearerCredentials": { + "dataclass": true, + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "scheme", + "required": true, + "type": "string" + }, + { + "name": "credentials", + "required": true, + "type": "string" } ], - "returns": "any" + "returns": "void" }, - "get_prompt": { + "credentials": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_raw_prompt": { + "scheme": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" + } + } + } + } + }, + "signalwire.core.config_loader": { + "classes": { + "ConfigLoader": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "config_paths", + "required": false, + "type": "optional>" + } + ], + "returns": "void" }, - "pom": { + "config_paths": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_add_section": { + "find_config_file": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered_bullets", - "type": "bool", - "kind": "keyword", + "default": null, + "name": "service_name", "required": false, - "default": null + "type": "optional" }, { - "name": "subsections", - "type": "optional>>", - "kind": "keyword", + "default": null, + "name": "additional_paths", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "prompt_add_subsection": { + "get": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "parent_title", - "type": "string", - "required": true - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "body", - "type": "string", - "required": false, - "default": null + "name": "key_path", + "required": true, + "type": "string" }, { - "name": "bullets", - "type": "optional>", - "kind": "keyword", + "default": null, + "name": "default", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "prompt_add_to_section": { + "get_config": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body_arg", - "type": "any", - "required": false, - "default": null - }, - { - "name": "body", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullet", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_config_file": { + "params": [ { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_has_section": { + "get_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "title", - "type": "string", - "required": true + "name": "section", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_post_prompt": { + "has_config": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_prompt_pom": { + "merge_with_env": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "pom", - "type": "list>", - "required": true + "default": "SWML_", + "name": "env_prefix", + "required": false, + "type": "string" } ], "returns": "any" }, - "set_prompt_text": { + "substitute_vars": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "text", - "type": "string", - "required": true + "name": "value", + "required": true, + "type": "any" + }, + { + "default": 10, + "name": "max_depth", + "required": false, + "type": "int" } ], "returns": "any" @@ -792,4096 +5327,4325 @@ } } }, - "signalwire.core.agent.tools.registry": { + "signalwire.core.contexts": { "classes": { - "ToolRegistry": { + "Context": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "agent", - "type": "any", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" } ], "returns": "void" }, - "define_tool": { + "add_bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true + "name": "title", + "required": true, + "type": "string" }, { - "name": "description", - "type": "string", - "kind": "keyword", - "required": true + "name": "bullets", + "required": true, + "type": "list" + } + ], + "returns": "any" + }, + "add_enter_filler": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "parameters", - "type": "dict", - "kind": "keyword", - "required": false, - "default": null + "name": "language_code", + "required": true, + "type": "string" }, { - "name": "handler", - "type": "callable,any>", - "kind": "keyword", - "required": false, - "default": null + "name": "fillers", + "required": true, + "type": "list" + } + ], + "returns": "any" + }, + "add_exit_filler": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "language_code", + "required": true, + "type": "string" }, { - "name": "secure", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "fillers", + "required": true, + "type": "list" + } + ], + "returns": "any" + }, + "add_section": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "fillers", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null + "name": "title", + "required": true, + "type": "string" }, { - "name": "wait_file", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "body", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "add_step": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "wait_file_loops", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" }, { - "name": "webhook_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "task", "required": false, - "default": null + "type": "optional" }, { - "name": "required", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" }, { - "name": "is_typed_handler", - "type": "bool", + "default": null, "kind": "keyword", + "name": "criteria", "required": false, - "default": null + "type": "optional" }, { - "name": "swaig_fields", - "type": "any", + "default": null, "kind": "keyword", + "name": "functions", "required": false, - "default": null + "type": "optional>>" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "valid_steps", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "get_all_functions": { + "add_system_bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" + }, + { + "name": "bullets", + "required": true, + "type": "list" } ], "returns": "any" }, - "get_function": { + "add_system_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true + "name": "title", + "required": true, + "type": "string" + }, + { + "name": "body", + "required": true, + "type": "string" } ], "returns": "any" }, - "has_function": { + "get_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" }, - "register_swaig_function": { + "move_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "func_def", - "type": "any", - "required": true + "name": "name", + "required": true, + "type": "string" + }, + { + "name": "position", + "required": true, + "type": "int" } ], "returns": "any" }, - "remove_function": { + "name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.agent.tools.type_inference": { - "functions": { - "create_typed_handler_wrapper": { - "params": [ - { - "name": "func", - "type": "callable,any>", - "required": true }, - { - "name": "has_raw_data", - "type": "bool", - "required": true - } - ], - "returns": "any" - }, - "infer_schema": { - "params": [ - { - "name": "func", - "type": "callable,any>", - "required": true - }, - { - "name": "types", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "descriptions", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - } - ], - "returns": "any" - } - } - }, - "signalwire.core.agent_base": { - "classes": { - "AgentBase": { - "methods": { - "__init__": { + "remove_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "route", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "host", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "basic_auth", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "use_pom", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "token_expiry_secs", - "type": "int", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "auto_answer", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "record_call", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "record_format", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_consolidate": { + "params": [ { - "name": "record_stereo", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "default_webhook_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "consolidate", + "required": true, + "type": "bool" + } + ], + "returns": "any" + }, + "set_enter_fillers": { + "params": [ { - "name": "agent_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "native_functions", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "enter_fillers", + "required": true, + "type": "dict>" + } + ], + "returns": "any" + }, + "set_exit_fillers": { + "params": [ { - "name": "schema_path", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "suppress_logs", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "exit_fillers", + "required": true, + "type": "dict>" + } + ], + "returns": "any" + }, + "set_full_reset": { + "params": [ { - "name": "enable_post_prompt_override", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "check_for_input_override", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "full_reset", + "required": true, + "type": "bool" + } + ], + "returns": "any" + }, + "set_history": { + "params": [ { - "name": "config_file", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "schema_validation", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "history", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_initial_step": { + "params": [ { - "name": "signing_key", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "trust_proxy_for_signature", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "step_name", + "required": true, + "type": "string" } ], - "returns": "void" + "returns": "any" }, - "add_answer_verb": { + "set_isolated": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "config", - "type": "optional>", - "required": true + "name": "isolated", + "required": true, + "type": "bool" } ], "returns": "any" }, - "add_post_ai_verb": { + "set_post_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "verb_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "config", - "type": "dict", - "required": true + "name": "post_prompt", + "required": true, + "type": "string" } ], "returns": "any" }, - "add_post_answer_verb": { + "set_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "verb_name", - "type": "string", - "required": true + "name": "prompt", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_system_prompt": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "config", - "type": "dict", - "required": true + "name": "system_prompt", + "required": true, + "type": "string" } ], "returns": "any" }, - "add_pre_answer_verb": { + "set_user_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "verb_name", - "type": "string", - "required": true + "name": "user_prompt", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_valid_contexts": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "config", - "type": "dict", - "required": true + "name": "contexts", + "required": true, + "type": "list" } ], "returns": "any" }, - "add_swaig_query_params": { + "set_valid_steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "dict", - "required": true + "name": "steps", + "required": true, + "type": "list" } ], "returns": "any" }, - "agent_id": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" + } + } + }, + "ContextBuilder": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "agent", + "required": false, + "type": "any" + } + ], + "returns": "void" }, - "as_rack_app": { + "add_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "string" } ], "returns": "any" }, - "auto_map_sip_usernames": { + "attach_agent": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "agent", + "required": true, + "type": "any" } ], "returns": "any" }, - "clear_post_ai_verbs": { + "get_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "string" } ], "returns": "any" }, - "clear_post_answer_verbs": { + "reset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "clear_pre_answer_verbs": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "clear_swaig_query_params": { + "validate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "contexts": { + } + } + }, + "GatherInfo": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "contexts", - "type": "any", + "default": null, + "kind": "keyword", + "name": "output_key", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "completion_action", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "prompt", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "isolated", "required": false, - "default": null + "type": "bool" } ], - "returns": "any" + "returns": "void" }, - "create_tool_token": { + "add_question": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "tool_name", - "type": "any", - "required": true + "kind": "keyword", + "name": "key", + "required": true, + "type": "string" }, { - "name": "call_id", - "type": "any", - "required": true + "kind": "keyword", + "name": "question", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "opts", + "required": false, + "type": "any" } ], "returns": "any" }, - "default_webhook_url": { + "completion_action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "define_tools": { + "output_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_sip_routing": { + "prompt": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "questions": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "to_dict": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "GatherQuestion": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "auto_map", - "type": "bool", "kind": "keyword", + "name": "key", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "question", + "required": true, + "type": "string" + }, + { + "default": "string", + "kind": "keyword", + "name": "type", + "required": false, + "type": "string" + }, + { + "default": false, + "kind": "keyword", + "name": "confirm", "required": false, - "default": null + "type": "bool" }, { - "name": "path", - "type": "string", + "default": null, + "kind": "keyword", + "name": "prompt", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "functions", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "isolated", "required": false, - "default": null + "type": "optional" + } + ], + "returns": "void" + }, + "confirm": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "functions": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "isolated": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "key": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" }, - "extract_sip_username": { + "prompt": { "params": [ { - "name": "sip_uri", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "extract_sip_username_from_request": { + "question": { "params": [ { - "name": "request_data", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_full_url": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "include_auth", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_name": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "handle_additional_route": { + } + } + }, + "Step": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "sub_path", - "type": "any", - "required": true + "name": "name", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "add_bullets": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "request_data", - "type": "any", - "required": true + "name": "title", + "required": true, + "type": "string" }, { - "name": "env", - "type": "any", - "required": true + "name": "bullets", + "required": true, + "type": "list" } ], "returns": "any" }, - "handle_request": { + "add_gather_question": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "method", - "type": "any", - "required": true + "kind": "keyword", + "name": "key", + "required": true, + "type": "string" }, { - "name": "url", - "type": "any", - "required": true + "kind": "keyword", + "name": "question", + "required": true, + "type": "string" }, { - "name": "headers", - "type": "any", - "required": true + "default": "string", + "kind": "keyword", + "name": "type", + "required": false, + "type": "string" }, { - "name": "body", - "type": "any", + "default": false, + "kind": "keyword", + "name": "confirm", "required": false, - "default": null + "type": "bool" }, { - "name": "request", - "type": "any", + "default": null, "kind": "keyword", + "name": "prompt", "required": false, - "default": null + "type": "optional" }, { - "name": "skip_auth", - "type": "any", + "default": null, + "kind": "keyword", + "name": "functions", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "isolated", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "list_tool_names": { + "add_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" + }, + { + "name": "body", + "required": true, + "type": "string" } ], "returns": "any" }, - "logger": { + "clear_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "native_functions": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_debug_event": { + "set_end": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "name": "end", + "required": true, + "type": "bool" } ], "returns": "any" }, - "on_summary": { + "set_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "summary", - "type": "optional", + "name": "functions", + "required": true, + "type": "union>" + } + ], + "returns": "any" + }, + "set_gather_info": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "output_key", "required": false, - "default": null + "type": "optional" }, { - "name": "raw_data", - "type": "optional", + "default": null, + "kind": "keyword", + "name": "completion_action", "required": false, - "default": null + "type": "optional" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "prompt", "required": false, - "default": null - } - ], - "returns": "any" - }, - "pom": { - "params": [ + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": false, + "kind": "keyword", + "name": "isolated", + "required": false, + "type": "bool" } ], "returns": "any" }, - "post_prompt": { + "set_history": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "prompt": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "history", + "required": true, + "type": "string" } ], "returns": "any" }, - "prompt_text": { + "set_reset_consolidate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "consolidate", + "required": true, + "type": "bool" } ], "returns": "any" }, - "rack_app": { + "set_reset_full_reset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "full_reset", + "required": true, + "type": "bool" } ], "returns": "any" }, - "register_sip_username": { + "set_reset_system_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "sip_username", - "type": "string", - "required": true + "name": "system_prompt", + "required": true, + "type": "string" } ], "returns": "any" }, - "render_swml": { + "set_reset_user_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "request_data", - "type": "any", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "request", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "name": "user_prompt", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_post_prompt_url": { + "set_skip_to_next_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "url", - "type": "string", - "required": true + "name": "skip", + "required": true, + "type": "bool" } ], "returns": "any" }, - "set_web_hook_url": { + "set_skip_user_turn": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "url", - "type": "string", - "required": true + "name": "skip", + "required": true, + "type": "bool" } ], "returns": "any" }, - "signing_key": { + "set_step_criteria": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "criteria", + "required": true, + "type": "string" } ], "returns": "any" }, - "skill_manager": { + "set_text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "text", + "required": true, + "type": "string" } ], "returns": "any" }, - "use_pom": { + "set_valid_contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "contexts", + "required": true, + "type": "list" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.auth_error": { - "classes": { - "AuthError": { - "methods": { - "__init__": { + }, + "set_valid_steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "response", - "type": "any", - "required": true + "name": "steps", + "required": true, + "type": "list" } ], - "returns": "void" + "returns": "any" }, - "response": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } } + }, + "functions": { + "create_simple_context": { + "params": [ + { + "default": "default", + "name": "name", + "required": false, + "type": "string" + } + ], + "returns": "any" + } } }, - "signalwire.core.auth_handler": { + "signalwire.core.data_map": { "classes": { - "AuthHandler": { + "DataMap": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "security_config", - "type": "class:signalwire.core.security_config.SecurityConfig", - "required": true + "name": "function_name", + "required": true, + "type": "string" } ], "returns": "void" }, - "auth_methods": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "flask_decorator": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "f", - "type": "callable,any>", - "required": true + "name": "description", + "required": true, + "type": "string" } ], "returns": "any" }, - "get_auth_info": { + "error_keys": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "keys", + "required": true, + "type": "list" } ], "returns": "any" }, - "get_fastapi_dependency": { + "expression": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "optional", - "type": "bool", + "name": "test_value", + "required": true, + "type": "string" + }, + { + "name": "pattern", + "required": true, + "type": "union" + }, + { + "name": "output", + "required": true, + "type": "class:signalwire.core.function_result.FunctionResult" + }, + { + "default": null, "kind": "keyword", + "name": "nomatch_output", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "rack_dependency": { + "fallback_output": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "optional", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "name": "result", + "required": true, + "type": "class:signalwire.core.function_result.FunctionResult" } ], "returns": "any" }, - "rack_middleware": { + "foreach": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "app", - "type": "any", - "required": true + "name": "config", + "required": true, + "type": "any" } ], "returns": "any" }, - "security_config": { + "function_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "verify_api_key": { + "global_error_keys": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "api_key", - "type": "string", - "required": true + "name": "keys", + "required": true, + "type": "list" } ], "returns": "any" }, - "verify_basic_auth": { + "output": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "credentials", - "type": "class:HTTPBasicCredentials", - "required": true + "name": "result", + "required": true, + "type": "class:signalwire.core.function_result.FunctionResult" } ], "returns": "any" }, - "verify_bearer_token": { + "parameter": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "credentials", - "type": "class:HTTPAuthorizationCredentials", - "required": true + "name": "name", + "required": true, + "type": "string" + }, + { + "name": "type", + "required": true, + "type": "any" + }, + { + "name": "desc", + "required": true, + "type": "any" + }, + { + "default": false, + "kind": "keyword", + "name": "required", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "enum", + "required": false, + "type": "optional>" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.auth_handler.basic_credentials": { - "classes": { - "BasicCredentials": { - "methods": { - "inspect": { - "params": [], - "returns": "any" - }, - "keyword_init": { - "params": [], - "returns": "any" }, - "members": { - "params": [], - "returns": "any" - }, - "new": { - "params": [], - "returns": "any" - }, - "password": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "username": { + "purpose": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "description", + "required": true, + "type": "string" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.auth_handler.bearer_credentials": { - "classes": { - "BearerCredentials": { - "methods": { - "credentials": { + }, + "to_swaig_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "inspect": { - "params": [], - "returns": "any" - }, - "keyword_init": { - "params": [], - "returns": "any" - }, - "members": { - "params": [], - "returns": "any" - }, - "new": { - "params": [], - "returns": "any" - } - } - } - } - }, - "signalwire.core.config_loader": { - "classes": { - "ConfigLoader": { - "methods": { - "__init__": { + "webhook": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "config_paths", - "type": "optional>", - "required": false, - "default": null - } - ], - "returns": "void" - }, - "find_config_file": { - "params": [ + "name": "method", + "required": true, + "type": "string" + }, { - "name": "service_name", - "type": "optional", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" }, { - "name": "additional_paths", - "type": "optional>", + "default": null, + "kind": "keyword", + "name": "headers", "required": false, - "default": null - } - ], - "returns": "any" - }, - "get": { - "params": [ + "type": "optional>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "form_param", + "required": false, + "type": "optional" }, { - "name": "key_path", - "type": "string", - "required": true + "default": false, + "kind": "keyword", + "name": "input_args_as_params", + "required": false, + "type": "bool" }, { - "name": "default", - "type": "any", + "default": null, + "kind": "keyword", + "name": "require_args", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "get_config": { + "webhook_expressions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "expressions", + "required": true, + "type": "list>" } ], "returns": "any" + } + } + } + }, + "functions": { + "create_expression_tool": { + "params": [ + { + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" }, - "get_config_file": { + { + "kind": "keyword", + "name": "patterns", + "required": true, + "type": "dict>" + }, + { + "default": null, + "kind": "keyword", + "name": "parameters", + "required": false, + "type": "optional>>" + } + ], + "returns": "any" + }, + "create_simple_api_tool": { + "params": [ + { + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "url", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "response_template", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "parameters", + "required": false, + "type": "optional>>" + }, + { + "default": "GET", + "kind": "keyword", + "name": "method", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "headers", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "body", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "error_keys", + "required": false, + "type": "optional>" + } + ], + "returns": "any" + } + } + }, + "signalwire.core.function_result": { + "classes": { + "FunctionResult": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "get_section": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": null, + "name": "response", + "required": false, + "type": "optional" }, { - "name": "section", - "type": "string", - "required": true + "default": false, + "kind": "keyword", + "name": "post_process", + "required": false, + "type": "bool" } ], - "returns": "any" + "returns": "void" }, - "has_config": { + "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "merge_with_env": { + "add_action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "env_prefix", - "type": "string", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" + }, + { + "name": "data", + "required": true, + "type": "any" } ], "returns": "any" }, - "substitute_vars": { + "add_actions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "value", - "type": "any", - "required": true - }, - { - "name": "max_depth", - "type": "int", - "required": false, - "default": null + "name": "actions", + "required": true, + "type": "list>" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.contexts": { - "classes": { - "Context": { - "methods": { - "__init__": { + }, + "add_dynamic_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true + "name": "hints", + "required": true, + "type": "list>>" } ], - "returns": "void" + "returns": "any" }, - "add_bullets": { + "clear_dynamic_hints": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "bullets", - "type": "list", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_enter_filler": { + "connect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "language_code", - "type": "string", - "required": true + "name": "destination", + "required": true, + "type": "string" }, { - "name": "fillers", - "type": "list", - "required": true + "default": true, + "kind": "keyword", + "name": "final", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "from_addr", + "required": false, + "type": "optional" } ], "returns": "any" }, - "add_exit_filler": { + "create_payment_action": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "language_code", - "type": "string", - "required": true + "name": "action_type", + "required": true, + "type": "string" }, { - "name": "fillers", - "type": "list", - "required": true + "name": "phrase", + "required": true, + "type": "string" } ], "returns": "any" }, - "add_section": { + "create_payment_parameter": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "body", - "type": "string", - "required": true + "name": "value", + "required": true, + "type": "string" } ], "returns": "any" }, - "add_step": { + "create_payment_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true - }, - { - "name": "task", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "name": "for_situation", + "required": true, + "type": "string" }, { - "name": "criteria", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "actions", + "required": true, + "type": "list>" }, { - "name": "functions", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "card_type", "required": false, - "default": null + "type": "optional" }, { - "name": "valid_steps", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "error_type", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "add_system_bullets": { + "enable_extensive_data": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "bullets", - "type": "list", - "required": true + "default": true, + "name": "enabled", + "required": false, + "type": "bool" } ], "returns": "any" }, - "add_system_section": { + "enable_functions_on_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "body", - "type": "string", - "required": true + "default": true, + "name": "enabled", + "required": false, + "type": "bool" } ], "returns": "any" }, - "get_step": { + "execute_rpc": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "move_step": { - "params": [ + "name": "method", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "params", + "required": false, + "type": "optional>" }, { - "name": "name", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "call_id", + "required": false, + "type": "optional" }, { - "name": "position", - "type": "int", - "required": true + "default": null, + "kind": "keyword", + "name": "node_id", + "required": false, + "type": "optional" } ], "returns": "any" }, - "name": { + "execute_swml": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "remove_step": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "swml_content", + "required": true, + "type": "union>,any>" }, { - "name": "name", - "type": "string", - "required": true + "default": false, + "kind": "keyword", + "name": "transfer", + "required": false, + "type": "bool" } ], "returns": "any" }, - "set_consolidate": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "consolidate", - "type": "bool", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_enter_fillers": { + "hold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "enter_fillers", - "type": "dict>", - "required": true + "default": 300, + "name": "timeout", + "required": false, + "type": "int" } ], "returns": "any" }, - "set_exit_fillers": { + "join_conference": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "exit_fillers", - "type": "dict>", - "required": true - } - ], - "returns": "any" - }, - "set_full_reset": { - "params": [ - { - "name": "self", - "kind": "self" + "name": "name", + "required": true, + "type": "string" }, { - "name": "full_reset", - "type": "bool", - "required": true - } - ], - "returns": "any" - }, - "set_history": { - "params": [ + "default": false, + "kind": "keyword", + "name": "muted", + "required": false, + "type": "bool" + }, { - "name": "self", - "kind": "self" + "default": "true", + "kind": "keyword", + "name": "beep", + "required": false, + "type": "string" }, { - "name": "history", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_initial_step": { - "params": [ + "default": true, + "kind": "keyword", + "name": "start_on_enter", + "required": false, + "type": "bool" + }, { - "name": "self", - "kind": "self" + "default": false, + "kind": "keyword", + "name": "end_on_exit", + "required": false, + "type": "bool" }, { - "name": "step_name", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_isolated": { - "params": [ + "default": null, + "kind": "keyword", + "name": "wait_url", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": 250, + "kind": "keyword", + "name": "max_participants", + "required": false, + "type": "int" }, { - "name": "isolated", - "type": "bool", - "required": true - } - ], - "returns": "any" - }, - "set_post_prompt": { - "params": [ + "default": "do-not-record", + "kind": "keyword", + "name": "record", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "region", + "required": false, + "type": "optional" }, { - "name": "post_prompt", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_prompt": { - "params": [ + "default": "trim-silence", + "kind": "keyword", + "name": "trim", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "coach", + "required": false, + "type": "optional" }, { - "name": "prompt", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_system_prompt": { - "params": [ + "default": null, + "kind": "keyword", + "name": "status_callback_event", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "status_callback", + "required": false, + "type": "optional" }, { - "name": "system_prompt", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_user_prompt": { - "params": [ + "default": "POST", + "kind": "keyword", + "name": "status_callback_method", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "recording_status_callback", + "required": false, + "type": "optional" }, { - "name": "user_prompt", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "set_valid_contexts": { - "params": [ + "default": "POST", + "kind": "keyword", + "name": "recording_status_callback_method", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": "completed", + "kind": "keyword", + "name": "recording_status_callback_event", + "required": false, + "type": "string" }, { - "name": "contexts", - "type": "list", - "required": true + "default": null, + "kind": "keyword", + "name": "result", + "required": false, + "type": "optional" } ], "returns": "any" }, - "set_valid_steps": { + "join_room": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "steps", - "type": "list", - "required": true + "name": "name", + "required": true, + "type": "string" } ], "returns": "any" }, - "to_dict": { + "pay": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "ContextBuilder": { - "methods": { - "__init__": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "payment_connector_url", + "required": true, + "type": "string" }, { - "name": "agent", - "type": "any", + "default": "dtmf", + "kind": "keyword", + "name": "input_method", "required": false, - "default": null - } - ], - "returns": "void" - }, - "add_context": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "string" }, { - "name": "name", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "attach_agent": { - "params": [ - { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "status_url", + "required": false, + "type": "optional" }, { - "name": "agent", - "type": "any", - "required": true - } - ], - "returns": "any" - }, - "get_context": { - "params": [ + "default": "credit-card", + "kind": "keyword", + "name": "payment_method", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": 5, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "int" }, { - "name": "name", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "reset": { - "params": [ + "default": 1, + "kind": "keyword", + "name": "max_attempts", + "required": false, + "type": "int" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "validate": { - "params": [ + "default": true, + "kind": "keyword", + "name": "security_code", + "required": false, + "type": "bool" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "to_dict": { - "params": [ + "default": true, + "kind": "keyword", + "name": "postal_code", + "required": false, + "type": "union" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "GatherInfo": { - "methods": { - "__init__": { - "params": [ + "default": 0, + "kind": "keyword", + "name": "min_postal_code_length", + "required": false, + "type": "int" + }, { - "name": "self", - "kind": "self" + "default": "reusable", + "kind": "keyword", + "name": "token_type", + "required": false, + "type": "string" }, { - "name": "output_key", - "type": "optional", + "default": null, "kind": "keyword", + "name": "charge_amount", "required": false, - "default": null + "type": "optional" }, { - "name": "completion_action", - "type": "optional", + "default": "usd", "kind": "keyword", + "name": "currency", "required": false, - "default": null + "type": "string" }, { - "name": "prompt", - "type": "optional", + "default": "en-US", "kind": "keyword", + "name": "language", "required": false, - "default": null - } - ], - "returns": "void" - }, - "add_question": { - "params": [ + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": "woman", + "kind": "keyword", + "name": "voice", + "required": false, + "type": "string" }, { - "name": "key", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "description", + "required": false, + "type": "optional" }, { - "name": "question", - "type": "string", + "default": "visa mastercard amex", "kind": "keyword", - "required": true + "name": "valid_card_types", + "required": false, + "type": "string" }, { - "name": "opts", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "parameters", "required": false, - "default": null - } - ], - "returns": "any" - }, - "completion_action": { - "params": [ + "type": "optional>>" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "output_key": { - "params": [ + "default": null, + "kind": "keyword", + "name": "prompts", + "required": false, + "type": "optional>>" + }, { - "name": "self", - "kind": "self" + "default": "The payment status is ${pay_result}, do not mention anything else about collecting payment if successful.", + "kind": "keyword", + "name": "ai_response", + "required": false, + "type": "optional" } ], "returns": "any" }, - "prompt": { + "play_background_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "filename", + "required": true, + "type": "string" + }, + { + "default": false, + "kind": "keyword", + "name": "wait", + "required": false, + "type": "bool" } ], "returns": "any" }, - "questions": { + "post_process": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_dict": { + "record_call": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "GatherQuestion": { - "methods": { - "__init__": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" }, { - "name": "key", - "type": "string", + "default": false, "kind": "keyword", - "required": true + "name": "stereo", + "required": false, + "type": "bool" }, { - "name": "question", - "type": "string", + "default": "wav", "kind": "keyword", - "required": true + "name": "format", + "required": false, + "type": "string" }, { - "name": "type", - "type": "string", + "default": "both", "kind": "keyword", + "name": "direction", "required": false, - "default": null + "type": "string" }, { - "name": "confirm", - "type": "bool", + "default": null, "kind": "keyword", + "name": "terminators", "required": false, - "default": null + "type": "optional" }, { - "name": "prompt", - "type": "optional", + "default": false, "kind": "keyword", + "name": "beep", "required": false, - "default": null + "type": "bool" }, { - "name": "functions", - "type": "optional>", + "default": 44.0, "kind": "keyword", + "name": "input_sensitivity", "required": false, - "default": null - } - ], - "returns": "void" - }, - "confirm": { - "params": [ + "type": "float" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "functions": { - "params": [ + "default": null, + "kind": "keyword", + "name": "initial_timeout", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "end_silence_timeout", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "max_length", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "status_url", + "required": false, + "type": "optional" } ], "returns": "any" }, - "key": { + "remove_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "keys", + "required": true, + "type": "union>" } ], "returns": "any" }, - "prompt": { + "remove_metadata": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "keys", + "required": true, + "type": "union>" } ], "returns": "any" }, - "question": { + "replace_in_history": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": true, + "name": "text", + "required": false, + "type": "union" } ], "returns": "any" }, - "type": { + "response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_dict": { + "rpc_ai_message": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "Step": { - "methods": { - "__init__": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "call_id", + "required": true, + "type": "string" }, { - "name": "name", - "type": "string", - "required": true + "name": "message_text", + "required": true, + "type": "string" + }, + { + "default": "system", + "kind": "keyword", + "name": "role", + "required": false, + "type": "string" } ], - "returns": "void" + "returns": "any" }, - "add_bullets": { + "rpc_ai_unhold": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "bullets", - "type": "list", - "required": true + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "add_gather_question": { + "rpc_dial": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "key", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "question", - "type": "string", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "type", - "type": "string", "kind": "keyword", - "required": false, - "default": null + "name": "to_number", + "required": true, + "type": "string" }, { - "name": "confirm", - "type": "bool", "kind": "keyword", - "required": false, - "default": null + "name": "from_number", + "required": true, + "type": "string" }, { - "name": "prompt", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "dest_swml", + "required": true, + "type": "string" }, { - "name": "functions", - "type": "optional>", + "default": "phone", "kind": "keyword", + "name": "device_type", "required": false, - "default": null + "type": "string" } ], "returns": "any" }, - "add_section": { + "say": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "clear_sections": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "name": { - "params": [ - { - "name": "self", - "kind": "self" + "name": "text", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_end": { + "send_sms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "end", - "type": "bool", - "required": true - } - ], - "returns": "any" - }, - "set_functions": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "to_number", + "required": true, + "type": "string" }, { - "name": "functions", - "type": "union>", - "required": true - } - ], - "returns": "any" - }, - "set_gather_info": { - "params": [ + "kind": "keyword", + "name": "from_number", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "body", + "required": false, + "type": "optional" }, { - "name": "output_key", - "type": "optional", + "default": null, "kind": "keyword", + "name": "media", "required": false, - "default": null + "type": "optional>" }, { - "name": "completion_action", - "type": "optional", + "default": null, "kind": "keyword", + "name": "tags", "required": false, - "default": null + "type": "optional>" }, { - "name": "prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "region", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "set_history": { + "set_end_of_speech_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "history", - "type": "string", - "required": true + "name": "milliseconds", + "required": true, + "type": "int" } ], "returns": "any" }, - "set_reset_consolidate": { + "set_metadata": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "consolidate", - "type": "bool", - "required": true + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "set_reset_full_reset": { + "set_post_process": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "full_reset", - "type": "bool", - "required": true + "name": "post_process", + "required": true, + "type": "bool" } ], "returns": "any" }, - "set_reset_system_prompt": { + "set_response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "system_prompt", - "type": "string", - "required": true + "name": "response", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_reset_user_prompt": { + "set_speech_event_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "user_prompt", - "type": "string", - "required": true + "name": "milliseconds", + "required": true, + "type": "int" } ], "returns": "any" }, - "set_skip_to_next_step": { + "simulate_user_input": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "skip", - "type": "bool", - "required": true + "name": "text", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_skip_user_turn": { + "sip_refer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "skip", - "type": "bool", - "required": true + "name": "to_uri", + "required": true, + "type": "string" } ], "returns": "any" }, - "set_step_criteria": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "criteria", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_text": { + "stop_background_file": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_valid_contexts": { + "stop_record_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "contexts", - "type": "list", - "required": true + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" } ], "returns": "any" }, - "set_valid_steps": { + "stop_tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "steps", - "type": "list", - "required": true + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" } ], "returns": "any" }, - "to_dict": { + "switch_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "system_prompt", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "user_prompt", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "consolidate", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "full_reset", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "isolated", + "required": false, + "type": "any" } ], "returns": "any" - } - } - } - }, - "functions": { - "create_simple_context": { - "params": [ - { - "name": "name", - "type": "string", - "required": false, - "default": null - } - ], - "returns": "any" - } - } - }, - "signalwire.core.data_map": { - "classes": { - "DataMap": { - "methods": { - "__init__": { + }, + "swml_change_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "function_name", - "type": "string", - "required": true + "name": "context_name", + "required": true, + "type": "string" } ], - "returns": "void" + "returns": "any" }, - "body": { + "swml_change_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "data", - "type": "dict", - "required": true + "name": "step_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "description": { + "swml_transfer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "description", - "type": "string", - "required": true + "name": "dest", + "required": true, + "type": "string" + }, + { + "name": "ai_response", + "required": true, + "type": "string" + }, + { + "default": true, + "kind": "keyword", + "name": "final", + "required": false, + "type": "bool" } ], "returns": "any" }, - "error_keys": { + "swml_user_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "keys", - "type": "list", - "required": true + "name": "event_data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "expression": { + "tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "test_value", - "type": "string", - "required": true + "name": "uri", + "required": true, + "type": "string" }, { - "name": "pattern", - "type": "union", - "required": true + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" }, { - "name": "output", - "type": "class:signalwire.core.function_result.FunctionResult", - "required": true + "default": "both", + "kind": "keyword", + "name": "direction", + "required": false, + "type": "string" }, { - "name": "nomatch_output", - "type": "optional", + "default": "PCMU", + "kind": "keyword", + "name": "codec", + "required": false, + "type": "string" + }, + { + "default": 20, + "kind": "keyword", + "name": "rtp_ptime", + "required": false, + "type": "int" + }, + { + "default": null, "kind": "keyword", + "name": "status_url", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "fallback_output": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "result", - "type": "class:signalwire.core.function_result.FunctionResult", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "foreach": { + "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "config", - "type": "any", - "required": true + "default": null, + "kind": "var_positional", + "name": "*", + "required": false, + "type": "any" } ], "returns": "any" }, - "function_name": { + "toggle_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_toggles", + "required": true, + "type": "list>" } ], "returns": "any" }, - "global_error_keys": { + "update_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "keys", - "type": "list", - "required": true + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "output": { + "update_settings": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "result", - "type": "class:signalwire.core.function_result.FunctionResult", - "required": true + "name": "settings", + "required": true, + "type": "dict" } ], "returns": "any" }, - "parameter": { + "wait_for_user": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "enabled", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" }, { - "name": "type", - "type": "any", - "required": true + "default": false, + "kind": "keyword", + "name": "answer_first", + "required": false, + "type": "bool" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.logging_config": { + "functions": { + "configure_logging": { + "params": [], + "returns": "any" + }, + "get_execution_mode": { + "params": [], + "returns": "any" + }, + "get_logger": { + "params": [ + { + "name": "name", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "reset_logging_configuration": { + "params": [], + "returns": "any" + }, + "strip_control_chars": { + "params": [ + { + "name": "event_dict", + "required": true, + "type": "dict" + } + ], + "returns": "any" + } + } + }, + "signalwire.core.mixins.ai_config_mixin": { + "classes": { + "AIConfigMixin": { + "methods": { + "add_function_include": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "desc", - "type": "any", - "required": true + "name": "url", + "required": true, + "type": "string" }, { - "name": "required", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "functions", + "required": true, + "type": "list" }, { - "name": "enum", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "meta_data", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "params": { + "add_hint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "data", - "type": "dict", - "required": true + "name": "hint", + "required": true, + "type": "string" } ], "returns": "any" }, - "purpose": { + "add_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "description", - "type": "string", - "required": true + "name": "hints", + "required": true, + "type": "list" } ], "returns": "any" }, - "to_swaig_function": { + "add_internal_filler": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "string" + }, + { + "name": "language_code", + "required": true, + "type": "string" + }, + { + "name": "fillers", + "required": true, + "type": "list" } ], "returns": "any" }, - "webhook": { + "add_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "method", - "type": "string", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "url", - "type": "string", - "required": true + "name": "code", + "required": true, + "type": "string" }, { - "name": "headers", - "type": "optional>", + "name": "voice", + "required": true, + "type": "string" + }, + { + "default": null, "kind": "keyword", + "name": "speech_fillers", "required": false, - "default": null + "type": "optional>" }, { - "name": "form_param", - "type": "optional", + "default": null, "kind": "keyword", + "name": "function_fillers", "required": false, - "default": null + "type": "optional>" }, { - "name": "input_args_as_params", - "type": "bool", + "default": null, "kind": "keyword", + "name": "engine", "required": false, - "default": null + "type": "optional" }, { - "name": "require_args", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "model", "required": false, - "default": null - } - ], - "returns": "any" - }, - "webhook_expressions": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "optional" }, { - "name": "expressions", - "type": "list>", - "required": true + "default": null, + "kind": "keyword", + "name": "params", + "required": false, + "type": "optional>" } ], "returns": "any" - } - } - } - }, - "functions": { - "create_expression_tool": { - "params": [ - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "patterns", - "type": "dict>", - "kind": "keyword", - "required": true - }, - { - "name": "parameters", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "create_simple_api_tool": { - "params": [ - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "url", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "response_template", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "parameters", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "method", - "type": "string", - "kind": "keyword", - "required": false, - "default": null }, - { - "name": "headers", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "body", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "error_keys", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - } - ], - "returns": "any" - } - } - }, - "signalwire.core.function_result": { - "classes": { - "FunctionResult": { - "methods": { - "__init__": { + "add_mcp_server": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "response", - "type": "optional", + "name": "url", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "headers", "required": false, - "default": null + "type": "optional>" }, { - "name": "post_process", - "type": "bool", + "default": false, "kind": "keyword", + "name": "resources", "required": false, - "default": null - } - ], - "returns": "void" - }, - "action": { - "params": [ + "type": "bool" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "resource_vars", + "required": false, + "type": "optional>" } ], "returns": "any" }, - "add_action": { + "add_pattern_hint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true + "name": "hint", + "required": true, + "type": "string" }, { - "name": "data", - "type": "any", - "required": true + "name": "pattern", + "required": true, + "type": "string" + }, + { + "name": "replace", + "required": true, + "type": "string" + }, + { + "default": false, + "kind": "keyword", + "name": "ignore_case", + "required": false, + "type": "bool" } ], "returns": "any" }, - "add_actions": { + "add_pronunciation": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "actions", - "type": "list>", - "required": true + "name": "replace", + "required": true, + "type": "string" + }, + { + "name": "with_text", + "required": true, + "type": "string" + }, + { + "default": false, + "kind": "keyword", + "name": "ignore_case", + "required": false, + "type": "bool" + }, + { + "default": "en-US", + "kind": "keyword", + "name": "language_code", + "required": false, + "type": "any" } ], "returns": "any" }, - "add_dynamic_hints": { + "enable_debug_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "hints", - "type": "list>>", - "required": true + "default": 1, + "name": "level", + "required": false, + "type": "int" } ], "returns": "any" }, - "clear_dynamic_hints": { + "enable_mcp_server": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "connect": { + "get_language_params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "destination", - "type": "string", - "required": true - }, + "name": "code", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_function_includes": { + "params": [ { - "name": "final", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "from_addr", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "includes", + "required": true, + "type": "list>" } ], "returns": "any" }, - "create_payment_action": { + "set_global_data": { "params": [ { - "name": "action_type", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "phrase", - "type": "string", - "required": true + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "create_payment_parameter": { + "set_internal_fillers": { "params": [ { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "value", - "type": "string", - "required": true + "name": "internal_fillers", + "required": true, + "type": "dict>>" } ], "returns": "any" }, - "create_payment_prompt": { + "set_language_params": { "params": [ { - "name": "for_situation", - "type": "string", - "required": true - }, - { - "name": "actions", - "type": "list>", - "required": true + "kind": "self", + "name": "self" }, { - "name": "card_type", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "code", + "required": true, + "type": "string" }, { - "name": "error_type", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "params", + "required": true, + "type": "dict" } ], "returns": "any" }, - "enable_extensive_data": { + "set_languages": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "enabled", - "type": "bool", - "required": false, - "default": null + "name": "languages", + "required": true, + "type": "list>" } ], "returns": "any" }, - "enable_functions_on_timeout": { + "set_multilingual": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "enabled", - "type": "bool", - "required": false, - "default": null + "name": "config", + "required": true, + "type": "dict" } ], "returns": "any" }, - "execute_rpc": { + "set_native_functions": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "method", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "call_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "node_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "function_names", + "required": true, + "type": "list" } ], "returns": "any" }, - "execute_swml": { + "set_param": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "swml_content", - "type": "union>,any>", - "required": true + "name": "key", + "required": true, + "type": "string" }, { - "name": "transfer", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "value", + "required": true, + "type": "any" } ], "returns": "any" }, - "hangup": { + "set_params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "params", + "required": true, + "type": "dict" } ], "returns": "any" }, - "hold": { + "set_post_prompt_llm_params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "timeout", - "type": "int", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "join_conference": { + "set_prompt_llm_params": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "muted", - "type": "bool", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null - }, + "type": "any" + } + ], + "returns": "any" + }, + "set_pronunciations": { + "params": [ { - "name": "beep", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "start_on_enter", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "pronunciations", + "required": true, + "type": "list>" + } + ], + "returns": "any" + }, + "update_global_data": { + "params": [ { - "name": "end_on_exit", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "wait_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "data", + "required": true, + "type": "dict" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.mixins.auth_mixin": { + "classes": { + "AuthMixin": { + "methods": { + "get_basic_auth_credentials": { + "params": [ { - "name": "max_participants", - "type": "int", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "record", - "type": "string", + "default": false, "kind": "keyword", + "name": "include_source", "required": false, - "default": null - }, + "type": "bool" + } + ], + "returns": "any" + }, + "validate_basic_auth": { + "params": [ { - "name": "region", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "trim", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "username", + "required": true, + "type": "string" }, { - "name": "coach", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "password", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.mixins.mcp_server_mixin": { + "classes": { + "MCPServerMixin": { + "methods": { + "add_mcp_server": { + "params": [ { - "name": "status_callback_event", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "status_callback", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" }, { - "name": "status_callback_method", - "type": "string", + "default": null, "kind": "keyword", + "name": "headers", "required": false, - "default": null + "type": "optional>" }, { - "name": "recording_status_callback", - "type": "optional", + "default": false, "kind": "keyword", + "name": "resources", "required": false, - "default": null + "type": "bool" }, { - "name": "recording_status_callback_method", - "type": "string", + "default": null, "kind": "keyword", + "name": "resource_vars", "required": false, - "default": null - }, + "type": "optional>" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.mixins.prompt_mixin": { + "classes": { + "PromptMixin": { + "methods": { + "define_contexts": { + "params": [ { - "name": "recording_status_callback_event", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "result", - "type": "optional", - "kind": "keyword", + "default": null, + "name": "contexts", "required": false, - "default": null + "type": "optional,class:signalwire.core.contexts.ContextBuilder>>" } ], "returns": "any" }, - "join_room": { + "get_post_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pay": { + "get_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "payment_connector_url", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "input_method", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "status_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "prompt_add_section": { + "params": [ { - "name": "payment_method", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "timeout", - "type": "int", - "kind": "keyword", - "required": false, - "default": null + "name": "title", + "required": true, + "type": "string" }, { - "name": "max_attempts", - "type": "int", - "kind": "keyword", + "default": "", + "name": "body", "required": false, - "default": null + "type": "string" }, { - "name": "security_code", - "type": "bool", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" }, { - "name": "postal_code", - "type": "union", + "default": false, "kind": "keyword", + "name": "numbered", "required": false, - "default": null + "type": "bool" }, { - "name": "min_postal_code_length", - "type": "int", + "default": false, "kind": "keyword", + "name": "numbered_bullets", "required": false, - "default": null + "type": "bool" }, { - "name": "token_type", - "type": "string", + "default": null, "kind": "keyword", + "name": "subsections", "required": false, - "default": null + "type": "optional>>" + } + ], + "returns": "any" + }, + "prompt_add_subsection": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "charge_amount", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "parent_title", + "required": true, + "type": "string" }, { - "name": "currency", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "title", + "required": true, + "type": "string" }, { - "name": "language", - "type": "string", - "kind": "keyword", + "default": "", + "name": "body", "required": false, - "default": null + "type": "string" }, { - "name": "voice", - "type": "string", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" + } + ], + "returns": "any" + }, + "prompt_add_to_section": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "description", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "title", + "required": true, + "type": "string" }, { - "name": "valid_card_types", - "type": "string", - "kind": "keyword", + "default": null, + "name": "body_arg", "required": false, - "default": null + "type": "any" }, { - "name": "parameters", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "body", "required": false, - "default": null + "type": "optional" }, { - "name": "prompts", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "bullet", "required": false, - "default": null + "type": "optional" }, { - "name": "ai_response", - "type": "optional", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "play_background_file": { + "prompt_has_section": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "filename", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "wait", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "title", + "required": true, + "type": "string" } ], "returns": "any" }, - "post_process": { + "reset_contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "record_call": { + "set_post_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "stereo", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "text", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "set_prompt_text": { + "params": [ { - "name": "format", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "direction", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "text", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.mixins.serverless_mixin": { + "classes": { + "ServerlessMixin": { + "methods": { + "handle_serverless_request": { + "params": [ { - "name": "terminators", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "beep", - "type": "bool", + "default": null, "kind": "keyword", + "name": "event", "required": false, - "default": null + "type": "any" }, { - "name": "input_sensitivity", - "type": "float", + "default": null, "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "any" }, { - "name": "initial_timeout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "mode", "required": false, - "default": null - }, + "type": "optional" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.mixins.skill_mixin": { + "classes": { + "SkillMixin": { + "methods": { + "add_skill": { + "params": [ { - "name": "end_silence_timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "max_length", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "skill_name", + "required": true, + "type": "string" }, { - "name": "status_url", - "type": "optional", - "kind": "keyword", + "default": null, + "name": "params", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "remove_global_data": { + "has_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "keys", - "type": "union>", - "required": true + "name": "skill_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "remove_metadata": { + "list_skills": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "keys", - "type": "union>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "replace_in_history": { + "remove_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "text", - "type": "union", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "response": { - "params": [ - { - "name": "self", - "kind": "self" + "name": "skill_name", + "required": true, + "type": "string" } ], "returns": "any" - }, - "rpc_ai_message": { + } + } + } + } + }, + "signalwire.core.mixins.state_mixin": { + "classes": { + "StateMixin": { + "methods": { + "validate_tool_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call_id", - "type": "string", - "required": true + "name": "function_name", + "required": true, + "type": "string" }, { - "name": "message_text", - "type": "string", - "required": true + "name": "token", + "required": true, + "type": "string" }, { - "name": "role", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" - }, - "rpc_ai_unhold": { + } + } + } + } + }, + "signalwire.core.mixins.tool_mixin": { + "classes": { + "ToolMixin": { + "methods": { + "define_tool": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call_id", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "rpc_dial": { - "params": [ + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "description", + "required": true, + "type": "string" }, { - "name": "to_number", - "type": "string", "kind": "keyword", - "required": true + "name": "parameters", + "required": true, + "type": "dict" }, { - "name": "from_number", - "type": "string", "kind": "keyword", - "required": true + "name": "handler", + "required": true, + "type": "callable,any>" }, { - "name": "dest_swml", - "type": "string", + "default": true, "kind": "keyword", - "required": true + "name": "secure", + "required": false, + "type": "bool" }, { - "name": "device_type", - "type": "string", + "default": null, "kind": "keyword", + "name": "fillers", "required": false, - "default": null - } - ], - "returns": "any" - }, - "say": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "optional>>" }, { - "name": "text", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "send_sms": { - "params": [ - { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "wait_file", + "required": false, + "type": "any" }, { - "name": "to_number", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "wait_file_loops", + "required": false, + "type": "any" }, { - "name": "from_number", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "webhook_url", + "required": false, + "type": "optional" }, { - "name": "body", - "type": "optional", + "default": null, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "optional>" }, { - "name": "media", - "type": "optional>", + "default": false, "kind": "keyword", + "name": "is_typed_handler", "required": false, - "default": null + "type": "bool" }, { - "name": "tags", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "swaig_fields", "required": false, - "default": null + "type": "any" }, { - "name": "region", - "type": "optional", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "set_end_of_speech_timeout": { + "on_function_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "milliseconds", - "type": "int", - "required": true - } - ], - "returns": "any" - }, - "set_metadata": { - "params": [ + "name": "name", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "name": "args", + "required": true, + "type": "dict" }, { - "name": "data", - "type": "dict", - "required": true + "default": null, + "name": "raw_data", + "required": false, + "type": "optional>" } ], "returns": "any" }, - "set_post_process": { + "register_swaig_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "post_process", - "type": "bool", - "required": true + "name": "func_def", + "required": true, + "type": "any" } ], "returns": "any" - }, - "set_response": { + } + } + } + } + }, + "signalwire.core.mixins.web_mixin": { + "classes": { + "WebMixin": { + "methods": { + "as_router": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "response", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], - "returns": "any" + "returns": "class:signalwire.core.web.HostAppRouter" }, - "set_speech_event_timeout": { + "enable_debug_routes": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "milliseconds", - "type": "int", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "simulate_user_input": { + "get_app": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sip_refer": { + "manual_set_proxy_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "to_uri", - "type": "string", - "required": true + "name": "proxy_url", + "required": true, + "type": "string" } ], "returns": "any" }, - "stop": { + "on_request": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "stop_background_file": { - "params": [ + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "request_data", + "required": false, + "type": "optional>" + }, { - "name": "self", - "kind": "self" + "default": null, + "name": "callback_path", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "request", + "required": false, + "type": "any" } ], "returns": "any" }, - "stop_record_call": { + "on_swml_request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "optional", + "default": null, + "name": "_request_data", + "required": false, + "type": "any" + }, + { + "default": null, + "name": "_callback_path", + "required": false, + "type": "any" + }, + { + "default": null, "kind": "keyword", + "name": "request", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "stop_tap": { + "register_routing_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "optional", + "name": "callback_fn", + "required": true, + "type": "callable,dict>,optional>" + }, + { + "default": "/sip", + "name": "path", + "required": false, + "type": "string" + }, + { + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "switch_context": { + "run": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "system_prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "event", "required": false, - "default": null + "type": "optional>" }, { - "name": "user_prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "any" }, { - "name": "consolidate", - "type": "bool", + "default": null, "kind": "keyword", + "name": "force_mode", "required": false, - "default": null + "type": "optional" }, { - "name": "full_reset", - "type": "bool", + "default": null, "kind": "keyword", + "name": "host", "required": false, - "default": null + "type": "optional" }, { - "name": "isolated", - "type": "any", + "default": null, "kind": "keyword", + "name": "port", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "swml_change_context": { + "serve": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "context_name", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "host", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "port", + "required": false, + "type": "optional" } ], "returns": "any" }, - "swml_change_step": { + "set_dynamic_config_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "step_name", - "type": "string", - "required": true + "name": "callback", + "required": true, + "type": "callable,dict,dict,class:signalwire.core.agent_base.AgentBase>,void>" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "swml_transfer": { + "setup_graceful_shutdown": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.pom_builder": { + "classes": { + "PomBuilder": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "void" + }, + "add_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "dest", - "type": "string", - "required": true + "name": "title", + "required": true, + "type": "string" }, { - "name": "ai_response", - "type": "string", - "required": true + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" }, { - "name": "final", - "type": "bool", + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "numbered", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "numbered_bullets", + "required": false, + "type": "bool" + }, + { + "default": null, "kind": "keyword", + "name": "subsections", "required": false, - "default": null + "type": "optional>>" } ], "returns": "any" }, - "swml_user_event": { + "add_subsection": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "event_data", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "tap": { - "params": [ - { - "name": "self", - "kind": "self" + "name": "parent_title", + "required": true, + "type": "string" }, { - "name": "uri", - "type": "string", - "required": true + "name": "title", + "required": true, + "type": "string" }, { - "name": "control_id", - "type": "optional", + "default": "", "kind": "keyword", + "name": "body", "required": false, - "default": null + "type": "string" }, { - "name": "direction", - "type": "string", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" + } + ], + "returns": "any" + }, + "add_to_section": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "codec", - "type": "string", + "name": "title", + "required": true, + "type": "string" + }, + { + "default": null, "kind": "keyword", + "name": "body", "required": false, - "default": null + "type": "optional" }, { - "name": "rtp_ptime", - "type": "int", + "default": null, "kind": "keyword", + "name": "bullet", "required": false, - "default": null + "type": "optional" }, { - "name": "status_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "bullets", "required": false, - "default": null + "type": "optional>" } ], "returns": "any" }, - "to_json": { + "from_sections": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "*", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "name": "sections", + "required": true, + "type": "list>" } ], "returns": "any" }, - "toggle_functions": { + "get_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "function_toggles", - "type": "list>", - "required": true + "name": "title", + "required": true, + "type": "string" } ], "returns": "any" }, - "update_global_data": { + "has_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "data", - "type": "dict", - "required": true + "name": "title", + "required": true, + "type": "string" } ], "returns": "any" }, - "update_settings": { + "pom": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "settings", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_user": { + "render_markdown": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "enabled", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "render_xml": { + "params": [ { - "name": "answer_first", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" @@ -4889,8 +9653,24 @@ "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "to_json": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_positional", + "name": "_args", + "required": false, + "type": "any" } ], "returns": "any" @@ -4899,1986 +9679,1309 @@ } } }, - "signalwire.core.logging_config": { - "functions": { - "configure_logging": { - "params": [], - "returns": "any" - }, - "get_execution_mode": { - "params": [], - "returns": "any" - }, - "get_logger": { - "params": [ - { - "name": "name", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "reset_logging_configuration": { - "params": [], - "returns": "any" - }, - "strip_control_chars": { - "params": [ - { - "name": "event_dict", - "type": "dict", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.core.mixins.ai_config_mixin": { + "signalwire.core.post_prompt_generated": { "classes": { - "AIConfigMixin": { + "PostPrompt": { "methods": { - "add_function_include": { + "SWMLCall": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "url", - "type": "string", - "required": true - }, - { - "name": "functions", - "type": "list", - "required": true - }, - { - "name": "meta_data", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_hint": { + "SWMLVars": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "hint", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_hints": { + "action": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "hints", - "type": "list", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_internal_filler": { + "ai_end_date": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "language_code", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "ai_id_tag": { + "params": [ { - "name": "fillers", - "type": "list", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_language": { + "ai_session_id": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "ai_start_date": { + "params": [ { - "name": "name_or_config", - "type": "any", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "app_name": { + "params": [ { - "name": "code", - "type": "string", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_answer_date": { + "params": [ { - "name": "voice", - "type": "string", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_end_date": { + "params": [ { - "name": "speech_fillers", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_ended_by": { + "params": [ { - "name": "function_fillers", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_id": { + "params": [ { - "name": "engine", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_log": { + "params": [ { - "name": "model", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "call_start_date": { + "params": [ { - "name": "params", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_mcp_server": { + "call_timeline": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "url", - "type": "string", - "required": true - }, - { - "name": "headers", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "resources", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "resource_vars", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_pattern_hint": { + "caller_id_name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null - }, - { - "name": "hint", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "pattern", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "replace", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "ignore_case", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "language", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_pronunciation": { + "caller_id_number": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "replace", - "type": "string", - "required": true - }, - { - "name": "with_text", - "type": "string", - "required": true - }, - { - "name": "ignore_case", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "language_code", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_debug_events": { + "content_disposition": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "level", - "type": "int", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_mcp_server": { + "content_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_language_params": { + "conversation_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "code", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_function_includes": { + "conversation_summary": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "includes", - "type": "list>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_global_data": { + "conversation_type": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "data", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_internal_fillers": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "internal_fillers", - "type": "dict>>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_language_params": { + "hard_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "code", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_languages": { + "post_prompt_data": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "languages", - "type": "list>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_multilingual": { + "previous_contexts": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "config", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_native_functions": { + "project_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_names", - "type": "list", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_param": { + "raw_call_log": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "key", - "type": "string", - "required": true - }, - { - "name": "value", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_params": { + "space_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "params", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_post_prompt_llm_params": { + "swaig_log": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_prompt_llm_params": { + "times": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_pronunciations": { + "total_asr_cost_factor": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "pronunciations", - "type": "list>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "update_global_data": { + "total_asr_minutes": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "data", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.auth_mixin": { - "classes": { - "AuthMixin": { - "methods": { - "validate_basic_auth": { + }, + "total_input_tokens": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "username", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_minutes": { + "params": [ { - "name": "password", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_basic_auth_credentials": { + "total_output_tokens": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_tts_chars": { + "params": [ { - "name": "include_source", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.mcp_server_mixin": { - "classes": { - "MCPServerMixin": { - "methods": { - "add_mcp_server": { + }, + "total_tts_chars_per_min": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_wire_input_tokens": { + "params": [ { - "name": "url", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_wire_input_tokens_per_minute": { + "params": [ { - "name": "headers", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_wire_output_tokens": { + "params": [ { - "name": "resources", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "total_wire_output_tokens_per_minute": { + "params": [ { - "name": "resource_vars", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.core.mixins.prompt_mixin": { - "classes": { - "PromptMixin": { + }, + "PostPromptAssistantEntry": { "methods": { - "define_contexts": { + "acoustic_latency": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "contexts", - "type": "union,any>", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_post_prompt": { + "audio_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_prompt": { + "barge_elapsed_ms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_add_section": { + "barged": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered_bullets", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "subsections", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_add_subsection": { + "content": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "parent_title", - "type": "string", - "required": true - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_add_to_section": { + "dg_decision_latency": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body_arg", - "type": "any", - "required": false, - "default": null - }, - { - "name": "body", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullet", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_has_section": { + "eos_to_push_latency": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "reset_contexts": { + "last_word_end_wall_us": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_post_prompt": { + "latency": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_prompt_text": { + "poll": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.serverless_mixin": { - "classes": { - "ServerlessMixin": { - "methods": { - "handle_serverless_request": { + }, + "role": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "context", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "mode", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.skill_mixin": { - "classes": { - "SkillMixin": { - "methods": { - "add_skill": { + }, + "speech_start_wall_us": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "skill_name", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "optional>", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "has_skill": { + "stamps_us": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "skill_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "list_skills": { + "status_pushed_wall_us": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "remove_skill": { + "text_heard_approx": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "skill_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.state_mixin": { - "classes": { - "StateMixin": { - "methods": { - "validate_tool_token": { + }, + "text_spoken_total": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "token", - "type": "string", - "required": true - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.mixins.tool_mixin": { - "classes": { - "ToolMixin": { - "methods": { - "define_tool": { + }, + "timestamp": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "description", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "parameters", - "type": "dict", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "handler", - "type": "callable,any>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "secure", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "fillers", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "wait_file", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "wait_file_loops", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "webhook_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "required", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "is_typed_handler", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "swaig_fields", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "tool_calls": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_function_call": { + "turn_decided_wall_us": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true - }, - { - "name": "args", - "type": "dict", - "required": true - }, - { - "name": "raw_data", - "type": "optional>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_swaig_function": { + "utterance_latency": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "func_def", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.core.mixins.web_mixin": { - "classes": { - "WebMixin": { + }, + "PostPromptData": { "methods": { - "as_router": { + "parsed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "class:signalwire.core.web.HostAppRouter" + "returns": "any" }, - "enable_debug_routes": { + "raw": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_app": { + "substituted": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "manual_set_proxy_url": { + } + } + }, + "PostPromptEntity": { + "methods": { + "type": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "proxy_url", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_request": { + "valid": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "request_data", - "type": "optional>", - "required": false, - "default": null - }, - { - "name": "callback_path", - "type": "optional", - "required": false, - "default": null - }, - { - "name": "request", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_swml_request": { + "value": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_request_data", - "type": "any", - "required": false, - "default": null - }, - { - "name": "_callback_path", - "type": "any", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "PostPromptEot": { + "methods": { + "basis": { + "params": [ { - "name": "request", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_routing_callback": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "PostPromptStampsUs": { + "methods": { + "first_audio": { + "params": [ { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "run": { + "first_token": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "context", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "force_mode", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "host", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "serve": { + "first_utterance": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "last_word_end": { + "params": [ { - "name": "host", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "request_detect": { + "params": [ { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_dynamic_config_callback": { + "speech_start": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "status_pushed": { + "params": [ { - "name": "callback", - "type": "callable,dict,dict,class:signalwire.core.agent_base.AgentBase>,void>", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "suspected_end": { + "params": [ { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "setup_graceful_shutdown": { + "turn_decided": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.core.pom_builder": { - "classes": { - "PomBuilder": { + }, + "PostPromptSwaigLogEntry": { "methods": { - "__init__": { + "active_count": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "add_section": { + "command_arg": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "numbered_bullets", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "subsections", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_subsection": { + "command_name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "parent_title", - "type": "string", - "required": true - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_to_section": { + "delayed_post_response": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "bullet", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "epoch_time": { + "params": [ { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_sections": { + "mcp_error": { "params": [ { - "name": "sections", - "type": "list>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_section": { + "mcp_response": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "has_section": { + "mcp_tool": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "mcp_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_markdown": { + "native": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_xml": { + "post_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_dict": { + "post_response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_json": { + "url": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.core.post_prompt_generated": { - "classes": { - "PostPrompt": { + }, + "PostPromptSystemEntry": { "methods": { - "SWMLCall": { + "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "SWMLVars": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, + "timestamp": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "PostPromptSystemLogEntry": { + "methods": { "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_end_date": { + "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_id_tag": { + "content_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_session_id": { + "context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_start_date": { + "lang": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "app_name": { + "metadata": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_answer_date": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_end_date": { + "step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_ended_by": { + "step_index": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_id": { + "timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_log": { + "tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "call_start_date": { + } + } + }, + "PostPromptThinkingEntry": { + "methods": { + "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_timeline": { + "lang": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "caller_id_name": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "caller_id_number": { + "timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "content_disposition": { + "tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "content_type": { + } + } + }, + "PostPromptTimesEntry": { + "methods": { + "answer_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conversation_id": { + "avg_tps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conversation_summary": { + "response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conversation_type": { + "response_word_count": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "global_data": { + "token_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hard_timeout": { + "tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_prompt_data": { + "tps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "previous_contexts": { + } + } + }, + "PostPromptTiming": { + "methods": { + "commit_latency_ms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "project_id": { + "hold_ms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "raw_call_log": { + "segments": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "space_id": { + "walkbacks": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "swaig_log": { + } + } + }, + "PostPromptToolEntry": { + "methods": { + "audio_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "times": { + "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_asr_cost_factor": { + "deprecation_warning": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_asr_minutes": { + "distilled": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_input_tokens": { + "end_timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_minutes": { + "execution_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_output_tokens": { + "function_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_tts_chars": { + "function_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_tts_chars_per_min": { + "latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_wire_input_tokens": { + "original_result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_wire_input_tokens_per_minute": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_wire_output_tokens": { + "start_timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "total_wire_output_tokens_per_minute": { + "timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PostPromptAssistantEntry": { - "methods": { - "acoustic_latency": { + }, + "tool_call_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "audio_latency": { + "utterance_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "barge_elapsed_ms": { + } + } + }, + "PostPromptUserEntry": { + "methods": { + "barge_count": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "barged": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -6886,107 +10989,107 @@ "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "dg_decision_latency": { + "content_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "eos_to_push_latency": { + "end_timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "last_word_end_wall_us": { + "entity": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "latency": { + "eot": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "poll": { + "merge_count": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "merged": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_start_wall_us": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stamps_us": { + "speaker": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_pushed_wall_us": { + "speaking_to_final_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text_heard_approx": { + "speaking_to_turn_detection": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text_spoken_total": { + "start_timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -6994,911 +11097,1148 @@ "timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tool_calls": { + "timing": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "turn_decided_wall_us": { + "turn_detection_to_final_event": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.security.security_utils": { + "functions": { + "filter_sensitive_headers": { + "params": [ + { + "name": "headers", + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "is_valid_hostname": { + "params": [ + { + "name": "host", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "redact_url": { + "params": [ + { + "name": "url", + "required": true, + "type": "any" + } + ], + "returns": "any" + } + } + }, + "signalwire.core.security.session_manager": { + "classes": { + "SessionManager": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": 900, + "kind": "keyword", + "name": "token_expiry_secs", + "required": false, + "type": "int" + }, + { + "default": null, + "kind": "keyword", + "name": "secret_key", + "required": false, + "type": "optional" } ], - "returns": "any" + "returns": "void" }, - "utterance_latency": { + "activate_session": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptData": { - "methods": { - "parsed": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "raw": { + "create_session": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "call_id", + "required": false, + "type": "optional" } ], "returns": "any" }, - "substituted": { + "create_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "any" + }, + { + "name": "call_id", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "PostPromptEntity": { - "methods": { - "type": { + }, + "create_tool_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "string" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "valid": { + "debug_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "token", + "required": true, + "type": "string" } ], "returns": "any" }, - "value": { + "end_session": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" - } - } - }, - "PostPromptEot": { - "methods": { - "basis": { + }, + "generate_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "string" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "confidence": { + "get_session_metadata": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" - } - } - }, - "PostPromptStampsUs": { - "methods": { - "first_audio": { + }, + "secret_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "first_token": { + "set_session_metadata": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "call_id", + "required": true, + "type": "string" + }, + { + "name": "key", + "required": true, + "type": "string" + }, + { + "name": "value", + "required": true, + "type": "any" } ], "returns": "any" }, - "first_utterance": { + "token_expiry_secs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "last_word_end": { + "validate_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "string" + }, + { + "name": "token", + "required": true, + "type": "string" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "request_detect": { + "validate_tool_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "function_name", + "required": true, + "type": "string" + }, + { + "name": "token", + "required": true, + "type": "string" + }, + { + "name": "call_id", + "required": true, + "type": "string" } ], "returns": "any" - }, - "speech_start": { + } + } + } + } + }, + "signalwire.core.security.webhook_middleware": { + "classes": { + "WebhookMiddleware": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "app", + "required": true, + "type": "any" + }, + { + "kind": "keyword", + "name": "signing_key", + "required": true, + "type": "any" + }, + { + "default": false, + "kind": "keyword", + "name": "trust_proxy", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "paths", + "required": false, + "type": "any" + }, + { + "default": [ + "POST" + ], + "kind": "keyword", + "name": "methods", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "status_pushed": { + "call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "env", + "required": true, + "type": "any" } ], "returns": "any" + } + } + } + }, + "functions": { + "validate": { + "params": [ + { + "name": "method", + "required": true, + "type": "string" + }, + { + "name": "url", + "required": true, + "type": "string" + }, + { + "name": "headers", + "required": true, + "type": "dict" + }, + { + "name": "body", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "signing_key", + "required": true, + "type": "string" + } + ], + "returns": "any" + } + } + }, + "signalwire.core.security.webhook_validator": { + "functions": { + "validate_request": { + "params": [ + { + "name": "signing_key", + "required": true, + "type": "string" + }, + { + "name": "signature", + "required": true, + "type": "string" + }, + { + "name": "url", + "required": true, + "type": "string" + }, + { + "name": "params_or_raw_body", + "required": true, + "type": "optional>,list>>>" + } + ], + "returns": "any" + }, + "validate_webhook_signature": { + "params": [ + { + "name": "signing_key", + "required": true, + "type": "string" }, - "suspected_end": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" + { + "name": "signature", + "required": true, + "type": "string" }, - "turn_decided": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" + { + "name": "url", + "required": true, + "type": "string" + }, + { + "name": "raw_body", + "required": true, + "type": "string" } - } - }, - "PostPromptSwaigLogEntry": { + ], + "returns": "any" + } + } + }, + "signalwire.core.security_config": { + "classes": { + "SecurityConfig": { "methods": { - "active_count": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "command_arg": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "command_name": { - "params": [ + "default": null, + "kind": "keyword", + "name": "config_file", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "service_name", + "required": false, + "type": "optional" } ], - "returns": "any" + "returns": "void" }, - "delayed_post_response": { + "allowed_hosts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "epoch_time": { + "basic_auth_password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "mcp_error": { + "basic_auth_user": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "mcp_response": { + "cors_origins": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "mcp_tool": { + "domain": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "mcp_url": { + "get_basic_auth": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "native": { + "get_cors_config": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_data": { + "get_security_headers": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "post_response": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": false, + "kind": "keyword", + "name": "is_https", + "required": false, + "type": "bool" } ], "returns": "any" }, - "url": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptSystemEntry": { - "methods": { - "content": { + "get_ssl_context_kwargs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "get_url_scheme": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timestamp": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptSystemLogEntry": { - "methods": { - "action": { + "hsts_max_age": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "content": { + "load_from_env": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "content_type": { + "log_config": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "context": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "service_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "lang": { + "max_request_size": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "metadata": { + "rate_limit": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "request_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "step": { + "should_allow_host": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "step_index": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "host", + "required": true, + "type": "string" } ], "returns": "any" }, - "timestamp": { + "ssl_cert_path": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tokens": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptThinkingEntry": { - "methods": { - "content": { + "ssl_enabled": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "lang": { + "ssl_key_path": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "ssl_verify_mode": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timestamp": { + "use_hsts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tokens": { + "validate_ssl_config": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "PostPromptTimesEntry": { + } + } + }, + "signalwire.core.skill_base": { + "classes": { + "SkillBase": { "methods": { - "answer_time": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "avg_tps": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "response": { - "params": [ + "default": null, + "name": "agent", + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" + }, { - "name": "self", - "kind": "self" + "default": null, + "name": "params", + "required": false, + "type": "optional>" } ], - "returns": "any" + "returns": "void" }, - "response_word_count": { + "agent": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "token_time": { + "cleanup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tokens": { + "define_tool": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "tps": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptTiming": { - "methods": { - "commit_latency_ms": { - "params": [ + "kind": "keyword", + "name": "name", + "required": true, + "type": "any" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "hold_ms": { - "params": [ + "kind": "keyword", + "name": "description", + "required": true, + "type": "any" + }, + { + "default": {}, + "kind": "keyword", + "name": "parameters", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "handler", + "required": false, + "type": "any" } ], "returns": "any" }, - "segments": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "walkbacks": { + "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PostPromptToolEntry": { - "methods": { - "audio_latency": { + }, + "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "content": { + "get_instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "deprecation_warning": { + "get_param": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "key", + "required": true, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "env_var", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "default", + "required": false, + "type": "any" } ], "returns": "any" }, - "distilled": { + "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_timestamp": { + "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "execution_latency": { + "get_skill_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "raw_data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "function_latency": { + "logger": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function_name": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "latency": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "original_result": { + "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "required_env_vars": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "start_timestamp": { + "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timestamp": { + "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tool_call_id": { + "swaig_fields": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "utterance_latency": { + "update_skill_data": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "PostPromptUserEntry": { - "methods": { - "barge_count": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "confidence": { - "params": [ + "name": "result", + "required": true, + "type": "class:signalwire.core.function_result.FunctionResult" + }, { - "name": "self", - "kind": "self" + "name": "data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "content": { + "validate_env_vars": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "content_type": { + "validate_packages": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_timestamp": { + "version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "entity": { + } + } + } + } + }, + "signalwire.core.skill_manager": { + "classes": { + "SkillManager": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "eot": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": null, + "name": "agent", + "required": false, + "type": "class:signalwire.core.agent_base.AgentBase" } ], - "returns": "any" + "returns": "void" }, - "merge_count": { + "agent": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "merged": { + "clear": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "get_skill": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "speaker": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "skill_identifier", + "required": true, + "type": "string" } ], "returns": "any" }, - "speaking_to_final_event": { + "has_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "skill_identifier", + "required": true, + "type": "string" } ], "returns": "any" }, - "speaking_to_turn_detection": { + "list_loaded_skills": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "start_timestamp": { + "load_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "key", + "required": true, + "type": "any" + }, + { + "name": "skill", + "required": true, + "type": "any" } ], "returns": "any" }, - "timestamp": { + "logger": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timing": { + "size": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "turn_detection_to_final_event": { + "unload_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "skill_identifier", + "required": true, + "type": "string" } ], "returns": "any" @@ -7907,668 +12247,588 @@ } } }, - "signalwire.core.security.security_utils": { - "functions": { - "filter_sensitive_headers": { - "params": [ - { - "name": "headers", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "is_valid_hostname": { - "params": [ - { - "name": "host", - "type": "string", - "required": true - } - ], - "returns": "any" - }, - "redact_url": { - "params": [ - { - "name": "url", - "type": "any", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.core.security.session_manager": { + "signalwire.core.swaig_function": { "classes": { - "SessionManager": { + "SWAIGFunction": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "token_expiry_secs", - "type": "int", "kind": "keyword", + "name": "name", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "handler", + "required": true, + "type": "callable,any>" + }, + { + "kind": "keyword", + "name": "description", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "parameters", + "required": false, + "type": "optional>>" + }, + { + "default": false, + "kind": "keyword", + "name": "secure", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "fillers", + "required": false, + "type": "optional>>" + }, + { + "default": null, + "kind": "keyword", + "name": "wait_file", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "wait_file_loops", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "webhook_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "required", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "is_typed_handler", "required": false, - "default": null + "type": "bool" }, { - "name": "secret_key", - "type": "optional", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "extra_swaig_fields", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "activate_session": { + "call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call_id", - "type": "string", - "required": true + "default": null, + "kind": "var_positional", + "name": "*", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "var_keyword", + "name": "**", + "required": false, + "type": "any" } ], "returns": "any" }, - "create_session": { + "description": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_id", - "type": "optional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "create_token": { + "execute": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "function_name", - "type": "any", - "required": true + "name": "args", + "required": true, + "type": "dict" }, { - "name": "call_id", - "type": "any", - "required": true + "default": null, + "name": "raw_data", + "required": false, + "type": "optional" } ], "returns": "any" }, - "create_tool_token": { + "extra_swaig_fields": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "debug_token": { + "fillers": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "token", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_session": { + "handler": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "generate_token": { + "is_external": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_session_metadata": { + "is_typed_handler": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_session_metadata": { + "name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_id", - "type": "string", - "required": true - }, - { - "name": "key", - "type": "string", - "required": true - }, - { - "name": "value", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_token": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "token", - "type": "string", - "required": true - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_tool_token": { + "required": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "function_name", - "type": "string", - "required": true - }, - { - "name": "token", - "type": "string", - "required": true - }, - { - "name": "call_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.security.webhook_middleware": { - "classes": { - "WebhookMiddleware": { - "methods": { - "__init__": { + }, + "secure": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "to_swaig": { + "params": [ { - "name": "app", - "type": "any", - "required": true + "kind": "self", + "name": "self" }, { - "name": "signing_key", - "type": "any", "kind": "keyword", - "required": true + "name": "base_url", + "required": true, + "type": "string" }, { - "name": "trust_proxy", - "type": "any", + "default": null, "kind": "keyword", + "name": "token", "required": false, - "default": null + "type": "optional" }, { - "name": "paths", - "type": "any", + "default": null, "kind": "keyword", + "name": "call_id", "required": false, - "default": null + "type": "optional" }, { - "name": "methods", - "type": "any", + "default": true, "kind": "keyword", + "name": "include_auth", "required": false, - "default": null + "type": "bool" } ], - "returns": "void" + "returns": "any" }, - "call": { + "validate_args": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "env", - "type": "any", - "required": true + "name": "args", + "required": true, + "type": "dict" } ], "returns": "any" - } - } - } - }, - "functions": { - "validate": { - "params": [ - { - "name": "method", - "type": "string", - "required": true - }, - { - "name": "url", - "type": "string", - "required": true }, - { - "name": "headers", - "type": "dict", - "required": true + "wait_file": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" }, - { - "name": "body", - "type": "string", - "required": true + "wait_file_loops": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" }, - { - "name": "signing_key", - "type": "string", - "kind": "keyword", - "required": true + "webhook_url": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" } - ], - "returns": "any" + } } } }, - "signalwire.core.security.webhook_validator": { - "functions": { - "validate_request": { - "params": [ - { - "name": "signing_key", - "type": "string", - "required": true - }, - { - "name": "signature", - "type": "string", - "required": true + "signalwire.core.swaig_request_generated": { + "classes": { + "SwaigArgument": { + "methods": { + "parsed": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" }, - { - "name": "url", - "type": "string", - "required": true + "raw": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" }, - { - "name": "params_or_raw_body", - "type": "optional>,list>>>", - "required": true + "substituted": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" } - ], - "returns": "any" + } }, - "validate_webhook_signature": { - "params": [ - { - "name": "signing_key", - "type": "string", - "required": true - }, - { - "name": "signature", - "type": "string", - "required": true - }, - { - "name": "url", - "type": "string", - "required": true - }, - { - "name": "raw_body", - "type": "string", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.core.security_config": { - "classes": { - "SecurityConfig": { + "SwaigRequest": { "methods": { - "__init__": { + "ai_session_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "config_file", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "app_name": { + "params": [ { - "name": "service_name", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "allowed_hosts": { + "args": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "basic_auth_password": { + "argument": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "basic_auth_user": { + "argument_desc": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "cors_origins": { + "call_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "domain": { + "call_log": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_basic_auth": { + "caller_id_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_cors_config": { + "caller_id_num": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_security_headers": { + "channel_active": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "is_https", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_ssl_context_kwargs": { + "channel_offhook": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_url_scheme": { + "channel_ready": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hsts_max_age": { + "content_disposition": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "load_from_env": { + "content_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "log_config": { + "conversation_id": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "description": { + "params": [ { - "name": "service_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_request_size": { + "error_reason": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "rate_limit": { + "fatal_error": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "request_timeout": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "should_allow_host": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "input": { + "params": [ { - "name": "host", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ssl_cert_path": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ssl_enabled": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ssl_key_path": { + "project_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ssl_verify_mode": { + "raw_call_log": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "use_hsts": { + "space_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_ssl_config": { + "version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -8577,301 +12837,622 @@ } } }, - "signalwire.core.skill_base": { + "signalwire.core.swml_builder": { "classes": { - "SkillBase": { + "SWMLBuilder": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "agent", - "type": "class:signalwire.core.agent_base.AgentBase", + "name": "service", + "required": true, + "type": "class:signalwire.core.swml_service.SWMLService" + } + ], + "returns": "void" + }, + "add_section": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "section_name", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "ai": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "prompt_text", "required": false, - "default": null + "type": "optional" }, { - "name": "params", - "type": "optional>", + "default": null, + "kind": "keyword", + "name": "prompt_pom", + "required": false, + "type": "optional>>" + }, + { + "default": null, + "kind": "keyword", + "name": "post_prompt", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "post_prompt_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "swaig", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], - "returns": "void" + "returns": "any" }, - "agent": { + "answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "max_duration", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "codecs", + "required": false, + "type": "optional" } ], "returns": "any" }, - "cleanup": { + "build": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "define_tool": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "any", + "default": null, + "kind": "keyword", + "name": "reason", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "method_missing": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "method_name", + "required": true, + "type": "any" + }, + { + "default": null, + "kind": "var_positional", + "name": "args", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "play": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "urls", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "say_voice", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "say_language", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "say_gender", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", - "required": true + "name": "auto_answer", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "render": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "reset": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "say": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "text", + "required": true, + "type": "string" }, { - "name": "description", - "type": "any", + "default": null, "kind": "keyword", - "required": true + "name": "voice", + "required": false, + "type": "optional" }, { - "name": "parameters", - "type": "any", + "default": null, "kind": "keyword", + "name": "language", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "gender", "required": false, - "default": null + "type": "optional" }, { - "name": "handler", - "type": "any", + "default": null, "kind": "keyword", + "name": "volume", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "description": { + "service": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "get_global_data": { + } + } + } + } + }, + "signalwire.core.swml_handler": { + "classes": { + "AIVerbHandler": { + "methods": { + "build_config": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "get_hints": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "get_param": { - "params": [ + "default": null, + "kind": "keyword", + "name": "prompt_text", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "prompt_pom", + "required": false, + "type": "optional>>" }, { - "name": "key", - "type": "any", - "required": true + "default": null, + "kind": "keyword", + "name": "contexts", + "required": false, + "type": "optional>" }, { - "name": "env_var", - "type": "any", + "default": null, "kind": "keyword", + "name": "post_prompt", "required": false, - "default": null + "type": "optional" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "post_prompt_url", "required": false, - "default": null - } - ], - "returns": "any" - }, - "get_parameter_schema": { - "params": [ + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "swaig", + "required": false, + "type": "optional>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "get_prompt_sections": { + "get_verb_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_skill_data": { + "validate_config": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "raw_data", - "type": "dict", - "required": true + "name": "config", + "required": true, + "type": "any" } ], "returns": "any" - }, - "logger": { + } + } + }, + "SWMLVerbHandler": { + "methods": { + "build_config": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "name": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "_kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "params": { + "get_verb_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_tools": { + "validate_config": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "_config", + "required": true, + "type": "any" } ], "returns": "any" - }, - "required_env_vars": { + } + } + }, + "VerbHandlerRegistry": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "any" + "returns": "void" }, - "setup": { + "get_handler": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "supports_multiple_instances": { + "has_handler": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "swaig_fields": { + "register_handler": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "handler", + "required": true, + "type": "class:signalwire.core.swml_handler.SWMLVerbHandler" } ], "returns": "any" - }, - "update_skill_data": { + } + } + } + } + }, + "signalwire.core.swml_renderer": { + "classes": { + "SwmlRenderer": { + "methods": { + "render_function_response_swml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "response_text", + "required": true, + "type": "string" }, { - "name": "result", - "type": "class:signalwire.core.function_result.FunctionResult", - "required": true + "kind": "keyword", + "name": "service", + "required": true, + "type": "class:signalwire.core.swml_service.SWMLService" }, { - "name": "data", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "validate_env_vars": { - "params": [ + "default": null, + "kind": "keyword", + "name": "actions", + "required": false, + "type": "optional>>" + }, { - "name": "self", - "kind": "self" + "default": "json", + "kind": "keyword", + "name": "format", + "required": false, + "type": "string" } ], "returns": "any" }, - "validate_packages": { + "render_swml": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "version": { - "params": [ + "kind": "keyword", + "name": "prompt", + "required": true, + "type": "union>>" + }, + { + "kind": "keyword", + "name": "service", + "required": true, + "type": "class:signalwire.core.swml_service.SWMLService" + }, + { + "default": null, + "kind": "keyword", + "name": "post_prompt", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "post_prompt_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "swaig_functions", + "required": false, + "type": "optional>>" + }, + { + "default": null, + "kind": "keyword", + "name": "startup_hook_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "hangup_hook_url", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "prompt_is_pom", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "params", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "add_answer", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "record_call", + "required": false, + "type": "bool" + }, + { + "default": "mp4", + "kind": "keyword", + "name": "record_format", + "required": false, + "type": "string" + }, + { + "default": true, + "kind": "keyword", + "name": "record_stereo", + "required": false, + "type": "bool" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "get_instance_key": { - "params": [ + "default": "json", + "kind": "keyword", + "name": "format", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "default_webhook_url", + "required": false, + "type": "optional" } ], "returns": "any" @@ -8880,127 +13461,70 @@ } } }, - "signalwire.core.skill_manager": { + "signalwire.core.swml_schema": { "classes": { - "SkillManager": { + "Schema": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "agent", - "type": "class:signalwire.core.agent_base.AgentBase", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "void" }, - "agent": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "clear": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "logger": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "size": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "load_skill": { + "get_verb": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "key", - "type": "any", - "required": true + "kind": "self", + "name": "self" }, { - "name": "skill", - "type": "any", - "required": true + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "unload_skill": { + "valid_verb": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "skill_identifier", - "type": "string", - "required": true + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "get_skill": { + "verb_count": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "skill_identifier", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "has_skill": { + "verb_names": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "skill_identifier", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "list_loaded_skills": { + "verbs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -9009,3744 +13533,3353 @@ } } }, - "signalwire.core.swaig_function": { + "signalwire.core.swml_service": { "classes": { - "SWAIGFunction": { + "SWMLService": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "handler", - "type": "callable,any>", - "kind": "keyword", - "required": true - }, - { - "name": "description", - "type": "string", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "parameters", - "type": "optional>>", "kind": "keyword", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" }, { - "name": "secure", - "type": "bool", + "default": "/", "kind": "keyword", + "name": "route", "required": false, - "default": null + "type": "string" }, { - "name": "fillers", - "type": "optional>>", + "default": "0.0.0.0", "kind": "keyword", + "name": "host", "required": false, - "default": null + "type": "string" }, { - "name": "wait_file", - "type": "optional", + "default": null, "kind": "keyword", + "name": "port", "required": false, - "default": null + "type": "optional" }, { - "name": "wait_file_loops", - "type": "optional", + "default": null, "kind": "keyword", + "name": "basic_auth", "required": false, - "default": null + "type": "optional>" }, { - "name": "webhook_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "schema_path", "required": false, - "default": null + "type": "optional" }, { - "name": "required", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "config_file", "required": false, - "default": null + "type": "optional" }, { - "name": "is_typed_handler", - "type": "bool", + "default": true, "kind": "keyword", + "name": "schema_validation", "required": false, - "default": null - }, - { - "name": "extra_swaig_fields", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "type": "bool" } ], "returns": "void" }, - "call": { + "add_section": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "*", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "**", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "section_name", + "required": true, + "type": "string" } ], "returns": "any" }, - "description": { + "add_verb": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "verb_name", + "required": true, + "type": "string" + }, + { + "name": "config", + "required": true, + "type": "union,int>" } ], "returns": "any" }, - "execute": { + "add_verb_to_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true + "name": "section_name", + "required": true, + "type": "string" }, { - "name": "raw_data", - "type": "optional", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "extra_swaig_fields": { - "params": [ + "name": "verb_name", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "name": "config", + "required": true, + "type": "union,int>" } ], "returns": "any" }, - "fillers": { + "all_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "handler": { + "as_router": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "any" + "returns": "class:signalwire.core.web.HostAppRouter" }, - "is_external": { + "basic_auth_credentials_with_source": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "is_typed_handler": { + "config_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "define_tool": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "name", + "required": true, + "type": "any" + }, + { + "kind": "keyword", + "name": "description", + "required": true, + "type": "any" + }, + { + "default": {}, + "kind": "keyword", + "name": "parameters", + "required": false, + "type": "any" + }, + { + "default": true, + "kind": "keyword", + "name": "secure", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "handler", + "required": false, + "type": "any" } ], "returns": "any" }, - "parameters": { + "define_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "required": { + "document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "secure": { + "domain": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_swaig": { + "execute_verb": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "base_url", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "token", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "verb_name", + "required": true, + "type": "any" }, { - "name": "call_id", - "type": "optional", - "kind": "keyword", + "default": [], + "name": "args", "required": false, - "default": null + "type": "any" }, { - "name": "include_auth", - "type": "bool", - "kind": "keyword", + "default": {}, + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "validate_args": { + "extract_sip_username": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "args", - "type": "dict", - "required": true + "name": "request_body", + "required": true, + "type": "dict" } ], "returns": "any" }, - "wait_file": { + "full_validation_enabled": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_file_loops": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "webhook_url": { + "get_all_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swaig_request_generated": { - "classes": { - "SwaigArgument": { - "methods": { - "parsed": { + }, + "get_basic_auth_credentials": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": false, + "kind": "keyword", + "name": "include_source", + "required": false, + "type": "bool" } ], "returns": "any" }, - "raw": { + "get_basic_auth_credentials_with_source": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "substituted": { + "get_document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SwaigRequest": { - "methods": { - "ai_session_id": { + }, + "get_full_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": false, + "kind": "keyword", + "name": "include_auth", + "required": false, + "type": "any" } ], "returns": "any" }, - "app_name": { + "get_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "args": { + "handle_additional_route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "_sub_path", + "required": true, + "type": "any" + }, + { + "name": "_request_data", + "required": true, + "type": "any" + }, + { + "name": "_env", + "required": true, + "type": "any" } ], "returns": "any" }, - "argument": { + "handle_request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "method", + "required": true, + "type": "string" + }, + { + "name": "url", + "required": true, + "type": "string" + }, + { + "name": "headers", + "required": true, + "type": "dict" + }, + { + "default": null, + "name": "body", + "required": false, + "type": "optional>" } ], "returns": "any" }, - "argument_desc": { + "has_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "call_id": { + "host": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_log": { + "list_tool_names": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "caller_id_name": { + "manual_set_proxy_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "proxy_url", + "required": true, + "type": "string" } ], "returns": "any" }, - "caller_id_num": { + "method_missing": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "method_name", + "required": true, + "type": "any" + }, + { + "default": null, + "kind": "var_positional", + "name": "args", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "channel_active": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "channel_offhook": { + "on_function_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "any" + }, + { + "name": "args", + "required": true, + "type": "any" + }, + { + "default": null, + "name": "raw_data", + "required": false, + "type": "any" } ], "returns": "any" }, - "channel_ready": { + "on_request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "request_data", + "required": false, + "type": "optional>" + }, + { + "default": null, + "name": "callback_path", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "request", + "required": false, + "type": "any" } ], "returns": "any" }, - "content_disposition": { + "on_swml_request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "_request_data", + "required": false, + "type": "any" + }, + { + "default": null, + "name": "_callback_path", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "request", + "required": false, + "type": "optional" } ], "returns": "any" }, - "content_type": { + "port": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conversation_id": { + "rack_app": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "register_routing_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "callback_fn", + "required": true, + "type": "callable,dict>,optional>" + }, + { + "default": "/sip", + "name": "path", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "error_reason": { + "register_swaig_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "func_def", + "required": true, + "type": "any" } ], "returns": "any" }, - "fatal_error": { + "register_verb_handler": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "handler", + "required": true, + "type": "class:signalwire.core.swml_handler.SWMLVerbHandler" } ], "returns": "any" }, - "function": { + "remove_function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "name", + "required": true, + "type": "any" } ], "returns": "any" }, - "global_data": { + "render": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "input": { + "render_document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "render_main_swml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "_request_data", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "request", + "required": false, + "type": "any" } ], "returns": "any" }, - "meta_data_token": { + "render_pretty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "project_id": { + "reset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "raw_call_log": { + "reset_document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "space_id": { + "route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "version": { + "schema_path": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swml_builder": { - "classes": { - "SWMLBuilder": { - "methods": { - "__init__": { + }, + "schema_utils": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "service", - "type": "class:signalwire.core.swml_service.SWMLService", - "required": true + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "add_section": { + "schema_validation": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "section_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai": { + "serve": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "prompt_text", - "type": "optional", + "default": null, "kind": "keyword", + "name": "host", "required": false, - "default": null + "type": "optional" }, { - "name": "prompt_pom", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "port", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "ssl_cert", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "ssl_key", "required": false, - "default": null + "type": "optional" }, { - "name": "swaig", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "ssl_enabled", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "domain", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "answer": { + "ssl_cert_path": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "max_duration", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "codecs", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "build": { + "ssl_enabled": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hangup": { + "ssl_key_path": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "stop": { + "params": [ { - "name": "reason", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "method_missing": { + "swaig_pre_dispatch": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "method_name", - "type": "any", - "required": true + "name": "_request_data", + "required": true, + "type": "any" }, { - "name": "args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "name": "_func_name", + "required": true, + "type": "any" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "_env", + "required": true, + "type": "any" } ], "returns": "any" }, - "play": { + "validate_basic_auth": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "urls", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "username", + "required": true, + "type": "string" }, { - "name": "say_voice", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "password", + "required": true, + "type": "string" + } + ], + "returns": "any" + }, + "verb_registry": { + "params": [ { - "name": "say_language", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.core.swml_verbs_generated": { + "classes": { + "AI": { + "methods": { + "ai": { + "params": [ { - "name": "say_gender", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "AIObject": { + "methods": { + "SWAIG": { + "params": [ { - "name": "auto_answer", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "reset": { + "hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "say": { + "languages": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "params": { + "params": [ { - "name": "voice", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "post_prompt": { + "params": [ { - "name": "language", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "post_prompt_url": { + "params": [ { - "name": "gender", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "prompt": { + "params": [ { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "service": { + "pronounce": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.core.swml_handler": { - "classes": { - "AIVerbHandler": { - "methods": { - "build_config": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "prompt_text", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "prompt_pom", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "contexts", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "post_prompt", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "post_prompt_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "swaig", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, + }, + "AIParams": { + "methods": { + "acknowledge_interruptions": { + "params": [ { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_verb_name": { + "ai_model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_config": { + "ai_name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "config", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SWMLVerbHandler": { - "methods": { - "build_config": { + }, + "ai_volume": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_verb_name": { + "app_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_config": { + "asr_diarize": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_config", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "VerbHandlerRegistry": { - "methods": { - "__init__": { + }, + "asr_smart_format": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "get_handler": { + "asr_speaker_affinity": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "verb_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "has_handler": { + "attention_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "verb_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_handler": { + "attention_timeout_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "handler", - "type": "class:signalwire.core.swml_handler.SWMLVerbHandler", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swml_renderer": { - "classes": { - "SwmlRenderer": { - "methods": { - "render_function_response_swml": { + }, + "background_file": { "params": [ { - "name": "response_text", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "service", - "type": "class:signalwire.core.swml_service.SWMLService", - "kind": "keyword", - "required": true - }, - { - "name": "actions", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "format", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_swml": { + "background_file_loops": { "params": [ { - "name": "prompt", - "type": "union>>", - "kind": "keyword", - "required": true - }, - { - "name": "service", - "type": "class:signalwire.core.swml_service.SWMLService", - "kind": "keyword", - "required": true - }, - { - "name": "post_prompt", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "post_prompt_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "swaig_functions", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "startup_hook_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "hangup_hook_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "prompt_is_pom", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "params", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "add_answer", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "record_call", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "record_format", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "record_stereo", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "format", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "default_webhook_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swml_schema": { - "classes": { - "Schema": { - "methods": { - "__init__": { + }, + "background_file_volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "get_verb": { + "barge_functions": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_verb": { + "barge_match_string": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "verb_count": { + "barge_min_words": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "verb_names": { + "conscience": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "verbs": { + "conversation_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swml_service": { - "classes": { - "SWMLService": { - "methods": { - "__init__": { + }, + "conversation_sliding_window": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "route", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "host", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "basic_auth", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "schema_path", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "convo": { + "params": [ { - "name": "config_file", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "debug": { + "params": [ { - "name": "schema_validation", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "debug_webhook_level": { + "params": [ + { + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "add_section": { + "debug_webhook_url": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "section_name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_verb": { + "digit_terminators": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "verb_name", - "type": "string", - "required": true - }, - { - "name": "config", - "type": "union,int>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_verb_to_section": { + "digit_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "section_name", - "type": "string", - "required": true - }, - { - "name": "verb_name", - "type": "string", - "required": true - }, - { - "name": "config", - "type": "union,int>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "all_functions": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "as_router": { + "eleven_labs_similarity": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], - "returns": "class:signalwire.core.web.HostAppRouter" + "returns": "any" }, - "basic_auth_credentials_with_source": { + "eleven_labs_stability": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "config_file": { + "enable_barge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "define_tool": { + "enable_inner_dialog": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "kind": "keyword", - "required": true - }, - { - "name": "description", - "type": "any", - "kind": "keyword", - "required": true - }, - { - "name": "parameters", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "secure", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "handler", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "define_tools": { + "enable_pause": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "document": { + "enable_thinking": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "execute_verb": { + "enable_turn_detection": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "verb_name", - "type": "any", - "required": true - }, - { - "name": "args", - "type": "any", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "extract_sip_username": { + "enable_vision": { "params": [ { - "name": "request_body", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "full_validation_enabled": { + "end_of_speech_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function": { + "energy_level": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_all_functions": { + "first_word_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_basic_auth_credentials": { + "function_wait_for_talking": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "include_source", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_basic_auth_credentials_with_source": { + "functions_on_no_response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_document": { + "hard_stop_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_full_url": { + "hard_stop_time": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "include_auth", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_function": { + "hold_music": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "handle_additional_route": { + "hold_on_process": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_sub_path", - "type": "any", - "required": true - }, - { - "name": "_request_data", - "type": "any", - "required": true - }, - { - "name": "_env", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "handle_request": { + "inactivity_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "method", - "type": "string", - "required": true - }, - { - "name": "url", - "type": "string", - "required": true - }, - { - "name": "headers", - "type": "dict", - "required": true - }, - { - "name": "body", - "type": "optional>", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "has_function": { + "initial_sleep_ms": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "host": { + "inner_dialog_model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "list_tool_names": { + "inner_dialog_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "manual_set_proxy_url": { + "inner_dialog_synced": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "proxy_url", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "method_missing": { + "input_poll_freq": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "method_name", - "type": "any", - "required": true - }, - { - "name": "args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "interrupt_on_noise": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_function_call": { + "interrupt_prompt": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "any", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "languages_enabled": { + "params": [ { - "name": "args", - "type": "any", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "llm_diarize_aware": { + "params": [ { - "name": "raw_data", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_request": { + "local_tz": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "max_emotion": { + "params": [ { - "name": "request_data", - "type": "optional>", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "max_response_tokens": { + "params": [ { - "name": "callback_path", - "type": "optional", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "openai_asr_engine": { + "params": [ { - "name": "request", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_swml_request": { + "outbound_attention_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "persist_global_data": { + "params": [ { - "name": "_request_data", - "type": "any", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "pom_format": { + "params": [ { - "name": "_callback_path", - "type": "any", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "save_conversation": { + "params": [ { - "name": "request", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "port": { + "speak_when_spoken_to": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "rack_app": { + "speech_event_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_routing_callback": { + "speech_gen_quick_stops": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_swaig_function": { + "speech_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "func_def", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_verb_handler": { + "start_paused": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "handler", - "type": "class:signalwire.core.swml_handler.SWMLVerbHandler", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "remove_function": { + "static_greeting": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "name", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render": { + "static_greeting_no_barge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_document": { + "summary_mode": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_main_swml": { + "swaig_allow_settings": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_request_data", - "type": "any", - "required": false, - "default": null - }, - { - "name": "request", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_pretty": { + "swaig_allow_swml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "reset_document": { + "swaig_post_conversation": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "route": { + "swaig_post_swml_vars": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "schema_path": { + "swaig_set_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "schema_utils": { + "thinking_model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "schema_validation": { + "transfer_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "serve": { + "transparent_barge": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "host", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "port", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "ssl_cert", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "ssl_key", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "ssl_enabled", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "domain", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stop": { + "transparent_barge_max_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "swaig_pre_dispatch": { + "tts_number_format": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_request_data", - "type": "any", - "required": true - }, - { - "name": "_func_name", - "type": "any", - "required": true - }, - { - "name": "_env", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "validate_basic_auth": { + "turn_detection_timeout": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "username", - "type": "string", - "required": true - }, - { - "name": "password", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "verb_registry": { + "vad_config": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "reset": { + "video_idle_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.core.swml_verbs_generated": { - "classes": { - "AI": { - "methods": { - "ai": { + }, + "video_listening_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIObject": { - "methods": { - "SWAIG": { + }, + "video_talking_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "global_data": { + "vision_model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hints": { + "wait_for_user": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "languages": { + "wake_prefix": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "params": { + } + } + }, + "AIPostPromptPom": { + "methods": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_prompt": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_prompt_url": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pronounce": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIParams": { - "methods": { - "acknowledge_interruptions": { + }, + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_model": { + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "ai_name": { + } + } + }, + "AIPostPromptText": { + "methods": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ai_volume": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "app_name": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "asr_diarize": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "asr_smart_format": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "asr_speaker_affinity": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "attention_timeout": { + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "attention_timeout_prompt": { + } + } + }, + "AIPromptPom": { + "methods": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "background_file": { + "contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "background_file_loops": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "background_file_volume": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "barge_functions": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "barge_match_string": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "barge_min_words": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conscience": { + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "conversation_id": { + } + } + }, + "AIPromptText": { + "methods": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "conversation_sliding_window": { + "contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "convo": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "debug": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "debug_webhook_level": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "debug_webhook_url": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "digit_terminators": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "digit_timeout": { + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "direction": { + } + } + }, + "AiSidecar": { + "methods": { + "ai_sidecar": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "eleven_labs_similarity": { + } + } + }, + "AiSidecarConfig": { + "methods": { + "SWAIG": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "eleven_labs_stability": { + "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_barge": { + "customer_role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_inner_dialog": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_pause": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_thinking": { + "hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_turn_detection": { + "lang": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enable_vision": { + "model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_of_speech_timeout": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "energy_level": { + "permissions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "first_word_timeout": { + "prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function_wait_for_talking": { + "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "functions_on_no_response": { + } + } + }, + "AllOfProperty": { + "methods": { + "allOf": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "hard_stop_prompt": { + } + } + }, + "AmazonBedrock": { + "methods": { + "amazon_bedrock": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "hard_stop_time": { + } + } + }, + "AmazonBedrockObject": { + "methods": { + "SWAIG": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hold_music": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hold_on_process": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "inactivity_timeout": { + "post_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "initial_sleep_ms": { + "post_prompt_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "inner_dialog_model": { + "prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "inner_dialog_prompt": { + } + } + }, + "Answer": { + "methods": { + "answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "inner_dialog_synced": { + } + } + }, + "AnyOfProperty": { + "methods": { + "anyOf": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "input_poll_freq": { + } + } + }, + "ArrayProperty": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "interrupt_on_noise": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "interrupt_prompt": { + "items": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "languages_enabled": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "llm_diarize_aware": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "local_tz": { + } + } + }, + "BedrockParams": { + "methods": { + "attention_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_emotion": { + "hard_stop_prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_response_tokens": { + "hard_stop_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "openai_asr_engine": { + "inactivity_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "outbound_attention_timeout": { + "video_idle_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "persist_global_data": { + "video_listening_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom_format": { + "video_talking_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "save_conversation": { + } + } + }, + "BedrockSWAIG": { + "methods": { + "defaults": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speak_when_spoken_to": { + "functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_event_timeout": { + "includes": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_gen_quick_stops": { + "native_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "speech_timeout": { + } + } + }, + "BooleanProperty": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "start_paused": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "static_greeting": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "static_greeting_no_barge": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "summary_mode": { + } + } + }, + "ChangeContextAction": { + "methods": { + "change_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "swaig_allow_settings": { + } + } + }, + "ChangeStepAction": { + "methods": { + "change_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "swaig_allow_swml": { + } + } + }, + "Cond": { + "methods": { + "cond": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "swaig_post_conversation": { + } + } + }, + "CondElse": { + "methods": { + "else": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "swaig_post_swml_vars": { + } + } + }, + "CondReg": { + "methods": { + "else": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "swaig_set_global_data": { + "then": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "thinking_model": { + "when": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "transfer_summary": { + } + } + }, + "Connect": { + "methods": { + "connect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "transparent_barge": { + } + } + }, + "ConnectConfig": { + "methods": { + "answer_on_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transparent_barge_max_time": { + "call_state_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tts_number_format": { + "call_state_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "turn_detection_timeout": { + "codecs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "vad_config": { + "confirm": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "video_idle_file": { + "confirm_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "video_listening_file": { + "encryption": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "video_talking_file": { + "from": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "vision_model": { + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_user": { + "max_duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wake_prefix": { + "parallel": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIPostPromptPom": { - "methods": { - "confidence": { + }, + "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "ringback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "serial": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "serial_parallel": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "session_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIPostPromptText": { - "methods": { - "confidence": { + }, + "to": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "webrtc_media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "temperature": { + } + } + }, + "ConnectDeviceParallel": { + "methods": { + "answer_on_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "call_state_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "call_state_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIPromptPom": { - "methods": { - "confidence": { + }, + "codecs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "contexts": { + "confirm": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "confirm_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "encryption": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "from": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "max_duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "parallel": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AIPromptText": { - "methods": { - "confidence": { + }, + "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "contexts": { + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "ringback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "session_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "webrtc_media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "AllOfProperty": { + "ConnectDeviceSerial": { "methods": { - "allOf": { + "answer_on_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AmazonBedrock": { - "methods": { - "amazon_bedrock": { + }, + "call_state_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AmazonBedrockObject": { - "methods": { - "SWAIG": { + }, + "call_state_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "global_data": { + "codecs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "confirm": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_prompt": { + "confirm_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post_prompt_url": { + "encryption": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt": { + "from": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Answer": { - "methods": { - "answer": { + }, + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "AnyOfProperty": { - "methods": { - "anyOf": { + }, + "max_duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ArrayProperty": { - "methods": { - "default": { + }, + "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "items": { + "ringback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "nullable": { + "serial": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "session_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "BedrockParams": { - "methods": { - "attention_timeout": { + }, + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hard_stop_prompt": { + "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hard_stop_time": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "inactivity_timeout": { + "webrtc_media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "video_idle_file": { + } + } + }, + "ConnectDeviceSerialParallel": { + "methods": { + "answer_on_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "video_listening_file": { + "call_state_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "video_talking_file": { + "call_state_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "BedrockSWAIG": { - "methods": { - "defaults": { + }, + "codecs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "functions": { + "confirm": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "includes": { + "confirm_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "native_functions": { + "encryption": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "BooleanProperty": { - "methods": { - "default": { + }, + "from": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "nullable": { + "max_duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ChangeContextAction": { - "methods": { - "change_context": { + }, + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ChangeStepAction": { - "methods": { - "change_step": { + }, + "ringback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Cond": { - "methods": { - "cond": { + }, + "serial_parallel": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "CondElse": { - "methods": { - "else": { + }, + "session_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "CondReg": { - "methods": { - "else": { + }, + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "then": { + "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "when": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Connect": { - "methods": { - "connect": { + }, + "webrtc_media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectConfig": { + "ConnectDeviceSingle": { "methods": { "answer_on_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12754,8 +16887,8 @@ "call_state_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12763,8 +16896,8 @@ "call_state_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12772,8 +16905,8 @@ "codecs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12781,8 +16914,8 @@ "confirm": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12790,8 +16923,8 @@ "confirm_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12799,8 +16932,8 @@ "encryption": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12808,8 +16941,8 @@ "from": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12817,8 +16950,8 @@ "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12826,17 +16959,8 @@ "max_duration": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "parallel": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12844,8 +16968,8 @@ "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12853,8 +16977,8 @@ "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12862,26 +16986,8 @@ "ringback": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "serial": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "serial_parallel": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12889,8 +16995,8 @@ "session_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12898,8 +17004,8 @@ "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12907,8 +17013,8 @@ "to": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12916,8 +17022,8 @@ "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12925,8 +17031,8 @@ "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -12934,636 +17040,656 @@ "webrtc_media": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "ConnectDeviceParallel": { - "methods": { - "answer_on_bridge": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "call_state_events": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "call_state_url": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "codecs": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "confirm": { + } + } + }, + "ConnectHeaders": { + "methods": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm_timeout": { + "value": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "encryption": { + } + } + }, + "ConnectSwitch": { + "methods": { + "case": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "headers": { + "variable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "max_duration": { + } + } + }, + "ConstProperty": { + "methods": { + "const": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "parallel": { + } + } + }, + "ContextPOMSteps": { + "methods": { + "end": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "password": { + "functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ringback": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "session_timeout": { + "skip_user_turn": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "step_criteria": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transfer_after_bridge": { + "valid_contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "username": { + "valid_steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "webrtc_media": { + } + } + }, + "ContextSwitchAction": { + "methods": { + "context_switch": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectDeviceSerial": { + "ContextTextSteps": { "methods": { - "answer_on_bridge": { + "end": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_state_events": { + "functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_state_url": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "codecs": { + "skip_user_turn": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm": { + "step_criteria": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm_timeout": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "encryption": { + "valid_contexts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from": { + "valid_steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "headers": { + } + } + }, + "Contexts": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "max_duration": { + } + } + }, + "ContextsPOMObject": { + "methods": { + "enter_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "password": { + "exit_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "isolated": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ringback": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "serial": { + "steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "session_timeout": { + } + } + }, + "ContextsTextObject": { + "methods": { + "enter_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "exit_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transfer_after_bridge": { + "isolated": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "username": { + "steps": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "webrtc_media": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectDeviceSerialParallel": { + "ConversationMessage": { "methods": { - "answer_on_bridge": { + "content": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_state_events": { + "lang": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_state_url": { + "role": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "codecs": { + } + } + }, + "DataMap": { + "methods": { + "expressions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm": { + "output": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm_timeout": { + "webhooks": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "encryption": { + } + } + }, + "Denoise": { + "methods": { + "denoise": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "from": { + } + } + }, + "DetectMachine": { + "methods": { + "detect_machine": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "headers": { + } + } + }, + "DetectMachineConfig": { + "methods": { + "detect_message_end": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_duration": { + "detectors": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "password": { + "end_silence_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "initial_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ringback": { + "machine_ready_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "serial_parallel": { + "machine_voice_threshold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "session_timeout": { + "machine_words_threshold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transfer_after_bridge": { + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "username": { + "tone": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "webrtc_media": { + "wait": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectDeviceSingle": { + "EnterQueue": { "methods": { - "answer_on_bridge": { + "enter_queue": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "call_state_events": { + } + } + }, + "EnterQueueObject": { + "methods": { + "queue_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_state_url": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "codecs": { + "transfer_after_bridge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm": { + "wait_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "confirm_timeout": { + "wait_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "encryption": { + } + } + }, + "Execute": { + "methods": { + "execute": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "from": { + } + } + }, + "ExecuteConfig": { + "methods": { + "dest": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "headers": { + "meta": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_duration": { + "on_return": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "password": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -13571,896 +17697,931 @@ "result": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "ringback": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "session_timeout": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "timeout": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "to": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "transfer_after_bridge": { + } + } + }, + "ExecuteSwitch": { + "methods": { + "case": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "username": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "webrtc_media": { + "variable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectHeaders": { + "Expression": { "methods": { - "name": { + "output": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "value": { + "pattern": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "string": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectSwitch": { + "FunctionParameters": { "methods": { - "case": { + "properties": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "default": { + "required": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "variable": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConstProperty": { + "Goto": { "methods": { - "const": { + "goto": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ContextPOMSteps": { + "GotoConfig": { "methods": { - "end": { + "label": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "functions": { + "max": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "when": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "HangUpHookSWAIGFunction": { + "methods": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "argument": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "skip_user_turn": { + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "step_criteria": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_contexts": { + "fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_steps": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ContextSwitchAction": { - "methods": { - "context_switch": { + }, + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ContextTextSteps": { - "methods": { - "end": { + }, + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "functions": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "purpose": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "skip_user_turn": { + "skip_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "step_criteria": { + "wait_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "wait_file_loops": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_contexts": { + "wait_for_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_steps": { + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Contexts": { + "Hangup": { "methods": { - "default": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ContextsPOMObject": { + "HangupAction": { "methods": { - "enter_fillers": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "exit_fillers": { + } + } + }, + "Hint": { + "methods": { + "hint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "isolated": { + "ignore_case": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "pattern": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "steps": { + "replace": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ContextsTextObject": { + "HoldAction": { "methods": { - "enter_fillers": { + "hold": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "InjectAction": { + "methods": { + "inject": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "IntegerProperty": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "exit_fillers": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "isolated": { + "enum": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "steps": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConversationMessage": { + "JoinConference": { "methods": { - "content": { + "join_conference": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "lang": { + } + } + }, + "JoinConferenceObject": { + "methods": { + "beep": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "role": { + "coach": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "DataMap": { - "methods": { - "expressions": { + }, + "end_on_exit": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "output": { + "max_participants": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "webhooks": { + "muted": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Denoise": { - "methods": { - "denoise": { + }, + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "DetectMachine": { - "methods": { - "detect_machine": { + }, + "record": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "DetectMachineConfig": { - "methods": { - "detect_message_end": { + }, + "recording_status_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "detectors": { + "recording_status_callback_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_silence_timeout": { + "recording_status_callback_method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "initial_timeout": { + "region": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "machine_ready_timeout": { + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "machine_voice_threshold": { + "start_on_enter": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "machine_words_threshold": { + "status_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "status_callback_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "status_callback_method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tone": { + "trim": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait": { + "wait_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "EnterQueue": { + "JoinRoom": { "methods": { - "enter_queue": { + "join_room": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "EnterQueueObject": { + "JoinRoomConfig": { "methods": { - "queue_name": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "Label": { + "methods": { + "label": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "LanguageParams": { + "methods": { + "similarity": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "stability": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "LanguagesWithFillers": { + "methods": { + "code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transfer_after_bridge": { + "emotion": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_time": { + "engine": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_url": { + "function_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Execute": { - "methods": { - "execute": { + }, + "model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ExecuteConfig": { - "methods": { - "dest": { + }, + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_return": { + "speech_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "speed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ExecuteSwitch": { + "LanguagesWithSoloFillers": { "methods": { - "case": { + "code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "default": { + "emotion": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "variable": { + "engine": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Expression": { - "methods": { - "output": { + }, + "fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pattern": { + "model": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "string": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "FunctionParameters": { - "methods": { - "properties": { + }, + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "required": { + "speed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Goto": { + "LiveTranscribe": { "methods": { - "goto": { + "live_transcribe": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "GotoConfig": { + "LiveTranscribeConfig": { "methods": { - "label": { + "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "max": { + } + } + }, + "LiveTranslate": { + "methods": { + "live_translate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "when": { + } + } + }, + "LiveTranslateConfig": { + "methods": { + "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "HangUpHookSWAIGFunction": { + "NullProperty": { "methods": { - "active": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "argument": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "data_map": { + } + } + }, + "NumberProperty": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -14468,658 +18629,584 @@ "description": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "fillers": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "function": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "enum": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "purpose": { + } + } + }, + "ObjectProperty": { + "methods": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "skip_fillers": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_file": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_file_loops": { + "properties": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_fillers": { + "required": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "web_hook_url": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Hangup": { + "OmitPropertiesBedrockPostPomptTextOmittedPromptProps": { "methods": { - "hangup": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "HangupAction": { - "methods": { - "hangup": { + }, + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Hint": { - "methods": { - "hint": { + }, + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "ignore_case": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pattern": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "replace": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "HoldAction": { - "methods": { - "hold": { + }, + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "InjectAction": { + "OmitPropertiesBedrockPostPromptPomOmittedPromptProps": { "methods": { - "inject": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "IntegerProperty": { - "methods": { - "default": { + }, + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enum": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "nullable": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "JoinConference": { - "methods": { - "join_conference": { + }, + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "JoinConferenceObject": { + "OmitPropertiesBedrockPromptPomOmittedPromptProps": { "methods": { - "beep": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "coach": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "end_on_exit": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "max_participants": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "muted": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "record": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "recording_status_callback": { + "pom": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "recording_status_callback_event": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "recording_status_callback_method": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "region": { + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "voice_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "start_on_enter": { + } + } + }, + "OmitPropertiesBedrockPromptTextOmittedPromptProps": { + "methods": { + "confidence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_callback": { + "frequency_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_callback_event": { + "max_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_callback_method": { + "presence_penalty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "trim": { + "temperature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_url": { + "text": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "JoinRoom": { - "methods": { - "join_room": { + }, + "top_p": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "JoinRoomConfig": { - "methods": { - "name": { + }, + "voice_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Label": { + "OneOfProperty": { "methods": { - "label": { + "oneOf": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "LanguageParams": { + "Output": { "methods": { - "similarity": { + "action": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stability": { + "response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "LanguagesWithFillers": { + "Pay": { "methods": { - "code": { + "pay": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "emotion": { + } + } + }, + "PayConfig": { + "methods": { + "charge_amount": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "engine": { + "currency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function_fillers": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "model": { + "input": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "max_attempts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_fillers": { + "min_postal_code_length": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speed": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "voice": { + "payment_connector_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "LanguagesWithSoloFillers": { - "methods": { - "code": { + }, + "payment_method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "emotion": { + "postal_code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "engine": { + "prompts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "fillers": { + "security_code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "model": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "token_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speed": { + "valid_card_types": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -15127,73 +19214,65 @@ "voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "LiveTranscribe": { + "PayParameters": { "methods": { - "live_transcribe": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "LiveTranscribeConfig": { - "methods": { - "action": { + }, + "value": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "LiveTranslate": { + "PayPromptPlayAction": { "methods": { - "live_translate": { + "phrase": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "LiveTranslateConfig": { - "methods": { - "action": { + }, + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "NullProperty": { + "PayPromptSayAction": { "methods": { - "description": { + "phrase": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -15201,70 +19280,79 @@ "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "NumberProperty": { + "PayPrompts": { "methods": { - "default": { + "actions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "attempts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enum": { + "card_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "nullable": { + "error_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "for": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ObjectProperty": { + "PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps": { "methods": { - "default": { + "active": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -15272,1025 +19360,1060 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "nullable": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "properties": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "required": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "parameters": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "OmitPropertiesBedrockPostPomptTextOmittedPromptProps": { + "PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps": { "methods": { - "confidence": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "parameters": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "OmitPropertiesBedrockPostPromptPomOmittedPromptProps": { + "PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps": { "methods": { - "confidence": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "web_hook_url": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "OmitPropertiesBedrockPromptPomOmittedPromptProps": { + "PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps": { "methods": { - "confidence": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "frequency_penalty": { + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pom": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "voice_id": { + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "OmitPropertiesBedrockPromptTextOmittedPromptProps": { + "Play": { "methods": { - "confidence": { + "play": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "frequency_penalty": { + } + } + }, + "PlayWithURL": { + "methods": { + "auto_answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_tokens": { + "say_gender": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "presence_penalty": { + "say_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "temperature": { + "say_voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "text": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "top_p": { + "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "voice_id": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "OneOfProperty": { - "methods": { - "oneOf": { + "volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Output": { + "PlayWithURLS": { "methods": { - "action": { + "auto_answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "response": { + "say_gender": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Pay": { - "methods": { - "pay": { + }, + "say_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PayConfig": { - "methods": { - "charge_amount": { + }, + "say_voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "currency": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "urls": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "input": { + "volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "language": { + } + } + }, + "PlaybackBGAction": { + "methods": { + "playback_bg": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "max_attempts": { + } + } + }, + "PomSectionBodyContent": { + "methods": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "min_postal_code_length": { + "bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "numbered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "payment_connector_url": { + "numberedBullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "payment_method": { + "subsections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "postal_code": { + "title": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "prompts": { + } + } + }, + "PomSectionBulletsContent": { + "methods": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "security_code": { + "bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "numbered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "numberedBullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "token_type": { + "subsections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "valid_card_types": { + "title": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "voice": { + } + } + }, + "Prompt": { + "methods": { + "prompt": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PayParameters": { + "PromptConfig": { "methods": { - "name": { + "digit_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "value": { + "initial_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PayPromptPlayAction": { - "methods": { - "phrase": { + }, + "max_digits": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "play": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PayPromptSayAction": { - "methods": { - "phrase": { + }, + "say_gender": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "say_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PayPrompts": { - "methods": { - "actions": { + }, + "say_voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "attempts": { + "speech_end_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "card_type": { + "speech_engine": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "error_type": { + "speech_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "for": { + "speech_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps": { - "methods": { - "active": { + }, + "speech_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "data_map": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "terminators": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function": { + "volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "meta_data": { + } + } + }, + "Pronounce": { + "methods": { + "ignore_case": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "replace": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "with": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "web_hook_url": { + } + } + }, + "ReceiveFax": { + "methods": { + "receive_fax": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps": { + "ReceiveFaxConfig": { "methods": { - "active": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "data_map": { + } + } + }, + "Record": { + "methods": { + "record": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "description": { + } + } + }, + "RecordCall": { + "methods": { + "record_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "function": { + } + } + }, + "RecordCallConfig": { + "methods": { + "beep": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "end_silence_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "web_hook_url": { + "format": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps": { - "methods": { - "active": { + }, + "initial_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "data_map": { + "input_sensitivity": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "max_length": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "stereo": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "terminators": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "parameters": { + } + } + }, + "RecordConfig": { + "methods": { + "beep": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "web_hook_url": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps": { - "methods": { - "active": { + }, + "end_silence_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "data_map": { + "format": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "initial_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function": { + "input_sensitivity": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "max_length": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "stereo": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "web_hook_url": { + "terminators": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Play": { + "Request": { "methods": { - "play": { + "request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PlayWithURL": { + "RequestConfig": { "methods": { - "auto_answer": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "say_gender": { + "connect_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "say_language": { + "headers": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "say_voice": { + "save_variables": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16298,30 +20421,43 @@ "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "volume": { + } + } + }, + "Return": { + "methods": { + "return": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PlayWithURLS": { + "RingbackConfig": { "methods": { "auto_answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "loop": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16329,8 +20465,8 @@ "say_gender": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16338,8 +20474,8 @@ "say_language": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16347,8 +20483,8 @@ "say_voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16356,8 +20492,17 @@ "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "url": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16365,8 +20510,8 @@ "urls": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16374,448 +20519,489 @@ "volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PlaybackBGAction": { + "SIPRefer": { "methods": { - "playback_bg": { + "sip_refer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PomSectionBodyContent": { + "SMSWithBody": { "methods": { "body": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "bullets": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "numbered": { + "from_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "numberedBullets": { + "region": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "subsections": { + "tags": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "title": { + "to_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PomSectionBulletsContent": { + "SMSWithMedia": { "methods": { "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "bullets": { + "from_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "numbered": { + "media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "numberedBullets": { + "region": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "subsections": { + "tags": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "title": { + "to_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Prompt": { + "SWAIG": { "methods": { - "prompt": { + "defaults": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PromptConfig": { - "methods": { - "digit_timeout": { + }, + "functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "initial_timeout": { + "includes": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_digits": { + "internal_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "play": { + "native_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "say_gender": { + } + } + }, + "SWAIGDefaults": { + "methods": { + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "say_language": { + } + } + }, + "SWAIGIncludes": { + "methods": { + "functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "say_voice": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_end_timeout": { + "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "speech_engine": { + } + } + }, + "SWAIGInternalFiller": { + "methods": { + "adjust_response_latency": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_hints": { + "change_context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_language": { + "check_time": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "speech_timeout": { + "get_ideal_strategy": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "get_visual_input": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminators": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "volume": { + "next_step": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Pronounce": { - "methods": { - "ignore_case": { + }, + "wait_for_user": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "replace": { + "wait_seconds": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "with": { + } + } + }, + "SWMLAction": { + "methods": { + "SWML": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ReceiveFax": { + "SayAction": { "methods": { - "receive_fax": { + "say": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ReceiveFaxConfig": { + "Section": { "methods": { - "status_url": { + "main": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Record": { + "SendDigits": { "methods": { - "record": { + "send_digits": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "RecordCall": { + "SendDigitsConfig": { "methods": { - "record_call": { + "digits": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "RecordCallConfig": { + "SendFax": { "methods": { - "beep": { + "send_fax": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "control_id": { + } + } + }, + "SendFaxConfig": { + "methods": { + "document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "header_info": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "end_silence_timeout": { + "identity": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "format": { + "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "initial_timeout": { + } + } + }, + "SendSMS": { + "methods": { + "send_sms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "input_sensitivity": { + } + } + }, + "Set": { + "methods": { + "set": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "max_length": { + } + } + }, + "SetGlobalDataAction": { + "methods": { + "set_global_data": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "SetMetaDataAction": { + "methods": { + "set_meta_data": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "SipReferConfig": { + "methods": { + "password": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -16823,620 +21009,598 @@ "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stereo": { + "to_uri": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminators": { + "username": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "RecordConfig": { + "Sleep": { "methods": { - "beep": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "direction": { + "sleep": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "end_silence_timeout": { + } + } + }, + "StartAction": { + "methods": { + "start": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "format": { + } + } + }, + "StartUpHookSWAIGFunction": { + "methods": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "initial_timeout": { + "argument": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "input_sensitivity": { + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_length": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stereo": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminators": { + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Request": { - "methods": { - "request": { + }, + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "RequestConfig": { - "methods": { - "body": { + }, + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "connect_timeout": { + "purpose": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "headers": { + "skip_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "method": { + "wait_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "save_variables": { + "wait_file_loops": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timeout": { + "wait_for_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "url": { + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Return": { + "StopAction": { "methods": { - "return": { + "stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SIPRefer": { + "StopDenoise": { "methods": { - "sip_refer": { + "stop_denoise": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SMSWithBody": { + "StopPlaybackBGAction": { "methods": { - "body": { + "stop_playback_bg": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "from_number": { + } + } + }, + "StopRecordCall": { + "methods": { + "stop_record_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "region": { + } + } + }, + "StopRecordCallConfig": { + "methods": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "tags": { + } + } + }, + "StopTap": { + "methods": { + "stop_tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "to_number": { + } + } + }, + "StopTapConfig": { + "methods": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SMSWithMedia": { + "StringProperty": { "methods": { - "body": { + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_number": { + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "media": { + "enum": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "region": { + "format": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tags": { + "nullable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_number": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "SWAIG": { - "methods": { - "defaults": { + "pattern": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "functions": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "includes": { + } + } + }, + "SummarizeAction": { + "methods": { + "summarize": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "internal_fillers": { + } + } + }, + "SummarizeConversationSWAIGFunction": { + "methods": { + "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "native_functions": { + "argument": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SWAIGDefaults": { - "methods": { - "web_hook_url": { + }, + "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SWAIGIncludes": { - "methods": { - "functions": { + }, + "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "url": { + "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SWAIGInternalFiller": { - "methods": { - "adjust_response_latency": { + }, + "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "change_context": { + "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "check_time": { + "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_ideal_strategy": { + "purpose": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_visual_input": { + "skip_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hangup": { + "wait_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "next_step": { + "wait_file_loops": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_user": { + "wait_for_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_seconds": { + "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SWMLAction": { + "Switch": { "methods": { - "SWML": { + "switch": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SayAction": { + "SwitchConfig": { "methods": { - "say": { + "case": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Section": { - "methods": { - "main": { + }, + "default": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SendDigits": { - "methods": { - "send_digits": { + }, + "variable": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SendDigitsConfig": { + "Tap": { "methods": { - "digits": { + "tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SendFax": { + "TapConfig": { "methods": { - "send_fax": { + "codec": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SendFaxConfig": { - "methods": { - "document": { + }, + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "header_info": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "identity": { + "rtp_ptime": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17444,139 +21608,191 @@ "status_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "uri": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SendSMS": { + "ToggleFunctionsAction": { "methods": { - "send_sms": { + "toggle_functions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Set": { + "TranscribeStartAction": { "methods": { - "set": { + "start": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SetGlobalDataAction": { + "TranscribeSummarizeAction": { "methods": { - "set_global_data": { + "summarize": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SetMetaDataAction": { + "Transfer": { "methods": { - "set_meta_data": { + "transfer": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "TransferConfig": { + "methods": { + "dest": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "meta": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "SipReferConfig": { + "Unset": { "methods": { - "password": { + "unset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "status_url": { + } + } + }, + "UnsetGlobalDataAction": { + "methods": { + "unset_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "to_uri": { + } + } + }, + "UnsetMetaDataAction": { + "methods": { + "unset_meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "username": { + } + } + }, + "UserEvent": { + "methods": { + "user_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "Sleep": { + "UserEventConfig": { "methods": { - "sleep": { + "event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "StartAction": { + "UserInputAction": { "methods": { - "start": { + "user_input": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "StartUpHookSWAIGFunction": { + "UserSWAIGFunction": { "methods": { "active": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17584,8 +21800,8 @@ "argument": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17593,8 +21809,8 @@ "data_map": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17602,8 +21818,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17611,8 +21827,8 @@ "fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17620,8 +21836,8 @@ "function": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17629,8 +21845,8 @@ "meta_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17638,8 +21854,8 @@ "meta_data_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17647,8 +21863,8 @@ "parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17656,8 +21872,8 @@ "purpose": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17665,8 +21881,8 @@ "skip_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17674,8 +21890,8 @@ "wait_file": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17683,8 +21899,8 @@ "wait_file_loops": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17692,8 +21908,8 @@ "wait_for_fillers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -17701,4427 +21917,4620 @@ "web_hook_url": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "StopAction": { - "methods": { - "stop": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "StopDenoise": { + "Webhook": { "methods": { - "stop_denoise": { + "error_keys": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StopPlaybackBGAction": { - "methods": { - "stop_playback_bg": { + }, + "expressions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StopRecordCall": { - "methods": { - "stop_record_call": { + }, + "foreach": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StopRecordCallConfig": { - "methods": { - "control_id": { + }, + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StopTap": { - "methods": { - "stop_tap": { + }, + "input_args_as_params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StopTapConfig": { - "methods": { - "control_id": { + }, + "method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "StringProperty": { - "methods": { - "default": { + }, + "output": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "enum": { + "require_args": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "format": { + "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "nullable": { + } + } + } + } + }, + "signalwire.pom.pom": { + "classes": { + "PromptObjectModel": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": false, + "kind": "keyword", + "name": "debug", + "required": false, + "type": "bool" } ], - "returns": "any" + "returns": "void" }, - "pattern": { + "add_pom_as_subsection": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "target", + "required": true, + "type": "union" + }, + { + "name": "pom_to_add", + "required": true, + "type": "class:signalwire.pom.pom.PromptObjectModel" } ], "returns": "any" }, - "type": { + "add_section": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "SummarizeAction": { - "methods": { - "summarize": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "SummarizeConversationSWAIGFunction": { - "methods": { - "active": { - "params": [ + "default": null, + "name": "title", + "required": false, + "type": "optional" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional,string>>" + }, + { + "default": null, + "kind": "keyword", + "name": "numbered", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": false, + "kind": "keyword", + "name": "numberedBullets", + "required": false, + "type": "bool" } ], "returns": "any" }, - "argument": { + "debug": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "data_map": { + "find_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "title", + "required": true, + "type": "string" } ], "returns": "any" }, - "description": { + "from_json": { "params": [ { - "name": "self", - "kind": "self" + "name": "json_data", + "required": true, + "type": "union>,list>>" } ], "returns": "any" }, - "fillers": { + "from_yaml": { "params": [ { - "name": "self", - "kind": "self" + "name": "yaml_data", + "required": true, + "type": "union>" } ], "returns": "any" }, - "function": { + "render_markdown": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "render_xml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data_token": { + "sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "parameters": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "purpose": { + "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_positional", + "name": "_args", + "required": false, + "type": "any" } ], "returns": "any" }, - "skip_fillers": { + "to_yaml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "wait_file": { + } + } + }, + "Section": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "title", + "required": false, + "type": "optional" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "numbered", + "required": false, + "type": "optional" + }, + { + "default": false, + "kind": "keyword", + "name": "numberedBullets", + "required": false, + "type": "bool" } ], - "returns": "any" + "returns": "void" }, - "wait_file_loops": { + "add_body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "body", + "required": true, + "type": "string" } ], "returns": "any" }, - "wait_for_fillers": { + "add_bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "bullets", + "required": true, + "type": "list" } ], "returns": "any" }, - "web_hook_url": { + "add_subsection": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "Switch": { - "methods": { - "switch": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "SwitchConfig": { - "methods": { - "case": { - "params": [ + "name": "title", + "required": true, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "bullets", + "required": false, + "type": "optional>" + }, + { + "default": false, + "kind": "keyword", + "name": "numbered", + "required": false, + "type": "bool" + }, + { + "default": false, + "kind": "keyword", + "name": "numberedBullets", + "required": false, + "type": "bool" } ], "returns": "any" }, - "default": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "variable": { + "bullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Tap": { - "methods": { - "tap": { + }, + "numbered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "TapConfig": { - "methods": { - "codec": { + }, + "numberedBullets": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "control_id": { + "render_markdown": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": 2, + "kind": "keyword", + "name": "level", + "required": false, + "type": "int" + }, + { + "default": null, + "kind": "keyword", + "name": "section_number", + "required": false, + "type": "optional>" } ], "returns": "any" }, - "direction": { + "render_xml": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": 0, + "kind": "keyword", + "name": "indent", + "required": false, + "type": "int" + }, + { + "default": null, + "kind": "keyword", + "name": "section_number", + "required": false, + "type": "optional>" } ], "returns": "any" }, - "rtp_ptime": { + "subsections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_url": { + "title": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "uri": { + "to_dict": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "ToggleFunctionsAction": { + } + } + }, + "signalwire.prefabs.concierge": { + "classes": { + "ConciergeAgent": { "methods": { - "toggle_functions": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "TranscribeStartAction": { - "methods": { - "start": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "TranscribeSummarizeAction": { - "methods": { - "summarize": { - "params": [ + "kind": "keyword", + "name": "venue_name", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "Transfer": { - "methods": { - "transfer": { - "params": [ + "kind": "keyword", + "name": "services", + "required": true, + "type": "list" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "TransferConfig": { - "methods": { - "dest": { - "params": [ + "kind": "keyword", + "name": "amenities", + "required": true, + "type": "dict>" + }, + { + "default": null, + "kind": "keyword", + "name": "hours_of_operation", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "special_instructions", + "required": false, + "type": "optional>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "welcome_message", + "required": false, + "type": "optional" + }, + { + "default": "concierge", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/concierge", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "_opts", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "meta": { + "amenities": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "check_availability": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "dict" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "Unset": { - "methods": { - "unset": { + }, + "get_directions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "dict" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "UnsetGlobalDataAction": { - "methods": { - "unset_global_data": { + }, + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "UnsetMetaDataAction": { - "methods": { - "unset_meta_data": { + }, + "handle_amenity_info": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "any" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "UserEvent": { - "methods": { - "user_event": { + }, + "handle_service_info": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "any" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "UserEventConfig": { - "methods": { - "event": { + }, + "hours_of_operation": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "UserInputAction": { - "methods": { - "user_input": { + }, + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "UserSWAIGFunction": { - "methods": { - "active": { + }, + "on_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "summary", + "required": true, + "type": "any" + }, + { + "default": null, + "name": "_raw_data", + "required": false, + "type": "any" } ], "returns": "any" }, - "argument": { + "prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "data_map": { + "route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "description": { + "services": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "fillers": { + "special_instructions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "function": { + "tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "meta_data": { + "venue_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "meta_data_token": { + } + } + } + } + }, + "signalwire.prefabs.faq_bot": { + "classes": { + "FAQBotAgent": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "faqs", + "required": true, + "type": "list>" + }, + { + "default": true, + "kind": "keyword", + "name": "suggest_related", + "required": false, + "type": "bool" + }, + { + "default": null, + "kind": "keyword", + "name": "persona", + "required": false, + "type": "optional" + }, + { + "default": "faq_bot", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/faq", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "_opts", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "parameters": { + "faqs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "purpose": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "skip_fillers": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_file": { + "on_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "summary", + "required": true, + "type": "any" + }, + { + "default": null, + "name": "_raw_data", + "required": false, + "type": "any" } ], "returns": "any" }, - "wait_file_loops": { + "persona": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_fillers": { + "prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "web_hook_url": { + "route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "Webhook": { - "methods": { - "error_keys": { + }, + "search_faqs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "dict" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" }, - "expressions": { + "suggest_related": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "foreach": { + "tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" + } + } + } + } + }, + "signalwire.prefabs.info_gatherer": { + "classes": { + "InfoGathererAgent": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "questions", + "required": false, + "type": "optional>>" + }, + { + "default": "info_gatherer", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/info_gatherer", + "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "**", + "required": false, + "type": "any" + } + ], + "returns": "void" }, - "headers": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "input_args_as_params": { + "on_swml_request": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "name": "request_data", + "required": false, + "type": "optional>" + }, + { + "default": null, + "name": "_callback_path", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "request", + "required": false, + "type": "any" } ], "returns": "any" }, - "method": { + "prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "output": { + "questions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "set_question_callback": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "callback", + "required": true, + "type": "callable,dict,dict>,list>>" } ], "returns": "any" }, - "require_args": { + "start_questions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "_args", + "required": true, + "type": "any" + }, + { + "name": "raw_data", + "required": true, + "type": "dict" } ], "returns": "any" }, - "url": { + "submit_answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "dict" + }, + { + "name": "raw_data", + "required": true, + "type": "dict" } ], "returns": "any" - } - } - } - } - }, - "signalwire.logging": { - "classes": { - "Logging": { - "methods": { - "global_level": { - "params": [], - "returns": "any" }, - "logger": { + "tools": { "params": [ { - "name": "name", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "reset": { - "params": [], - "returns": "any" - }, - "suppressed": { - "params": [], - "returns": "any" } } } } }, - "signalwire.pom.pom": { + "signalwire.prefabs.receptionist": { "classes": { - "PromptObjectModel": { + "ReceptionistAgent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "debug", - "type": "bool", "kind": "keyword", - "required": false, - "default": null - } - ], - "returns": "void" - }, - "add_pom_as_subsection": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "target", - "type": "union", - "required": true - }, - { - "name": "pom_to_add", - "type": "class:signalwire.pom.pom.PromptObjectModel", - "required": true - } - ], - "returns": "any" - }, - "add_section": { - "params": [ - { - "name": "self", - "kind": "self" + "name": "departments", + "required": true, + "type": "list>" }, { - "name": "title", - "type": "optional", + "default": "receptionist", + "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "string" }, { - "name": "body", - "type": "string", + "default": "/receptionist", "kind": "keyword", + "name": "route", "required": false, - "default": null + "type": "string" }, { - "name": "bullets", - "type": "optional,string>>", + "default": "Thank you for calling. How can I help you today?", "kind": "keyword", + "name": "greeting", "required": false, - "default": null + "type": "string" }, { - "name": "numbered", - "type": "optional", + "default": "rime.spore", "kind": "keyword", + "name": "voice", "required": false, - "default": null + "type": "string" }, { - "name": "numberedBullets", - "type": "bool", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "_opts", "required": false, - "default": null + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "debug": { + "departments": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "find_section": { + "global_data": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "title", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_json": { + "greeting": { "params": [ { - "name": "json_data", - "type": "union>,list>>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_yaml": { + "handle_transfer": { "params": [ { - "name": "yaml_data", - "type": "union>", - "required": true - } - ], - "returns": "any" - }, - "render_markdown": { - "params": [ + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "any" + }, { - "name": "self", - "kind": "self" + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" }, - "render_xml": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sections": { + "on_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "_summary", + "required": true, + "type": "any" + }, + { + "default": null, + "name": "_raw_data", + "required": false, + "type": "any" } ], "returns": "any" }, - "to_json": { + "prompt_sections": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_args", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_yaml": { + "route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_dict": { + "tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "Section": { + } + } + }, + "signalwire.prefabs.survey": { + "classes": { + "SurveyAgent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "title", - "type": "optional", + "kind": "keyword", + "name": "survey_name", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "questions", + "required": true, + "type": "list>" + }, + { + "default": null, + "kind": "keyword", + "name": "introduction", "required": false, - "default": null + "type": "optional" }, { - "name": "body", - "type": "string", + "default": null, "kind": "keyword", + "name": "conclusion", "required": false, - "default": null + "type": "optional" }, { - "name": "bullets", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "brand_name", "required": false, - "default": null + "type": "optional" }, { - "name": "numbered", - "type": "optional", + "default": 2, "kind": "keyword", + "name": "max_retries", "required": false, - "default": null + "type": "int" }, { - "name": "numberedBullets", - "type": "bool", + "default": "survey", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": "/survey", "kind": "keyword", + "name": "route", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "_opts", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "add_body": { + "brand_name": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "conclusion": { + "params": [ { - "name": "body", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "add_bullets": { + "global_data": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "handle_start": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "bullets", - "type": "list", - "required": true + "name": "_args", + "required": true, + "type": "any" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" }, - "add_subsection": { + "handle_submit": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "title", - "type": "string", - "required": true + "name": "args", + "required": true, + "type": "any" }, { - "name": "body", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "_raw_data", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "handle_summary": { + "params": [ { - "name": "bullets", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "numbered", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "_args", + "required": true, + "type": "any" }, { - "name": "numberedBullets", - "type": "bool", - "kind": "keyword", - "required": false, - "default": null + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" }, - "body": { + "introduction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "bullets": { + "log_response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "args", + "required": true, + "type": "dict" + }, + { + "name": "_raw_data", + "required": true, + "type": "any" } ], "returns": "any" }, - "numbered": { + "max_retries": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "numbered_bullets": { + "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "render_markdown": { + "on_summary": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "level", - "type": "int", - "kind": "keyword", - "required": false, - "default": null + "name": "summary", + "required": true, + "type": "any" }, { - "name": "section_number", - "type": "optional>", - "kind": "keyword", + "default": null, + "name": "_raw_data", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "render_xml": { + "prompt_sections": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "indent", - "type": "int", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "section_number", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "subsections": { + "questions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "title": { + "route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_dict": { + "survey_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.prefabs.concierge": { - "classes": { - "ConciergeAgent": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "venue_name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "services", - "type": "list", - "kind": "keyword", - "required": true - }, - { - "name": "amenities", - "type": "dict>", - "kind": "keyword", - "required": true - }, - { - "name": "hours_of_operation", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "special_instructions", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "welcome_message", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "route", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "_opts", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "void" }, - "amenities": { + "tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "check_availability": { + "validate_response": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "args", - "type": "dict", - "required": true + "required": true, + "type": "dict" }, { "name": "_raw_data", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" - }, - "get_directions": { + } + } + } + } + }, + "signalwire.relay.call": { + "classes": { + "AIAction": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "_raw_data", - "type": "any", - "required": true + "name": "control_id", + "required": true, + "type": "string" } ], - "returns": "any" + "returns": "void" }, - "global_data": { + "stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "handle_amenity_info": { + } + } + }, + "Action": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "any", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "_raw_data", - "type": "any", - "required": true + "name": "control_id", + "required": true, + "type": "string" + }, + { + "name": "terminal_event", + "required": true, + "type": "string" + }, + { + "name": "terminal_states", + "required": true, + "type": "tuple" } ], - "returns": "any" + "returns": "void" }, - "handle_service_info": { + "call": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "args", - "type": "any", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "completed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_summary": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "summary", - "type": "any", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_sections": { + "done": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "route": { + "is_done": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "services": { + "on_completed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "tools": { + "result": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "venue_name": { + "wait": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" } ], "returns": "any" } } - } - } - }, - "signalwire.prefabs.faq_bot": { - "classes": { - "FAQBotAgent": { + }, + "Call": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "client", + "required": true, + "type": "class:signalwire.relay.client.RelayClient" }, { - "name": "faqs", - "type": "list>", "kind": "keyword", - "required": true + "name": "call_id", + "required": true, + "type": "string" }, { - "name": "suggest_related", - "type": "bool", "kind": "keyword", + "name": "node_id", + "required": true, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "project_id", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "context", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "tag", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "direction", + "required": false, + "type": "string" + }, + { + "default": {}, + "kind": "keyword", + "name": "device", + "required": false, + "type": "optional>" + }, + { + "default": "", + "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "persona", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "default": "", + "kind": "keyword", + "name": "segment_id", + "required": false, + "type": "string" + } + ], + "returns": "void" + }, + "ai": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "route", - "type": "string", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" }, { - "name": "_opts", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], - "returns": "void" + "returns": "any" }, - "faqs": { + "ai_hold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "global_data": { + "ai_message": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "name": { + "ai_unhold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "on_summary": { + "amazon_bedrock": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "summary", - "type": "any", - "required": true + "kind": "self", + "name": "self" }, { - "name": "_raw_data", - "type": "any", + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "prompt_sections": { + "answer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "route": { + "bind_digit": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "digits", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "bind_method", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "tools": { + "call_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "search_faqs": { + "clear_digit_bindings": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": true + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" - } - } - } - } - }, - "signalwire.prefabs.info_gatherer": { - "classes": { - "InfoGathererAgent": { - "methods": { - "__init__": { + }, + "collect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "questions", - "type": "optional>>", - "kind": "keyword", - "required": false, - "default": null + "name": "collect_opts", + "required": true, + "type": "any" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "route", - "type": "string", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" }, { - "name": "**", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null - } - ], - "returns": "void" - }, - "global_data": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "any" } ], "returns": "any" }, - "on_swml_request": { + "connect": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "request_data", - "type": "optional>", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "_callback_path", - "type": "any", - "required": false, - "default": null + "kind": "keyword", + "name": "devices", + "required": true, + "type": "list>>" }, { - "name": "request", - "type": "any", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "prompt_sections": { + "context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "questions": { + "denoise": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "set_question_callback": { + "denoise_stop": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "callback", - "type": "callable,dict,dict>,list>>", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tools": { + "detect": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "start_questions": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "detect_opts", + "required": true, + "type": "any" }, { - "name": "_args", - "type": "any", - "required": true + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" }, { - "name": "raw_data", - "type": "dict", + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "submit_answer": { + "detect_answering_machine": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true + "default": null, + "kind": "keyword", + "name": "initial_timeout", + "required": false, + "type": "optional" }, { - "name": "raw_data", - "type": "dict", + "default": null, + "kind": "keyword", + "name": "end_silence_timeout", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "machine_voice_threshold", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "machine_words_threshold", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "detect_interruptions", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "detect_message_end", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], "returns": "any" - } - } - } - } - }, - "signalwire.prefabs.receptionist": { - "classes": { - "ReceptionistAgent": { - "methods": { - "__init__": { + }, + "detect_digit": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "digits", + "required": false, + "type": "optional" }, { - "name": "departments", - "type": "list>", + "default": null, "kind": "keyword", - "required": true + "name": "timeout", + "required": false, + "type": "optional" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" + } + ], + "returns": "any" + }, + "detect_fax": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "route", - "type": "string", + "default": null, "kind": "keyword", + "name": "tone", "required": false, - "default": null + "type": "optional" }, { - "name": "greeting", - "type": "string", + "default": null, "kind": "keyword", + "name": "timeout", "required": false, - "default": null + "type": "optional" }, { - "name": "_opts", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], - "returns": "void" + "returns": "any" }, - "departments": { + "device": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "global_data": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "greeting": { + "disconnect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "handle_transfer": { + "echo": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "any", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": true + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "name": { + "ended": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_summary": { + "hangup": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "_summary", - "type": "any", - "required": true + "kind": "self", + "name": "self" }, { - "name": "_raw_data", - "type": "any", + "default": "hangup", + "kind": "keyword", + "name": "reason", "required": false, - "default": null + "type": "string" } ], "returns": "any" }, - "prompt_sections": { + "hold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "route": { + "inspect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tools": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - } - } - }, - "signalwire.prefabs.survey": { - "classes": { - "SurveyAgent": { - "methods": { - "__init__": { + "join_conference": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "survey_name", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "questions", - "type": "list>", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "introduction", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" }, { - "name": "conclusion", - "type": "optional", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null - }, + "type": "any" + } + ], + "returns": "any" + }, + "join_room": { + "params": [ { - "name": "name", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "route", - "type": "string", "kind": "keyword", - "required": false, - "default": null + "name": "name", + "required": true, + "type": "string" }, { - "name": "_opts", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null - } - ], - "returns": "void" - }, - "global_data": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "any" } ], "returns": "any" }, - "handle_start": { + "leave_conference": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "_args", - "type": "any", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": true + "kind": "keyword", + "name": "conference_id", + "required": true, + "type": "string" } ], "returns": "any" }, - "handle_submit": { + "leave_room": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "args", - "type": "any", - "required": true - }, - { - "name": "_raw_data", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "handle_summary": { + "live_transcribe": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "_args", - "type": "any", - "required": true + "kind": "keyword", + "name": "action", + "required": true, + "type": "dict" }, { - "name": "_raw_data", - "type": "any", - "required": true + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "log_response": { + "live_translate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true + "kind": "keyword", + "name": "action", + "required": true, + "type": "dict" }, { - "name": "_raw_data", - "type": "any", - "required": true + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "name": { + "node_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_summary": { + "on": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "summary", - "type": "any", - "required": true + "name": "event_type", + "required": true, + "type": "string" }, { - "name": "_raw_data", - "type": "any", + "name": "handler", + "required": true, + "type": "callable,void>" + }, + { + "default": null, + "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "prompt_sections": { + "pass_": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "questions": { + "pay": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "route": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "survey_name": { - "params": [ + "kind": "keyword", + "name": "payment_connector_url", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "tools": { - "params": [ + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "validate_response": { + "play": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "args", - "type": "dict", - "required": true + "name": "media", + "required": true, + "type": "list>" }, { - "name": "_raw_data", - "type": "any", - "required": true - } - ], - "returns": "any" - } - } - } - } - }, - "signalwire.relay.call": { - "classes": { - "AIAction": { - "methods": { - "__init__": { - "params": [ + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "direction", + "required": false, + "type": "optional" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "default": null, + "kind": "keyword", + "name": "loop", + "required": false, + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "control_id", - "type": "string", - "required": true - } - ], - "returns": "void" - }, - "stop": { - "params": [ + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" - } - } - }, - "Action": { - "methods": { - "__init__": { + }, + "play_and_collect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "name": "media", + "required": true, + "type": "list>" }, { - "name": "control_id", - "type": "string", - "required": true + "name": "collect", + "required": true, + "type": "dict" }, { - "name": "terminal_event", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" }, { - "name": "terminal_states", - "type": "tuple", - "required": true - } - ], - "returns": "void" - }, - "call": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "completed": { - "params": [ + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "control_id": { - "params": [ + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "done": { + "play_audio": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "is_done": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "on_completed": { - "params": [ + "name": "url", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], "returns": "any" }, - "result": { + "play_ringtone": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "wait": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "name", + "required": true, + "type": "string" }, { - "name": "timeout", - "type": "optional", + "default": null, + "kind": "keyword", + "name": "duration", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], "returns": "any" - } - } - }, - "Call": { - "methods": { - "__init__": { + }, + "play_silence": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "client", - "type": "class:signalwire.relay.client.RelayClient", - "required": true + "name": "duration", + "required": true, + "type": "float" }, { - "name": "call_id", - "type": "string", + "default": null, "kind": "keyword", - "required": true - }, + "name": "on_completed", + "required": false, + "type": "optional,any>>" + } + ], + "returns": "any" + }, + "play_tts": { + "params": [ { - "name": "node_id", - "type": "string", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "project_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "text", + "required": true, + "type": "string" }, { - "name": "context", - "type": "string", + "default": null, "kind": "keyword", + "name": "language", "required": false, - "default": null + "type": "optional" }, { - "name": "tag", - "type": "string", + "default": null, "kind": "keyword", + "name": "gender", "required": false, - "default": null + "type": "optional" }, { - "name": "direction", - "type": "string", + "default": null, "kind": "keyword", + "name": "voice", "required": false, - "default": null + "type": "optional" }, { - "name": "device", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "volume", "required": false, - "default": null + "type": "optional" }, { - "name": "state", - "type": "string", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null - }, + "type": "optional,any>>" + } + ], + "returns": "any" + }, + "project_id": { + "params": [ { - "name": "segment_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "ai": { + "prompt_audio": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" }, { - "name": "on_completed", - "type": "optional,any>>", + "name": "collect", + "required": true, + "type": "dict" + }, + { + "default": null, "kind": "keyword", + "name": "volume", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], "returns": "any" }, - "ai_hold": { + "prompt_tts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "text", + "required": true, + "type": "string" + }, + { + "name": "collect", + "required": true, + "type": "dict" + }, + { + "default": null, + "kind": "keyword", + "name": "language", "required": false, - "default": null - } - ], - "returns": "any" - }, - "ai_message": { - "params": [ + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "gender", + "required": false, + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "voice", "required": false, - "default": null - } - ], - "returns": "any" - }, - "ai_unhold": { - "params": [ + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "volume", + "required": false, + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" } ], "returns": "any" }, - "amazon_bedrock": { + "queue_enter": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "answer": { - "params": [ + "kind": "keyword", + "name": "queue_name", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "bind_digit": { + "queue_leave": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "digits", - "type": "string", "kind": "keyword", - "required": true + "name": "queue_name", + "required": true, + "type": "string" }, { - "name": "bind_method", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "control_id", + "required": false, + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "call_id": { + "receive_fax": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "clear_digit_bindings": { - "params": [ + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "collect": { + "record": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "collect_opts", - "type": "any", - "required": true + "default": null, + "kind": "keyword", + "name": "audio", + "required": false, + "type": "optional>" }, { - "name": "control_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "connect": { + "refer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "devices", - "type": "list>>", "kind": "keyword", - "required": true + "name": "device", + "required": true, + "type": "dict" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null - } - ], - "returns": "any" - }, - "context": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "denoise": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "any" } ], "returns": "any" }, - "denoise_stop": { + "segment_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "detect": { + "send_digits": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "detect_opts", - "type": "any", - "required": true - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "digits", + "required": true, + "type": "string" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "detect_answering_machine": { + "send_fax": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "initial_timeout", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "document", + "required": true, + "type": "string" }, { - "name": "end_silence_timeout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "machine_voice_threshold", - "type": "optional", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" }, { - "name": "machine_words_threshold", - "type": "optional", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" + } + ], + "returns": "any" + }, + "state": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "stream": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "detect_interruptions", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" }, { - "name": "detect_message_end", - "type": "optional", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "timeout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null + "type": "optional,any>>" }, { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "detect_digit": { + "tag": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "digits", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "detect_fax": { + "tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "tap_opts", + "required": true, + "type": "any" }, { - "name": "tone", - "type": "optional", "kind": "keyword", - "required": false, - "default": null + "name": "device", + "required": true, + "type": "dict" }, { - "name": "timeout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "on_completed", "required": false, - "default": null - } - ], - "returns": "any" - }, - "device": { - "params": [ + "type": "optional,any>>" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "direction": { + "to_s": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "disconnect": { + "transcribe": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "control_id", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "echo": { + "transfer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "dest", + "required": true, + "type": "string" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "ended": { + "unhold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hangup": { + "user_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "reason", - "type": "string", + "default": null, "kind": "keyword", + "name": "event", "required": false, - "default": null - } - ], - "returns": "any" - }, - "hold": { - "params": [ + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "inspect": { + "wait_for": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "event_type", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "predicate", + "required": false, + "type": "optional,bool>>" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" } ], "returns": "any" }, - "join_conference": { + "wait_for_answered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "timeout", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "join_room": { + "wait_for_ended": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "timeout", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "leave_conference": { + "wait_for_ending": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "conference_id", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "timeout", + "required": false, + "type": "optional" } ], "returns": "any" }, - "leave_room": { + "wait_for_ringing": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" } ], "returns": "any" - }, - "live_transcribe": { + } + } + }, + "CollectAction": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "action", - "type": "dict", - "kind": "keyword", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "control_id", + "required": true, + "type": "string" } ], - "returns": "any" + "returns": "void" }, - "live_translate": { + "pause": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "action", - "type": "dict", + "default": null, "kind": "keyword", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "behavior", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "node_id": { + "resume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on": { + "start_input_timers": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event_type", - "type": "string", - "required": true - }, - { - "name": "handler", - "type": "class:signalwire.relay.call.EventHandler", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pay": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "payment_connector_url", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "play": { + "volume": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "media", - "type": "list>", - "required": true + "kind": "self", + "name": "self" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "vol", + "required": true, + "type": "any" + } + ], + "returns": "any" + } + } + }, + "DetectAction": { + "methods": { + "__init__": { + "params": [ { - "name": "direction", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "loop", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "required": true, + "type": "string" } ], - "returns": "any" + "returns": "void" }, - "play_and_collect": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "media", - "type": "list>", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "FaxAction": { + "methods": { + "__init__": { + "params": [ { - "name": "collect", - "type": "dict", - "required": true + "kind": "self", + "name": "self" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "required": true, + "type": "string" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "method_prefix", + "required": true, + "type": "string" } ], - "returns": "any" + "returns": "void" }, - "play_audio": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "PayAction": { + "methods": { + "__init__": { + "params": [ { - "name": "url", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "name": "control_id", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "stop": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "play_ringtone": { + } + } + }, + "PlayAction": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "duration", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "control_id", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "pause": { + "params": [ { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "behavior", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "play_silence": { + "resume": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "duration", - "type": "float", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "stop": { + "params": [ { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "play_tts": { + "volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "text", - "type": "string", - "required": true - }, + "name": "vol", + "required": true, + "type": "any" + } + ], + "returns": "any" + } + } + }, + "RecordAction": { + "methods": { + "__init__": { + "params": [ { - "name": "language", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "gender", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "voice", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "control_id", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "pause": { + "params": [ { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "behavior", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "project_id": { + "resume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_audio": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "StandaloneCollectAction": { + "methods": { + "__init__": { + "params": [ { - "name": "url", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "collect", - "type": "dict", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "control_id", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "start_input_timers": { + "params": [ { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "prompt_tts": { + "stop": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "text", - "type": "string", - "required": true - }, - { - "name": "collect", - "type": "dict", - "required": true - }, - { - "name": "language", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "StreamAction": { + "methods": { + "__init__": { + "params": [ { - "name": "gender", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "voice", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { - "name": "volume", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "control_id", + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "stop": { + "params": [ { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "queue_enter": { + } + } + }, + "TapAction": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "queue_name", - "type": "string", - "kind": "keyword", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "stop": { + "params": [ { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "queue_leave": { + } + } + }, + "TranscribeAction": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "queue_name", - "type": "string", - "kind": "keyword", - "required": true + "name": "call", + "required": true, + "type": "class:signalwire.relay.call.Call" }, { "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, + "required": true, + "type": "string" + } + ], + "returns": "void" + }, + "stop": { + "params": [ { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "receive_fax": { + } + } + } + } + }, + "signalwire.relay.call_state": { + "functions": { + "terminal": { + "params": [ + { + "name": "state", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "valid": { + "params": [ + { + "name": "state", + "required": true, + "type": "any" + } + ], + "returns": "any" + } + } + }, + "signalwire.relay.client": { + "classes": { + "RelayClient": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "project", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "token", "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "any" - }, - "record": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "optional" }, { - "name": "audio", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "jwt_token", "required": false, - "default": null + "type": "optional" }, { - "name": "control_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "host", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": [ + "default" + ], "kind": "keyword", + "name": "contexts", "required": false, - "default": null + "type": "optional>" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "max_active_calls", "required": false, - "default": null - } - ], - "returns": "any" - }, - "refer": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "optional" }, { - "name": "device", - "type": "dict", + "default": null, "kind": "keyword", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "name": "space", "required": false, - "default": null + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "segment_id": { + "connect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "send_digits": { + "contexts": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "digits", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "send_fax": { + "dial": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "document", - "type": "string", - "kind": "keyword", - "required": true + "name": "devices", + "required": true, + "type": "list>>" }, { - "name": "control_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "tag", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "max_duration", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "dial_timeout", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "state": { + "disconnect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stream": { + "execute": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "url", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "name": "method", + "required": true, + "type": "string" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "name": "params", + "required": true, + "type": "dict" } ], "returns": "any" }, - "tag": { + "host": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_s": { + "inspect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transcribe": { + "jwt_token": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "control_id", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "transfer": { + "max_active_calls": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "dest", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "unhold": { + "on_call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "handler", + "required": true, + "type": "callable,void>" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "user_event": { + "on_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "event", - "type": "optional", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "wait_for": { + "on_message": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event_type", - "type": "string", - "required": true + "kind": "self", + "name": "self" }, { - "name": "predicate", - "type": "optional,bool>>", - "kind": "keyword", - "required": false, - "default": null + "name": "handler", + "required": true, + "type": "callable,void>" }, { - "name": "timeout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" }, - "wait_for_answered": { + "project": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_ended": { + "protocol": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait_for_ending": { + "receive": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "name": "contexts", + "required": true, + "type": "list" } ], "returns": "any" }, - "wait_for_ringing": { + "run": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "pass_": { + "send_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "msg", + "required": true, + "type": "any" } ], "returns": "any" }, - "tap": { + "send_message": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "tap_opts", - "type": "any", - "required": true + "kind": "keyword", + "name": "to_number", + "required": true, + "type": "string" }, { - "name": "device", - "type": "dict", "kind": "keyword", - "required": true + "name": "from_number", + "required": true, + "type": "string" }, { - "name": "control_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "optional" }, { - "name": "on_completed", - "type": "optional,any>>", + "default": null, "kind": "keyword", + "name": "body", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "media", "required": false, - "default": null - } - ], - "returns": "any" - } - } - }, - "CollectAction": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "type": "optional>" }, { - "name": "control_id", - "type": "string", - "required": true - } - ], - "returns": "void" - }, - "pause": { - "params": [ - { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "tags", + "required": false, + "type": "optional>" }, { - "name": "behavior", - "type": "optional", + "default": null, "kind": "keyword", + "name": "region", "required": false, - "default": null - } - ], - "returns": "any" - }, - "resume": { - "params": [ + "type": "optional" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "on_completed", + "required": false, + "type": "optional,any>>" } ], "returns": "any" }, - "start_input_timers": { + "to_s": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stop": { + "token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "volume": { + "unreceive": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "vol", - "type": "any", - "required": true + "name": "contexts", + "required": true, + "type": "list" } ], "returns": "any" } } }, - "DetectAction": { + "RelayError": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "name": "code", + "required": true, + "type": "int" }, { - "name": "control_id", - "type": "string", - "required": true + "name": "message", + "required": true, + "type": "string" } ], "returns": "void" }, - "stop": { + "code": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "message": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "FaxAction": { + } + } + }, + "signalwire.relay.collect_config": { + "classes": { + "CollectConfig": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "default": null, + "kind": "keyword", + "name": "digits", + "required": false, + "type": "any" }, { - "name": "control_id", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "speech", + "required": false, + "type": "any" }, { - "name": "method_prefix", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "initial_timeout", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "partial_results", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "continuous", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "send_start_of_input", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "start_input_timers", + "required": false, + "type": "any" } ], "returns": "void" }, - "stop": { + "continuous": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PayAction": { - "methods": { - "__init__": { + }, + "deconstruct_keys": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", - "required": true + "name": "keys", + "required": true, + "type": "any" } ], - "returns": "void" + "returns": "any" }, - "stop": { + "digits": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "PlayAction": { - "methods": { - "__init__": { + }, + "eql": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true - }, - { - "name": "control_id", - "type": "string", - "required": true + "name": "other", + "required": true, + "type": "any" } ], - "returns": "void" + "returns": "any" }, - "pause": { + "hash": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "behavior", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "resume": { + "initial_timeout": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stop": { + "inspect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "volume": { + "partial_results": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "vol", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "RecordAction": { - "methods": { - "__init__": { + }, + "send_start_of_input": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "speech": { + "params": [ { - "name": "control_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "pause": { + "start_input_timers": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "to_h": { + "params": [ { - "name": "behavior", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "resume": { + "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_positional", + "name": "*", + "required": false, + "type": "any" } ], "returns": "any" }, - "stop": { + "to_s": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "StandaloneCollectAction": { + } + } + }, + "signalwire.relay.device": { + "classes": { + "Device": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "name": "type", + "required": true, + "type": "any" }, { - "name": "control_id", - "type": "string", - "required": true + "default": {}, + "name": "params", + "required": false, + "type": "any" } ], "returns": "void" }, - "start_input_timers": { + "deconstruct": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "stop": { + "deconstruct_keys": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "keys", + "required": true, + "type": "any" } ], "returns": "any" - } - } - }, - "StreamAction": { - "methods": { - "__init__": { + }, + "eql": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "other", + "required": true, + "type": "any" + } + ], + "returns": "any" + }, + "hash": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "inspect": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "params": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true - }, - { - "name": "control_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "stop": { + "phone": { "params": [ { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "to", + "required": true, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "from", + "required": false, + "type": "any" + }, + { + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "any" } ], "returns": "any" - } - } - }, - "TapAction": { - "methods": { - "__init__": { + }, + "sip": { "params": [ { - "name": "self", - "kind": "self" + "kind": "keyword", + "name": "to", + "required": true, + "type": "any" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true + "default": null, + "kind": "keyword", + "name": "from", + "required": false, + "type": "any" }, { - "name": "control_id", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "headers", + "required": false, + "type": "any" } ], - "returns": "void" + "returns": "any" }, - "stop": { + "to_h": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "TranscribeAction": { - "methods": { - "__init__": { + }, + "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "call", - "type": "class:signalwire.relay.call.Call", - "required": true - }, + "default": null, + "kind": "var_positional", + "name": "*", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "to_s": { + "params": [ { - "name": "control_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "stop": { + "type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -22130,14 +26539,14 @@ } } }, - "signalwire.relay.call_state": { + "signalwire.relay.dial_state": { "functions": { "terminal": { "params": [ { "name": "state", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -22146,202 +26555,141 @@ "params": [ { "name": "state", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" } } }, - "signalwire.relay.client": { + "signalwire.relay.event": { "classes": { - "RelayClient": { + "CallReceiveEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "project", - "type": "optional", + "default": "", "kind": "keyword", + "name": "call_state", "required": false, - "default": null + "type": "string" }, { - "name": "token", - "type": "optional", + "default": "", "kind": "keyword", + "name": "direction", "required": false, - "default": null + "type": "string" }, { - "name": "jwt_token", - "type": "optional", + "default": {}, "kind": "keyword", + "name": "device", "required": false, - "default": null + "type": "dict" }, { - "name": "host", - "type": "optional", + "default": "", "kind": "keyword", + "name": "node_id", "required": false, - "default": null + "type": "string" }, { - "name": "contexts", - "type": "optional>", + "default": "", "kind": "keyword", + "name": "project_id", "required": false, - "default": null + "type": "string" }, { - "name": "max_active_calls", - "type": "optional", + "default": "", "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "string" }, { - "name": "space", - "type": "any", + "default": "", "kind": "keyword", + "name": "segment_id", "required": false, - "default": null - } - ], - "returns": "void" - }, - "connect": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "dial": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "devices", - "type": "list>>", - "required": true + "type": "string" }, { - "name": "timeout", - "type": "any", + "default": "", "kind": "keyword", - "required": false, - "default": null - }, - { "name": "tag", - "type": "optional", - "kind": "keyword", "required": false, - "default": null + "type": "string" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "execute": { + "call_state": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "method", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "dict", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "host": { + "context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "max_active_calls": { + "device": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_call": { + "direction": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on_event": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "on_message": { + "node_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "block", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" @@ -22349,163 +26697,163 @@ "project_id": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "protocol": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "receive": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "contexts", - "type": "list", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "run": { + "segment_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "send_json": { + "tag": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "msg", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "send_message": { + } + } + }, + "CallStateEvent": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "to_number", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "from_number", - "type": "string", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "context", - "type": "optional", + "default": "", "kind": "keyword", + "name": "call_state", "required": false, - "default": null + "type": "string" }, { - "name": "body", - "type": "optional", + "default": "", "kind": "keyword", + "name": "end_reason", "required": false, - "default": null + "type": "string" }, { - "name": "media", - "type": "optional>", + "default": "", "kind": "keyword", + "name": "direction", "required": false, - "default": null + "type": "string" }, { - "name": "tags", - "type": "optional>", + "default": {}, "kind": "keyword", + "name": "device", "required": false, - "default": null + "type": "dict" }, { - "name": "region", - "type": "optional", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "base", "required": false, - "default": null - }, + "type": "any" + } + ], + "returns": "void" + }, + "call_state": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "device": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "direction": { + "params": [ { - "name": "on_completed", - "type": "optional,any>>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "unreceive": { + "end_reason": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "from_payload": { + "params": [ { - "name": "contexts", - "type": "list", - "required": true + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "disconnect": { + "terminal": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "RelayError": { + "CallingErrorEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": "", + "kind": "keyword", "name": "code", - "type": "int", - "required": true + "required": false, + "type": "string" }, { + "default": "", + "kind": "keyword", "name": "message", - "type": "string", - "required": true + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" } ], "returns": "void" @@ -22513,551 +26861,446 @@ "code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "from_payload": { + "params": [ + { + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "error_message": { + "message": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.relay.collect_config": { - "classes": { - "CollectConfig": { + }, + "CollectEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "digits", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "speech", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "initial_timeout", - "type": "any", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "partial_results", - "type": "any", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "continuous", - "type": "any", + "default": {}, "kind": "keyword", + "name": "result", "required": false, - "default": null + "type": "dict" }, { - "name": "send_start_of_input", - "type": "any", + "default": null, "kind": "keyword", + "name": "final", "required": false, - "default": null + "type": "optional" }, { - "name": "start_input_timers", - "type": "any", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "continuous": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "deconstruct_keys": { + "final": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "keys", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "digits": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "eql": { + "result": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "other", - "type": "any", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hash": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "initial_timeout": { + } + } + }, + "ConferenceEvent": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "inspect": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "partial_results": { - "params": [ + "default": "", + "kind": "keyword", + "name": "conference_id", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "send_start_of_input": { - "params": [ + "default": "", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "speech": { - "params": [ + "default": "", + "kind": "keyword", + "name": "status", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "start_input_timers": { + "conference_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_h": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "to_json": { + "name": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "*", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_s": { + "status": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - } - }, - "signalwire.relay.device": { - "classes": { - "Device": { + }, + "ConnectEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "type", - "type": "any", - "required": true - }, - { - "name": "params", - "type": "any", + "default": "", + "kind": "keyword", + "name": "connect_state", "required": false, - "default": null - } - ], - "returns": "void" - }, - "deconstruct": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "deconstruct_keys": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "string" }, { - "name": "keys", - "type": "any", - "required": true - } - ], - "returns": "any" - }, - "eql": { - "params": [ - { - "name": "self", - "kind": "self" + "default": {}, + "kind": "keyword", + "name": "peer", + "required": false, + "type": "dict" }, { - "name": "other", - "type": "any", - "required": true + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "hash": { + "connect_state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "inspect": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "params": { + "peer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "phone": { + } + } + }, + "DenoiseEvent": { + "methods": { + "__init__": { "params": [ { - "name": "to", - "type": "any", - "kind": "keyword", - "required": true + "kind": "self", + "name": "self" }, { - "name": "from", - "type": "any", + "default": false, "kind": "keyword", + "name": "denoised", "required": false, - "default": null + "type": "bool" }, { - "name": "timeout", - "type": "any", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" + } + ], + "returns": "void" + }, + "denoised": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sip": { + "from_payload": { "params": [ { - "name": "to", - "type": "any", - "kind": "keyword", - "required": true + "name": "payload", + "required": true, + "type": "dict" + } + ], + "returns": "any" + } + } + }, + "DetectEvent": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "from", - "type": "any", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "headers", - "type": "any", + "default": {}, "kind": "keyword", + "name": "detect", "required": false, - "default": null - } - ], - "returns": "any" - }, - "to_h": { - "params": [ + "type": "dict" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, - "to_json": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "*", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_s": { + "detect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "type": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" } } - } - } - }, - "signalwire.relay.dial_state": { - "functions": { - "terminal": { - "params": [ - { - "name": "state", - "type": "any", - "required": true - } - ], - "returns": "any" }, - "valid": { - "params": [ - { - "name": "state", - "type": "any", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.relay.event": { - "classes": { - "CallReceiveEvent": { + "DialEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "direction", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "device", - "type": "dict", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "node_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "project_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "context", - "type": "string", + "default": "", "kind": "keyword", + "name": "tag", "required": false, - "default": null + "type": "string" }, { - "name": "segment_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "dial_state", "required": false, - "default": null + "type": "string" }, { - "name": "tag", - "type": "string", + "default": {}, "kind": "keyword", + "name": "call", "required": false, - "default": null + "type": "dict" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "call_state": { + "answered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "context": { + "call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "device": { + "dial_state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "failed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -23066,541 +27309,503 @@ "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" }, - "node_id": { + "tag": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "project_id": { + "terminal": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" + } + } + }, + "EchoEvent": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "", + "kind": "keyword", + "name": "state", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" + } + ], + "returns": "void" }, - "segment_id": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "tag": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "CallStateEvent": { + "FaxEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "call_state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "end_reason", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "direction", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "device", - "type": "dict", + "default": {}, "kind": "keyword", + "name": "fax", "required": false, - "default": null + "type": "dict" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "call_state": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "device": { + "fax": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" - }, - "end_reason": { + } + } + }, + "HoldEvent": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": "", + "kind": "keyword", + "name": "state", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" } ], - "returns": "any" + "returns": "void" }, "from_payload": { "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" }, - "terminal": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "CallingErrorEvent": { + "MessageReceiveEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "code", - "type": "string", + "default": "", "kind": "keyword", + "name": "message_id", "required": false, - "default": null + "type": "string" }, { - "name": "message", - "type": "string", + "default": "", "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "void" - }, - "code": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_payload": { - "params": [ - { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "message": { - "params": [ + "default": "", + "kind": "keyword", + "name": "direction", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "CollectEvent": { - "methods": { - "__init__": { - "params": [ + "default": "", + "kind": "keyword", + "name": "from_number", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" + "default": "", + "kind": "keyword", + "name": "to_number", + "required": false, + "type": "string" }, { - "name": "control_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "body", "required": false, - "default": null + "type": "string" }, { - "name": "state", - "type": "string", + "default": [], "kind": "keyword", + "name": "media", "required": false, - "default": null + "type": "list" }, { - "name": "result", - "type": "dict", + "default": 0, "kind": "keyword", + "name": "segments", "required": false, - "default": null + "type": "int" }, { - "name": "final", - "type": "optional", + "default": "", + "kind": "keyword", + "name": "message_state", + "required": false, + "type": "string" + }, + { + "default": [], "kind": "keyword", + "name": "tags", "required": false, - "default": null + "type": "list" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "control_id": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "final": { + "context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "direction": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "result": { + "from_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "state": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" - } - } - }, - "ConferenceEvent": { - "methods": { - "__init__": { + }, + "media": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "conference_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "name", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "status", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "message_id": { + "params": [ { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "conference_id": { + "message_state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "segments": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "name": { + "tags": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status": { + "to_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "ConnectEvent": { + "MessageStateEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "connect_state", - "type": "string", + "default": "", "kind": "keyword", + "name": "message_id", "required": false, - "default": null + "type": "string" }, { - "name": "peer", - "type": "dict", + "default": "", "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", - "kind": "var_keyword", + "default": "", + "kind": "keyword", + "name": "direction", "required": false, - "default": null - } - ], - "returns": "void" - }, - "connect_state": { - "params": [ + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_payload": { - "params": [ + "default": "", + "kind": "keyword", + "name": "from_number", + "required": false, + "type": "string" + }, { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "peer": { - "params": [ + "default": "", + "kind": "keyword", + "name": "to_number", + "required": false, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - } - } - }, - "DenoiseEvent": { - "methods": { - "__init__": { - "params": [ + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": [], + "kind": "keyword", + "name": "media", + "required": false, + "type": "list" + }, { - "name": "self", - "kind": "self" + "default": 0, + "kind": "keyword", + "name": "segments", + "required": false, + "type": "int" }, { - "name": "denoised", - "type": "bool", + "default": "", "kind": "keyword", + "name": "message_state", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": "", + "kind": "keyword", + "name": "reason", + "required": false, + "type": "string" + }, + { + "default": [], + "kind": "keyword", + "name": "tags", + "required": false, + "type": "list" + }, + { + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "denoised": { + "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "context": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "DetectEvent": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "detect", - "type": "dict", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "void" }, - "control_id": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "detect": { + "from_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -23609,150 +27814,133 @@ "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" - } - } - }, - "DialEvent": { - "methods": { - "__init__": { + }, + "media": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "tag", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "dial_state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "call_data", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "answered": { + "message_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "call_data": { + "message_state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "dial_state": { + "reason": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "failed": { + "segments": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "tags": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tag": { + "terminal": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminal": { + "to_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "EchoEvent": { + "PayEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "state", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": "", + "kind": "keyword", + "name": "state", + "required": false, + "type": "string" + }, + { + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, + "control_id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, "from_payload": { "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" @@ -23760,42 +27948,42 @@ "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "FaxEvent": { + "PlayEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "fax", - "type": "dict", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" @@ -23803,512 +27991,564 @@ "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "fax": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "from_payload": { + "state": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "HoldEvent": { + "QueueEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "state", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": "", + "kind": "keyword", + "name": "status", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "queue_id", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "queue_name", + "required": false, + "type": "string" + }, + { + "default": 0, + "kind": "keyword", + "name": "position", + "required": false, + "type": "int" + }, + { + "default": 0, + "kind": "keyword", + "name": "size", + "required": false, + "type": "int" + }, + { + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, + "control_id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, "from_payload": { "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" }, - "state": { + "position": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "queue_id": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "queue_name": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "size": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "status": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "MessageReceiveEvent": { + "RecordEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "message_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "context", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "direction", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "from_number", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "to_number", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "body", - "type": "string", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "media", - "type": "list", + "default": "", "kind": "keyword", + "name": "url", "required": false, - "default": null + "type": "string" }, { - "name": "segments", - "type": "int", + "default": 0.0, "kind": "keyword", + "name": "duration", "required": false, - "default": null + "type": "float" }, { - "name": "message_state", - "type": "string", + "default": 0, "kind": "keyword", + "name": "size", "required": false, - "default": null + "type": "int" }, { - "name": "tags", - "type": "list", + "default": {}, "kind": "keyword", + "name": "record", "required": false, - "default": null + "type": "dict" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "body": { + "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "context": { + "duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "from_number": { + "record": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "size": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "media": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "message_id": { + "url": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + }, + "ReferEvent": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "default": "", + "kind": "keyword", + "name": "state", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "sip_refer_to", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "sip_refer_response_code", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "sip_notify_response_code", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "var_keyword", + "name": "base", + "required": false, + "type": "any" + } + ], + "returns": "void" + }, + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "message_state": { + "sip_notify_response_code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "segments": { + "sip_refer_response_code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tags": { + "sip_refer_to": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_number": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "MessageStateEvent": { + "RelayEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "message_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "context", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "direction", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "from_number", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "to_number", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "body", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "media", - "type": "list", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "segments", - "type": "int", "kind": "keyword", - "required": false, - "default": null + "name": "event_type", + "required": true, + "type": "string" }, { - "name": "message_state", - "type": "string", + "default": {}, "kind": "keyword", + "name": "params", "required": false, - "default": null + "type": "dict" }, { - "name": "reason", - "type": "string", + "default": "", "kind": "keyword", + "name": "call_id", "required": false, - "default": null + "type": "string" }, { - "name": "tags", - "type": "list", + "default": 0.0, "kind": "keyword", + "name": "timestamp", "required": false, - "default": null - }, - { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "type": "float" } ], "returns": "void" }, - "body": { + "call_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "context": { + "deconstruct": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "deconstruct_keys": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_number": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "keys", + "required": true, + "type": "any" } ], "returns": "any" }, - "from_payload": { + "eql": { "params": [ { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "media": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "name": "other", + "required": true, + "type": "any" } ], "returns": "any" }, - "message_id": { + "event_type": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "message_state": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "reason": { + "hash": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "segments": { + "params": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tags": { + "timestamp": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminal": { + "to_h": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_number": { + "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "default": null, + "kind": "var_positional", + "name": "*", + "required": false, + "type": "any" } ], "returns": "any" } } }, - "PayEvent": { + "SendDigitsEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "state", - "type": "string", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" @@ -24316,8 +28556,8 @@ "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24326,8 +28566,8 @@ "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" @@ -24335,42 +28575,56 @@ "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "PlayEvent": { + "StreamEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { + "default": "", + "kind": "keyword", "name": "state", - "type": "string", + "required": false, + "type": "string" + }, + { + "default": "", "kind": "keyword", + "name": "url", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", + "default": "", + "kind": "keyword", + "name": "name", + "required": false, + "type": "string" + }, + { + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" @@ -24378,8 +28632,8 @@ "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24388,8 +28642,17 @@ "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" + } + ], + "returns": "any" + }, + "name": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24397,70 +28660,65 @@ "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "url": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "QueueEvent": { + "TapEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "status", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "queue_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "queue_name", - "type": "string", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "position", - "type": "int", + "default": {}, "kind": "keyword", + "name": "tap", "required": false, - "default": null + "type": "dict" }, { - "name": "size", - "type": "int", + "default": {}, "kind": "keyword", + "name": "device", "required": false, - "default": null + "type": "dict" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" @@ -24468,125 +28726,107 @@ "control_id": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_payload": { - "params": [ - { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "position": { - "params": [ - { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "queue_id": { + "device": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "queue_name": { + "from_payload": { "params": [ { - "name": "self", - "kind": "self" + "name": "payload", + "required": true, + "type": "dict" } ], "returns": "any" }, - "size": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status": { + "tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } }, - "RecordEvent": { + "TranscribeEvent": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", + "default": "", "kind": "keyword", + "name": "control_id", "required": false, - "default": null + "type": "string" }, { - "name": "state", - "type": "string", + "default": "", "kind": "keyword", + "name": "state", "required": false, - "default": null + "type": "string" }, { - "name": "url", - "type": "string", + "default": "", "kind": "keyword", + "name": "url", "required": false, - "default": null + "type": "string" }, { - "name": "duration", - "type": "float", + "default": "", "kind": "keyword", + "name": "recording_id", "required": false, - "default": null + "type": "string" }, { - "name": "size", - "type": "int", + "default": 0.0, "kind": "keyword", + "name": "duration", "required": false, - "default": null + "type": "float" }, { - "name": "record", - "type": "dict", + "default": 0, "kind": "keyword", + "name": "size", "required": false, - "default": null + "type": "int" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "base", "required": false, - "default": null + "type": "any" } ], "returns": "void" @@ -24594,8 +28834,8 @@ "control_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24603,8 +28843,8 @@ "duration": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24613,17 +28853,17 @@ "params": [ { "name": "payload", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" }, - "record": { + "recording_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24631,8 +28871,8 @@ "size": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24640,8 +28880,8 @@ "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -24649,741 +28889,800 @@ "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - }, - "ReferEvent": { + } + }, + "functions": { + "parse_event": { + "params": [ + { + "name": "payload", + "required": true, + "type": "dict" + } + ], + "returns": "any" + } + } + }, + "signalwire.relay.message": { + "classes": { + "Message": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "state", - "type": "string", + "default": "", "kind": "keyword", + "name": "message_id", "required": false, - "default": null + "type": "string" }, { - "name": "sip_refer_to", - "type": "string", + "default": "", "kind": "keyword", + "name": "context", "required": false, - "default": null + "type": "string" }, { - "name": "sip_refer_response_code", - "type": "string", + "default": "", "kind": "keyword", + "name": "direction", "required": false, - "default": null + "type": "string" }, { - "name": "sip_notify_response_code", - "type": "string", + "default": "", "kind": "keyword", + "name": "from_number", "required": false, - "default": null + "type": "string" }, { - "name": "base", - "type": "any", - "kind": "var_keyword", + "default": "", + "kind": "keyword", + "name": "to_number", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "body", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "media", + "required": false, + "type": "optional>" + }, + { + "default": 0, + "kind": "keyword", + "name": "segments", + "required": false, + "type": "int" + }, + { + "default": "", + "kind": "keyword", + "name": "state", + "required": false, + "type": "string" + }, + { + "default": "", + "kind": "keyword", + "name": "reason", + "required": false, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "tags", "required": false, - "default": null + "type": "optional>" } ], "returns": "void" }, - "from_payload": { + "body": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sip_notify_response_code": { + "context": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sip_refer_response_code": { + "direction": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "sip_refer_to": { + "done": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "state": { + "from_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "RelayEvent": { - "methods": { - "__init__": { + }, + "is_done": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "event_type", - "type": "string", - "kind": "keyword", - "required": true - }, - { - "name": "params", - "type": "dict", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "call_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "timestamp", - "type": "float", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "call_id": { + "media": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "deconstruct": { + "message_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "deconstruct_keys": { + "on": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "keys", - "type": "any", - "required": true + "name": "handler", + "required": true, + "type": "callable,any>" + }, + { + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "eql": { + "on_completed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "other", - "type": "any", - "required": true + "default": null, + "kind": "keyword", + "name": "block", + "required": false, + "type": "any" } ], "returns": "any" }, - "event_type": { + "reason": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "result": { "params": [ { - "name": "payload", - "type": "dict", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "hash": { + "segments": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "state": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "timestamp": { + "tags": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_h": { + "terminal": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_json": { + "to_h": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "*", - "type": "any", - "kind": "var_positional", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SendDigitsEvent": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "base", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "void" }, - "control_id": { + "to_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "wait": { "params": [ { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "state": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" + "default": null, + "kind": "keyword", + "name": "timeout", + "required": false, + "type": "optional" } ], "returns": "any" } } + } + } + }, + "signalwire.relay.message_state": { + "functions": { + "terminal": { + "params": [ + { + "name": "state", + "required": true, + "type": "any" + } + ], + "returns": "any" }, - "StreamEvent": { + "valid": { + "params": [ + { + "name": "state", + "required": true, + "type": "any" + } + ], + "returns": "any" + } + } + }, + "signalwire.rest._base": { + "classes": { + "BaseResource": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "http", + "required": true, + "type": "class:signalwire.rest._base.HttpClient" }, { - "name": "state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null - }, + "name": "base_path", + "required": true, + "type": "string" + } + ], + "returns": "void" + } + } + }, + "CrudResource": { + "methods": { + "create": { + "params": [ { - "name": "url", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "base", - "type": "any", + "default": null, "kind": "var_keyword", - "required": false, - "default": null - } - ], - "returns": "void" - }, - "control_id": { - "params": [ - { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_payload": { - "params": [ - { - "name": "payload", - "type": "dict", - "required": true + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "name": { + "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "resource_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "state": { + "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "resource_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" } ], "returns": "any" }, - "url": { + "update_method": { + "params": [], + "returns": "any" + } + } + }, + "CrudWithAddresses": { + "methods": { + "list_addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "resource_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "var_keyword", + "name": "params", + "required": false, + "type": "any" } ], "returns": "any" } } }, - "TapEvent": { + "HttpClient": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "project", + "required": true, + "type": "string" }, { - "name": "state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "token", + "required": true, + "type": "string" }, { - "name": "tap", - "type": "dict", - "kind": "keyword", + "name": "host", + "required": true, + "type": "string" + }, + { + "default": null, + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "device", - "type": "dict", + "default": null, "kind": "keyword", + "name": "base_url", "required": false, - "default": null + "type": "any" }, { - "name": "base", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "ca_file", "required": false, - "default": null + "type": "any" } ], "returns": "void" }, - "control_id": { + "base_url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "device": { + "delete": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "from_payload": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "payload", - "type": "dict", - "required": true + "name": "path", + "required": true, + "type": "string" + }, + { + "default": null, + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "state": { + "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "path", + "required": true, + "type": "string" + }, + { + "default": null, + "name": "params", + "required": false, + "type": "optional>" + }, + { + "default": null, + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "tap": { + "inspect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "TranscribeEvent": { - "methods": { - "__init__": { + }, + "patch": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "control_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "path", + "required": true, + "type": "string" }, { - "name": "state", - "type": "string", - "kind": "keyword", + "default": null, + "name": "body", "required": false, - "default": null + "type": "any" }, { - "name": "url", - "type": "string", - "kind": "keyword", + "default": null, + "name": "request_options", "required": false, - "default": null + "type": "optional" + } + ], + "returns": "any" + }, + "post": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "recording_id", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "path", + "required": true, + "type": "string" }, { - "name": "duration", - "type": "float", - "kind": "keyword", + "default": null, + "name": "body", "required": false, - "default": null + "type": "any" }, { - "name": "size", - "type": "int", + "default": null, "kind": "keyword", + "name": "params", "required": false, - "default": null + "type": "optional>" }, { - "name": "base", - "type": "any", - "kind": "var_keyword", + "default": null, + "name": "request_options", "required": false, - "default": null - } - ], - "returns": "void" - }, - "control_id": { - "params": [ - { - "name": "self", - "kind": "self" + "type": "optional" } ], "returns": "any" }, - "duration": { + "project_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_payload": { + "put": { "params": [ { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, - "recording_id": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "size": { - "params": [ + "name": "path", + "required": true, + "type": "string" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "state": { - "params": [ + "default": null, + "name": "body", + "required": false, + "type": "any" + }, { - "name": "self", - "kind": "self" + "default": null, + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "url": { + "to_s": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" } } - } - }, - "functions": { - "parse_event": { - "params": [ - { - "name": "payload", - "type": "dict", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.relay.message": { - "classes": { - "Message": { + }, + "ReadResource": { "methods": { - "__init__": { + "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "message_id", - "type": "string", + "name": "resource_id", + "required": true, + "type": "string" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null - }, + "type": "optional" + } + ], + "returns": "any" + }, + "list": { + "params": [ { - "name": "context", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "direction", - "type": "string", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "from_number", - "type": "string", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" + } + ], + "returns": "any" + }, + "paginate": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "to_number", - "type": "string", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "body", - "type": "string", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" + } + ], + "returns": "any" + } + } + }, + "SignalWireRestError": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "media", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "name": "status_code", + "required": true, + "type": "optional" }, { - "name": "segments", - "type": "int", - "kind": "keyword", - "required": false, - "default": null + "name": "body", + "required": true, + "type": "any" }, { - "name": "state", - "type": "string", - "kind": "keyword", - "required": false, - "default": null + "name": "url", + "required": true, + "type": "string" }, { - "name": "reason", - "type": "string", - "kind": "keyword", + "default": "GET", + "name": "method", "required": false, - "default": null + "type": "string" }, { - "name": "tags", - "type": "optional>", - "kind": "keyword", + "default": null, + "name": "headers", "required": false, - "default": null + "type": "optional>" } ], "returns": "void" @@ -25391,191 +29690,208 @@ "body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "context": { + "headers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "direction": { + "method": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "done": { + "request_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "from_number": { + "status_code": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "is_done": { + "url": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - }, - "media": { + } + } + }, + "SignalWireRestTransportError": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "message_id": { - "params": [ + "kind": "self", + "name": "self" + }, { - "name": "self", - "kind": "self" - } - ], - "returns": "any" - }, - "on_completed": { - "params": [ + "name": "body", + "required": true, + "type": "any" + }, { - "name": "self", - "kind": "self" + "name": "url", + "required": true, + "type": "string" }, { - "name": "block", - "type": "any", - "kind": "keyword", + "default": "GET", + "name": "method", "required": false, - "default": null + "type": "string" } ], - "returns": "any" - }, - "reason": { + "returns": "void" + } + } + } + } + }, + "signalwire.rest._pagination": { + "classes": { + "PaginatedIterator": { + "methods": { + "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "http", + "required": true, + "type": "class:signalwire.rest._base.HttpClient" + }, + { + "name": "path", + "required": true, + "type": "string" + }, + { + "default": null, + "name": "params", + "required": false, + "type": "optional>" + }, + { + "default": "data", + "name": "data_key", + "required": false, + "type": "string" + }, + { + "default": null, + "name": "request_options", + "required": false, + "type": "optional" } ], - "returns": "any" + "returns": "void" }, - "result": { + "data_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "segments": { + "done": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "state": { + "each": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "tags": { + "http": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "terminal": { + "index": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_h": { + "items": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "to_number": { + "next_item": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "wait": { + "params": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "timeout", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "on": { + "path": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "handler", - "type": "callable,any>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" @@ -25584,613 +29900,442 @@ } } }, - "signalwire.relay.message_state": { - "functions": { - "terminal": { - "params": [ - { - "name": "state", - "type": "any", - "required": true - } - ], - "returns": "any" - }, - "valid": { - "params": [ - { - "name": "state", - "type": "any", - "required": true - } - ], - "returns": "any" - } - } - }, - "signalwire.rest._base": { + "signalwire.rest._request_options": { "classes": { - "BaseResource": { + "RequestOptions": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "http", - "type": "class:signalwire.rest._base.HttpClient", - "required": true + "default": null, + "name": "timeout", + "required": false, + "type": "optional" }, { - "name": "base_path", - "type": "string", - "required": true + "default": null, + "name": "retries", + "required": false, + "type": "optional" + }, + { + "default": null, + "name": "retry_on_status", + "required": false, + "type": "optional>" + }, + { + "default": null, + "name": "retry_backoff", + "required": false, + "type": "optional" + }, + { + "default": null, + "name": "abort_signal", + "required": false, + "type": "optional" } ], "returns": "void" - } - } - }, - "CrudResource": { - "methods": { - "create": { + }, + "abort_signal": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "delete": { + "merge": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "resource_id", - "type": "string", - "required": true + "name": "override", + "required": true, + "type": "optional" } ], "returns": "any" }, - "update": { + "retries": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "resource_id", - "type": "string", - "required": true - }, - { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "update_method": { - "params": [], - "returns": "any" - } - } - }, - "CrudWithAddresses": { - "methods": { - "list_addresses": { + "retry_backoff": { "params": [ { - "name": "self", - "kind": "self" - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "retry_on_status": { + "params": [ { - "name": "resource_id", - "type": "string", - "required": true - }, + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "timeout": { + "params": [ { - "name": "params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" } } + } + }, + "functions": { + "resolve": { + "params": [ + { + "name": "client_default", + "required": true, + "type": "optional" + }, + { + "name": "per_request", + "required": true, + "type": "optional" + } + ], + "returns": "any" }, - "HttpClient": { + "status_is_retryable": { + "params": [ + { + "name": "method", + "required": true, + "type": "string" + }, + { + "name": "status", + "required": true, + "type": "int" + }, + { + "name": "opts", + "required": true, + "type": "class:signalwire.rest._request_options._EffectiveOptions" + } + ], + "returns": "any" + } + } + }, + "signalwire.rest.client": { + "classes": { + "RestClient": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, + "kind": "keyword", "name": "project", - "type": "string", - "required": true + "required": false, + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "token", - "type": "string", - "required": true + "required": false, + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "host", - "type": "string", - "required": true + "required": false, + "type": "optional" }, { - "name": "base_url", - "type": "any", + "default": null, "kind": "keyword", + "name": "base_url", "required": false, - "default": null + "type": "any" }, { - "name": "ca_file", - "type": "any", + "default": null, "kind": "keyword", + "name": "ca_file", "required": false, - "default": null + "type": "any" + }, + { + "default": null, + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "void" }, - "base_url": { + "addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "delete": { + "calling": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get": { + "chat": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "optional>", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "patch": { + "datasphere": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "any", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "post": { + "fabric": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "any", - "required": false, - "default": null - }, - { - "name": "params", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "project_id": { + "generated_http_client": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "put": { + "http": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "body", - "type": "any", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "ReadResource": { - "methods": { - "get": { + }, + "imported_numbers": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "resource_id", - "type": "string", - "required": true + "kind": "self", + "name": "self" } ], "returns": "any" }, - "list": { + "inspect": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" }, - "paginate": { + "logs": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "params", - "type": "any", - "kind": "var_keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - }, - "SignalWireRestError": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "status_code", - "type": "int", - "required": true - }, - { - "name": "body", - "type": "any", - "required": true - }, - { - "name": "url", - "type": "string", - "required": true - }, - { - "name": "method", - "type": "string", - "required": false, - "default": null - } - ], - "returns": "void" }, - "body": { + "lookup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "method_name": { + "messages": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "status_code": { + "mfa": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "url": { + "number_groups": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.rest._pagination": { - "classes": { - "PaginatedIterator": { - "methods": { - "__init__": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "http", - "type": "class:signalwire.rest._base.HttpClient", - "required": true - }, - { - "name": "path", - "type": "string", - "required": true - }, - { - "name": "params", - "type": "optional>", - "required": false, - "default": null - }, - { - "name": "data_key", - "type": "string", - "required": false, - "default": null - } - ], - "returns": "void" }, - "data_key": { + "phone_numbers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "done": { + "project": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "each": { + "project_id": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "http": { + "projects": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "index": { + "pubsub": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "items": { + "queues": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "next_item": { + "recordings": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "params": { + "registry": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "path": { + "short_codes": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" - } - } - } - } - }, - "signalwire.rest.client": { - "classes": { - "RestClient": { - "methods": { - "__init__": { + }, + "sip_profile": { "params": [ { - "name": "self", - "kind": "self" - }, - { - "name": "project", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "token", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "host", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "base_url", - "type": "any", - "kind": "keyword", - "required": false, - "default": null - }, - { - "name": "ca_file", - "type": "any", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" } ], - "returns": "void" + "returns": "any" }, - "generated_http_client": { + "to_s": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "http": { + "verified_callers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "project_id": { + "video": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26206,13 +30351,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26220,8 +30365,8 @@ "documents": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26233,13 +30378,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26247,8 +30392,8 @@ "addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26256,8 +30401,8 @@ "ai_agents": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26265,8 +30410,8 @@ "call_flows": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26274,8 +30419,8 @@ "conference_rooms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26283,8 +30428,8 @@ "cxml_applications": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26292,8 +30437,8 @@ "cxml_scripts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26301,8 +30446,8 @@ "cxml_webhooks": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26310,8 +30455,8 @@ "freeswitch_connectors": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26319,8 +30464,8 @@ "relay_applications": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26328,8 +30473,8 @@ "resources": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26337,8 +30482,8 @@ "sip_endpoints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26346,8 +30491,8 @@ "sip_gateways": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26355,8 +30500,8 @@ "subscribers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26364,8 +30509,8 @@ "swml_scripts": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26373,8 +30518,8 @@ "swml_webhooks": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26382,8 +30527,8 @@ "tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26395,13 +30540,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26409,8 +30554,8 @@ "conferences": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26418,8 +30563,8 @@ "fax": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26427,8 +30572,8 @@ "messages": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26436,8 +30581,8 @@ "voice": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26449,13 +30594,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26463,8 +30608,8 @@ "tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26476,13 +30621,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26490,8 +30635,8 @@ "brands": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26499,8 +30644,8 @@ "campaigns": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26508,8 +30653,8 @@ "numbers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26517,8 +30662,8 @@ "orders": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26530,13 +30675,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26544,8 +30689,8 @@ "conference_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26553,8 +30698,8 @@ "conferences": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26562,8 +30707,8 @@ "room_recordings": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26571,8 +30716,8 @@ "room_sessions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26580,8 +30725,8 @@ "room_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26589,8 +30734,8 @@ "rooms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26598,8 +30743,8 @@ "streams": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -26615,13 +30760,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -26629,8 +30774,8 @@ "ai_hold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26660,11 +30805,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26672,8 +30817,8 @@ "ai_message": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26717,11 +30862,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26729,8 +30874,8 @@ "ai_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26752,11 +30897,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26764,8 +30909,8 @@ "ai_unhold": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26788,11 +30933,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26800,8 +30945,8 @@ "collect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26859,11 +31004,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26871,8 +31016,8 @@ "collect_start_input_timers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26894,11 +31039,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26906,8 +31051,8 @@ "collect_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26929,11 +31074,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26941,8 +31086,8 @@ "denoise": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26958,11 +31103,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26970,8 +31115,8 @@ "denoise_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -26987,11 +31132,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -26999,8 +31144,8 @@ "detect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27036,11 +31181,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27048,8 +31193,8 @@ "detect_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27071,11 +31216,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27083,8 +31228,8 @@ "dial": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -27162,11 +31307,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27174,8 +31319,8 @@ "disconnect": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27191,11 +31336,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27203,8 +31348,8 @@ "end": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27227,11 +31372,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27239,8 +31384,8 @@ "live_transcribe": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27262,11 +31407,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27274,8 +31419,8 @@ "live_translate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27304,11 +31449,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27316,8 +31461,8 @@ "play": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27374,11 +31519,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27386,8 +31531,8 @@ "play_pause": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27409,11 +31554,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27421,8 +31566,8 @@ "play_resume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27444,11 +31589,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27456,8 +31601,8 @@ "play_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27479,11 +31624,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27491,8 +31636,8 @@ "play_volume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27520,11 +31665,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27532,8 +31677,8 @@ "receive_fax_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27555,11 +31700,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27567,8 +31712,8 @@ "record": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27605,11 +31750,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27617,8 +31762,8 @@ "record_pause": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27640,11 +31785,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27652,8 +31797,8 @@ "record_resume": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27675,11 +31820,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27687,8 +31832,8 @@ "record_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27710,11 +31855,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27722,8 +31867,8 @@ "refer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27752,11 +31897,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27764,8 +31909,8 @@ "send_fax_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27787,11 +31932,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27799,8 +31944,8 @@ "stream": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27857,11 +32002,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27869,8 +32014,8 @@ "stream_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27892,11 +32037,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27904,8 +32049,8 @@ "tap": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27940,11 +32085,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27952,8 +32097,8 @@ "tap_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -27975,11 +32120,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -27987,8 +32132,8 @@ "transcribe": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28018,11 +32163,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28030,8 +32175,8 @@ "transcribe_stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28053,11 +32198,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28065,8 +32210,8 @@ "transfer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28088,11 +32233,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28100,8 +32245,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -28152,11 +32297,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28164,8 +32309,8 @@ "user_event": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28187,11 +32332,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28207,13 +32352,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -28221,8 +32366,8 @@ "create_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -28258,11 +32403,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28278,13 +32423,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -28292,13 +32437,20 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "body", - "type": "class:signalwire.rest.namespaces.datasphere_types_generated.DocumentCreateRequest", - "required": true + "required": true, + "type": "class:signalwire.rest.namespaces.datasphere_types_generated.DocumentCreateRequest" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -28306,13 +32458,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -28320,8 +32479,8 @@ "delete_chunk": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28334,6 +32493,13 @@ "name": "chunk_id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -28341,8 +32507,8 @@ "get_chunk": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28357,11 +32523,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28369,8 +32535,8 @@ "list_chunks": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28379,11 +32545,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28391,8 +32557,8 @@ "search": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -28457,11 +32623,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28469,33 +32635,40 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "tags", - "type": "optional>", "kind": "keyword", - "required": true + "name": "tags", + "required": true, + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -28511,13 +32684,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -28525,97 +32698,104 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "prompt", - "type": "class:signalwire.rest.namespaces.fabric_types_generated.AIPrompt", "kind": "keyword", - "required": true + "name": "prompt", + "required": true, + "type": "class:signalwire.rest.namespaces.fabric_types_generated.AIPrompt" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "global_data", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "global_data", "required": false, - "default": null + "type": "optional>" }, { - "name": "hints", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "hints", "required": false, - "default": null + "type": "optional>>" }, { - "name": "languages", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "languages", "required": false, - "default": null + "type": "optional>" }, { - "name": "params", - "type": "optional", + "default": null, "kind": "keyword", + "name": "params", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "post_prompt", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "post_prompt_url", "required": false, - "default": null + "type": "optional" }, { - "name": "pronounce", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "pronounce", "required": false, - "default": null + "type": "optional>" }, { - "name": "SWAIG", - "type": "optional", + "default": null, "kind": "keyword", + "name": "SWAIG", "required": false, - "default": null + "type": "optional" }, { - "name": "agent_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "agent_id", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -28623,104 +32803,111 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "global_data", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "global_data", "required": false, - "default": null + "type": "optional>" }, { - "name": "hints", - "type": "optional>>", + "default": null, "kind": "keyword", + "name": "hints", "required": false, - "default": null + "type": "optional>>" }, { - "name": "languages", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "languages", "required": false, - "default": null + "type": "optional>" }, { - "name": "params", - "type": "optional", + "default": null, "kind": "keyword", + "name": "params", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "post_prompt", "required": false, - "default": null + "type": "optional" }, { - "name": "post_prompt_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "post_prompt_url", "required": false, - "default": null + "type": "optional" }, { - "name": "pronounce", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "pronounce", "required": false, - "default": null + "type": "optional>" }, { - "name": "prompt", - "type": "optional", + "default": null, "kind": "keyword", + "name": "prompt", "required": false, - "default": null + "type": "optional" }, { - "name": "SWAIG", - "type": "optional", + "default": null, "kind": "keyword", + "name": "SWAIG", "required": false, - "default": null + "type": "optional" }, { - "name": "agent_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "agent_id", "required": false, - "default": null + "type": "optional" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -28732,13 +32919,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -28746,28 +32933,35 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "title", - "type": "string", "kind": "keyword", - "required": true + "name": "title", + "required": true, + "type": "string" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -28775,8 +32969,8 @@ "deploy_version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28789,6 +32983,13 @@ "name": "body", "required": true, "type": "dict" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -28796,8 +32997,8 @@ "list_addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28806,11 +33007,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28818,8 +33019,8 @@ "list_versions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -28828,11 +33029,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -28840,41 +33041,48 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "title", - "type": "optional", + "default": null, "kind": "keyword", + "name": "title", "required": false, - "default": null + "type": "optional" }, { - "name": "document_version", - "type": "optional", + "default": null, "kind": "keyword", + "name": "document_version", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -28886,13 +33094,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -28900,139 +33108,146 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "enable_room_previews", - "type": "bool", "kind": "keyword", - "required": true + "name": "enable_room_previews", + "required": true, + "type": "bool" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "description", - "type": "optional", + "default": null, "kind": "keyword", + "name": "description", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "max_members", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_members", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_at", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_at", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_after_seconds_elapsed", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_after_seconds_elapsed", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "meta", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "meta", "required": false, - "default": null + "type": "optional>" }, { - "name": "sync_audio_video", - "type": "optional", + "default": null, "kind": "keyword", + "name": "sync_audio_video", "required": false, - "default": null + "type": "optional" }, { - "name": "tone_on_entry_and_exit", - "type": "optional", + "default": null, "kind": "keyword", + "name": "tone_on_entry_and_exit", "required": false, - "default": null + "type": "optional" }, { - "name": "room_join_video_off", - "type": "optional", + "default": null, "kind": "keyword", + "name": "room_join_video_off", "required": false, - "default": null + "type": "optional" }, { - "name": "user_join_video_off", - "type": "optional", + "default": null, "kind": "keyword", + "name": "user_join_video_off", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29040,8 +33255,8 @@ "list_addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -29050,11 +33265,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29062,144 +33277,151 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "enable_room_previews", - "type": "optional", "kind": "keyword", - "required": true + "name": "enable_room_previews", + "required": true, + "type": "optional" }, { - "name": "sync_audio_video", - "type": "optional", "kind": "keyword", - "required": true + "name": "sync_audio_video", + "required": true, + "type": "optional" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "description", - "type": "optional", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_members", "required": false, - "default": null + "type": "optional" }, { - "name": "max_members", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_at", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_at", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_after_seconds_elapsed", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_after_seconds_elapsed", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "meta", "required": false, - "default": null + "type": "optional>" }, { - "name": "meta", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "tone_on_entry_and_exit", "required": false, - "default": null + "type": "optional" }, { - "name": "tone_on_entry_and_exit", - "type": "optional", + "default": null, "kind": "keyword", + "name": "room_join_video_off", "required": false, - "default": null + "type": "optional" }, { - "name": "room_join_video_off", - "type": "optional", + "default": null, "kind": "keyword", + "name": "user_join_video_off", "required": false, - "default": null + "type": "optional" }, { - "name": "user_join_video_off", - "type": "optional", + "default": {}, "kind": "keyword", + "name": "extras", "required": false, - "default": null + "type": "optional>" }, { - "name": "extras", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29211,13 +33433,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -29225,14 +33447,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -29240,8 +33469,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -29250,11 +33479,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29262,15 +33491,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29278,8 +33507,8 @@ "list_addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -29288,11 +33517,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29300,8 +33529,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -29415,11 +33644,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29431,13 +33660,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -29445,48 +33674,55 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "display_name", - "type": "string", "kind": "keyword", - "required": true + "name": "display_name", + "required": true, + "type": "string" }, { - "name": "contents", - "type": "string", "kind": "keyword", - "required": true + "name": "contents", + "required": true, + "type": "string" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "status_callback_method", "required": false, - "default": null + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29494,55 +33730,62 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "contents", - "type": "optional", + "default": null, "kind": "keyword", + "name": "contents", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "status_callback_method", "required": false, - "default": null + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29554,13 +33797,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -29568,77 +33811,84 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "primary_request_url", - "type": "string", "kind": "keyword", - "required": true + "name": "primary_request_url", + "required": true, + "type": "string" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "used_for", - "type": "optional", + "default": null, "kind": "keyword", + "name": "used_for", "required": false, - "default": null + "type": "optional" }, { - "name": "primary_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "primary_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "fallback_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "fallback_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "fallback_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "fallback_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "status_callback_method", "required": false, - "default": null + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29646,83 +33896,90 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "used_for", - "type": "optional", + "default": null, "kind": "keyword", + "name": "used_for", "required": false, - "default": null + "type": "optional" }, { - "name": "primary_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "primary_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "primary_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "primary_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "fallback_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "fallback_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "fallback_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "fallback_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "status_callback_method", "required": false, - "default": null + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29734,13 +33991,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -29748,13 +34005,20 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -29762,15 +34026,22 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29778,15 +34049,22 @@ "paginate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -29798,13 +34076,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -29812,8 +34090,8 @@ "create_embed_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -29829,11 +34107,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29841,8 +34119,8 @@ "create_guest_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -29865,11 +34143,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29877,8 +34155,8 @@ "create_invite_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -29901,11 +34179,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -29913,8 +34191,8 @@ "create_subscriber_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -30005,13 +34283,13 @@ "name": "extras", "required": false, "type": "optional>" - }, - { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30019,8 +34297,8 @@ "refresh_subscriber_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -30036,11 +34314,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30052,13 +34330,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30066,34 +34344,41 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "token", - "type": "class:signalwire.rest.namespaces.fabric_types_generated.uuid", "kind": "keyword", - "required": true + "name": "token", + "required": true, + "type": "class:signalwire.rest.namespaces.fabric_types_generated.uuid" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30101,48 +34386,55 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "caller_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "caller_id", "required": false, - "default": null + "type": "optional" }, { - "name": "send_as", - "type": "optional", + "default": null, "kind": "keyword", + "name": "send_as", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30154,13 +34446,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30168,8 +34460,8 @@ "assign_domain_application": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30191,11 +34483,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30203,8 +34495,8 @@ "assign_phone_route": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30232,11 +34524,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30244,14 +34536,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -30259,8 +34558,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30269,11 +34568,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30281,15 +34580,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30297,8 +34596,8 @@ "list_addresses": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30307,11 +34606,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30323,13 +34622,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30337,41 +34636,48 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "topic", - "type": "string", "kind": "keyword", - "required": true + "name": "topic", + "required": true, + "type": "string" }, { - "name": "call_status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_status_callback_url", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30379,48 +34685,55 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "topic", - "type": "optional", + "default": null, "kind": "keyword", + "name": "topic", "required": false, - "default": null + "type": "optional" }, { - "name": "call_status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_status_callback_url", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30432,13 +34745,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30446,77 +34759,84 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "username", - "type": "string", "kind": "keyword", - "required": true + "name": "username", + "required": true, + "type": "string" }, { - "name": "caller_id", - "type": "string", "kind": "keyword", - "required": true + "name": "caller_id", + "required": true, + "type": "string" }, { - "name": "send_as", - "type": "string", "kind": "keyword", - "required": true + "name": "send_as", + "required": true, + "type": "string" }, { - "name": "ciphers", - "type": "list", "kind": "keyword", - "required": true + "name": "ciphers", + "required": true, + "type": "list" }, { - "name": "codecs", - "type": "list", "kind": "keyword", - "required": true + "name": "codecs", + "required": true, + "type": "list" }, { - "name": "encryption", - "type": "class:signalwire.rest.namespaces.fabric_types_generated.Encryption", "kind": "keyword", - "required": true + "name": "encryption", + "required": true, + "type": "class:signalwire.rest.namespaces.fabric_types_generated.Encryption" }, { - "name": "call_handler", - "type": "class:signalwire.rest.namespaces.fabric_types_generated.CallHandlerType", "kind": "keyword", - "required": true + "name": "call_handler", + "required": true, + "type": "class:signalwire.rest.namespaces.fabric_types_generated.CallHandlerType" }, { - "name": "calling_handler_resource_id", - "type": "optional", "kind": "keyword", - "required": true + "name": "calling_handler_resource_id", + "required": true, + "type": "optional" }, { - "name": "id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "id", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30524,82 +34844,89 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "calling_handler_resource_id", - "type": "optional>", "kind": "keyword", - "required": true + "name": "calling_handler_resource_id", + "required": true, + "type": "optional>" }, { - "name": "username", - "type": "optional", + "default": null, "kind": "keyword", + "name": "username", "required": false, - "default": null + "type": "optional" }, { - "name": "caller_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "caller_id", "required": false, - "default": null + "type": "optional" }, { - "name": "send_as", - "type": "optional", + "default": null, "kind": "keyword", + "name": "send_as", "required": false, - "default": null + "type": "optional" }, { - "name": "ciphers", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "ciphers", "required": false, - "default": null + "type": "optional>" }, { - "name": "codecs", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "codecs", "required": false, - "default": null + "type": "optional>" }, { - "name": "encryption", - "type": "optional", + "default": null, "kind": "keyword", + "name": "encryption", "required": false, - "default": null + "type": "optional" }, { - "name": "call_handler", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_handler", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30611,13 +34938,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30625,52 +34952,59 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "uri", - "type": "string", "kind": "keyword", - "required": true + "name": "uri", + "required": true, + "type": "string" }, { - "name": "encryption", - "type": "class:signalwire.rest.namespaces.fabric_types_generated.Encryption", "kind": "keyword", - "required": true + "name": "encryption", + "required": true, + "type": "class:signalwire.rest.namespaces.fabric_types_generated.Encryption" }, { - "name": "ciphers", - "type": "list", "kind": "keyword", - "required": true + "name": "ciphers", + "required": true, + "type": "list" }, { - "name": "codecs", - "type": "list", "kind": "keyword", - "required": true + "name": "codecs", + "required": true, + "type": "list" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30678,62 +35012,69 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "uri", - "type": "optional", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", + "name": "encryption", "required": false, - "default": null + "type": "optional" }, { - "name": "encryption", - "type": "optional", + "default": null, "kind": "keyword", + "name": "ciphers", "required": false, - "default": null + "type": "optional>" }, { - "name": "ciphers", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "codecs", "required": false, - "default": null + "type": "optional>" }, { - "name": "codecs", - "type": "optional>", + "default": {}, "kind": "keyword", + "name": "extras", "required": false, - "default": null + "type": "optional>" }, { - "name": "extras", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30745,13 +35086,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -30759,91 +35100,98 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "email", - "type": "string", "kind": "keyword", - "required": true + "name": "email", + "required": true, + "type": "string" }, { - "name": "password", - "type": "optional", + "default": null, "kind": "keyword", + "name": "password", "required": false, - "default": null + "type": "optional" }, { - "name": "first_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "first_name", "required": false, - "default": null + "type": "optional" }, { - "name": "last_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "last_name", "required": false, - "default": null + "type": "optional" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "job_title", - "type": "optional", + "default": null, "kind": "keyword", + "name": "job_title", "required": false, - "default": null + "type": "optional" }, { - "name": "timezone", - "type": "optional", + "default": null, "kind": "keyword", + "name": "timezone", "required": false, - "default": null + "type": "optional" }, { - "name": "country", - "type": "optional", + "default": null, "kind": "keyword", + "name": "country", "required": false, - "default": null + "type": "optional" }, { - "name": "region", - "type": "optional", + "default": null, "kind": "keyword", + "name": "region", "required": false, - "default": null + "type": "optional" }, { - "name": "company_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "company_name", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -30851,8 +35199,8 @@ "create_sip_endpoint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30915,11 +35263,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30927,8 +35275,8 @@ "delete_sip_endpoint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30941,6 +35289,13 @@ "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -30948,8 +35303,8 @@ "get_sip_endpoint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30964,11 +35319,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30976,8 +35331,8 @@ "list_sip_endpoints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -30986,11 +35341,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -30998,96 +35353,103 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "email", - "type": "optional", "kind": "keyword", - "required": true + "name": "email", + "required": true, + "type": "optional" }, { - "name": "password", - "type": "optional", + "default": null, "kind": "keyword", + "name": "password", "required": false, - "default": null + "type": "optional" }, { - "name": "first_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "first_name", "required": false, - "default": null + "type": "optional" }, { - "name": "last_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "last_name", "required": false, - "default": null + "type": "optional" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "job_title", - "type": "optional", + "default": null, "kind": "keyword", + "name": "job_title", "required": false, - "default": null + "type": "optional" }, { - "name": "timezone", - "type": "optional", + "default": null, "kind": "keyword", + "name": "timezone", "required": false, - "default": null + "type": "optional" }, { - "name": "country", - "type": "optional", + "default": null, "kind": "keyword", + "name": "country", "required": false, - "default": null + "type": "optional" }, { - "name": "region", - "type": "optional", + "default": null, "kind": "keyword", + "name": "region", "required": false, - "default": null + "type": "optional" }, { - "name": "company_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "company_name", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -31095,8 +35457,8 @@ "update_sip_endpoint": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -31167,11 +35529,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -31183,13 +35545,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -31197,41 +35559,48 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "string", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "string" }, { - "name": "contents", - "type": "string", "kind": "keyword", - "required": true + "name": "contents", + "required": true, + "type": "string" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -31239,48 +35608,55 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "contents", - "type": "optional", + "default": null, "kind": "keyword", + "name": "contents", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -31292,175 +35668,316 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" }, - "create": { + "create": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "primary_request_url", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "name", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "used_for", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "primary_request_method", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "fallback_request_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "fallback_request_method", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "status_callback_url", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "status_callback_method", + "required": false, + "type": "optional>" + }, + { + "default": {}, + "kind": "keyword", + "name": "extras", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "var_keyword", + "name": "kwargs", + "required": false, + "type": "any" + } + ], + "returns": "any" + }, + "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "primary_request_url", - "type": "string", - "kind": "keyword", - "required": true + "name": "resource_id", + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { + "default": null, + "kind": "keyword", "name": "used_for", - "type": "optional", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", + "name": "primary_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "primary_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "primary_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "fallback_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "fallback_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "fallback_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "fallback_request_method", "required": false, - "default": null + "type": "optional>" }, { - "name": "status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "status_callback_method", "required": false, - "default": null + "type": "optional>" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" + } + } + } + } + }, + "signalwire.rest.namespaces.fax_resources_generated": { + "classes": { + "FaxLogs": { + "methods": { + "__init__": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "http", + "required": true, + "type": "any" + } + ], + "returns": "void" }, - "update": { + "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "string" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null - }, + "type": "optional" + } + ], + "returns": "any" + }, + "list": { + "params": [ { - "name": "used_for", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "primary_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "primary_request_method", - "type": "optional>", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null - }, + "type": "any" + } + ], + "returns": "any" + }, + "paginate": { + "params": [ { - "name": "fallback_request_url", - "type": "optional", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "fallback_request_method", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "status_callback_url", - "type": "optional", - "kind": "keyword", + "default": null, + "kind": "var_keyword", + "name": "params", "required": false, - "default": null - }, + "type": "any" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.rest.namespaces.logs_resources_generated": { + "classes": { + "ConferenceLogs": { + "methods": { + "__init__": { + "params": [ { - "name": "status_callback_method", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "kind": "self", + "name": "self" }, { - "name": "extras", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null + "name": "http", + "required": true, + "type": "any" + } + ], + "returns": "void" + }, + "list": { + "params": [ + { + "kind": "self", + "name": "self" }, { - "name": "kwargs", - "type": "any", - "kind": "var_keyword", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" } ], "returns": "any" @@ -31469,20 +35986,20 @@ } } }, - "signalwire.rest.namespaces.fax_resources_generated": { + "signalwire.rest.namespaces.message_resources_generated": { "classes": { - "FaxLogs": { + "MessageLogs": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -31490,13 +36007,20 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -31504,15 +36028,22 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -31520,15 +36051,22 @@ "paginate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -31537,36 +36075,125 @@ } } }, - "signalwire.rest.namespaces.logs_resources_generated": { + "signalwire.rest.namespaces.messages_resources_generated": { "classes": { - "ConferenceLogs": { + "Messages": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" }, - "list": { + "create": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "to", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "from_", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "body", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "media", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "send_as_mms", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "status_callback", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "custom_variables", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "extras", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "positional", + "name": "message_id", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "body", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "extras", + "required": false, + "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -31575,66 +36202,127 @@ } } }, - "signalwire.rest.namespaces.message_resources_generated": { + "signalwire.rest.namespaces.project_resources_generated": { "classes": { - "MessageLogs": { + "ProjectTokens": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" }, - "get": { + "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "resource_id", - "type": "string", - "required": true + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" + }, + { + "kind": "keyword", + "name": "permissions", + "required": true, + "type": "list" + }, + { + "default": null, + "kind": "keyword", + "name": "subproject_id", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "extras", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "list": { + "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", - "kind": "var_keyword", + "kind": "positional", + "name": "token_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" } ], "returns": "any" }, - "paginate": { + "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", - "kind": "var_keyword", + "kind": "positional", + "name": "token_id", + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "name", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "permissions", "required": false, - "default": null + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "extras", + "required": false, + "type": "optional>" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -31643,20 +36331,20 @@ } } }, - "signalwire.rest.namespaces.project_resources_generated": { + "signalwire.rest.namespaces.projects_resources_generated": { "classes": { - "ProjectTokens": { + "Projects": { "methods": { "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -31664,8 +36352,8 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -31674,27 +36362,49 @@ "type": "string" }, { + "default": null, "kind": "keyword", - "name": "permissions", - "required": true, - "type": "list" + "name": "protect_recordings", + "required": false, + "type": "optional" }, { "default": null, "kind": "keyword", - "name": "subproject_id", + "name": "protect_message_media", "required": false, - "type": "optional" + "type": "optional" }, { "default": null, "kind": "keyword", + "name": "protect_fax_media", + "required": false, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "force_https_requests", + "required": false, + "type": "optional" + }, + { + "default": {}, + "kind": "keyword", "name": "extras", "required": false, "type": "optional>" }, { - "default": {}, + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", "name": "kwargs", "required": false, @@ -31706,53 +36416,107 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "kind": "positional", - "name": "token_id", + "name": "resource_id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" }, - "update": { + "rotate_signing_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", - "name": "token_id", + "name": "id", "required": true, "type": "string" }, { "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + } + ], + "returns": "any" + }, + "update": { + "params": [ + { + "kind": "self", + "name": "self" + }, + { + "name": "resource_id", + "required": true, + "type": "any" + }, + { "kind": "keyword", "name": "name", + "required": true, + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "protect_recordings", "required": false, - "type": "optional" + "type": "optional" }, { "default": null, "kind": "keyword", - "name": "permissions", + "name": "protect_message_media", "required": false, - "type": "optional" + "type": "optional" + }, + { + "default": null, + "kind": "keyword", + "name": "protect_fax_media", + "required": false, + "type": "optional" }, { "default": null, "kind": "keyword", + "name": "force_https_requests", + "required": false, + "type": "optional" + }, + { + "default": {}, + "kind": "keyword", "name": "extras", "required": false, "type": "optional>" }, { - "default": {}, + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", "name": "kwargs", "required": false, @@ -31772,13 +36536,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -31786,8 +36550,8 @@ "create_token": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -31823,11 +36587,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -31843,13 +36607,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -31857,8 +36621,8 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -31936,11 +36700,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -31948,14 +36712,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -31963,8 +36734,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -31973,11 +36744,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -31985,15 +36756,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32005,13 +36776,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -32019,8 +36790,8 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -32049,11 +36820,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32065,13 +36836,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -32079,8 +36850,8 @@ "phone_number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32089,11 +36860,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32105,13 +36876,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -32119,8 +36890,8 @@ "call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -32178,11 +36949,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32190,8 +36961,8 @@ "sms": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -32249,11 +37020,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32261,8 +37032,8 @@ "verify": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32284,11 +37055,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32300,13 +37071,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -32314,8 +37085,8 @@ "add_membership": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32337,11 +37108,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32349,35 +37120,42 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "kind": "keyword", + "name": "name", + "required": true, + "type": "string" }, { - "name": "name", - "type": "string", + "default": null, "kind": "keyword", - "required": true + "name": "sticky_sender", + "required": false, + "type": "optional" }, { - "name": "sticky_sender", - "type": "optional", + "default": {}, "kind": "keyword", + "name": "extras", "required": false, - "default": null + "type": "optional>" }, { - "name": "extras", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -32385,13 +37163,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -32399,14 +37184,21 @@ "delete_membership": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -32414,8 +37206,8 @@ "get_membership": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32424,11 +37216,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32436,8 +37228,8 @@ "list_memberships": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32446,11 +37238,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32458,40 +37250,47 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "optional" }, { - "name": "sticky_sender", - "type": "optional", + "default": null, "kind": "keyword", + "name": "sticky_sender", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -32503,13 +37302,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -32517,28 +37316,35 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "number", - "type": "string", "kind": "keyword", - "required": true + "name": "number", + "required": true, + "type": "string" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -32546,13 +37352,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -32560,15 +37373,15 @@ "search": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32576,8 +37389,8 @@ "set_ai_agent": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32592,11 +37405,11 @@ "type": "dict" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32604,8 +37417,8 @@ "set_call_flow": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32627,11 +37440,11 @@ "type": "optional" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32639,8 +37452,8 @@ "set_cxml_application": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32655,11 +37468,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32667,8 +37480,8 @@ "set_cxml_webhook": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32697,11 +37510,11 @@ "type": "optional" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32709,8 +37522,8 @@ "set_relay_application": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32725,11 +37538,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32737,8 +37550,8 @@ "set_relay_topic": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32760,11 +37573,11 @@ "type": "optional" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32772,8 +37585,8 @@ "set_swml_webhook": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -32788,11 +37601,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "extra", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -32800,258 +37613,265 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "call_handler", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_handler", "required": false, - "default": null + "type": "optional" }, { - "name": "call_receive_mode", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_receive_mode", "required": false, - "default": null + "type": "optional" }, { - "name": "call_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_request_method", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_request_method", "required": false, - "default": null + "type": "optional" }, { - "name": "call_fallback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_fallback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_fallback_method", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_fallback_method", "required": false, - "default": null + "type": "optional" }, { - "name": "call_status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_status_callback_method", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_status_callback_method", "required": false, - "default": null + "type": "optional" }, { - "name": "call_laml_application_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_laml_application_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_dialogflow_agent_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_dialogflow_agent_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_topic", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_topic", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_topic_status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_topic_status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_script_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_script_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_context", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_context", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_context_status_callback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_context_status_callback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_application", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_application", "required": false, - "default": null + "type": "optional" }, { - "name": "call_relay_connector_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_relay_connector_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_sip_endpoint_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_sip_endpoint_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_verto_resource", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_verto_resource", "required": false, - "default": null + "type": "optional" }, { - "name": "call_video_room_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_video_room_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_ai_agent_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_ai_agent_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_flow_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_flow_id", "required": false, - "default": null + "type": "optional" }, { - "name": "call_flow_version", - "type": "optional", + "default": null, "kind": "keyword", + "name": "call_flow_version", "required": false, - "default": null + "type": "optional" }, { - "name": "message_handler", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_handler", "required": false, - "default": null + "type": "optional" }, { - "name": "message_request_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_request_url", "required": false, - "default": null + "type": "optional" }, { - "name": "message_request_method", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_request_method", "required": false, - "default": null + "type": "optional" }, { - "name": "message_fallback_url", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_fallback_url", "required": false, - "default": null + "type": "optional" }, { - "name": "message_fallback_method", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_fallback_method", "required": false, - "default": null + "type": "optional" }, { - "name": "message_laml_application_id", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_laml_application_id", "required": false, - "default": null + "type": "optional" }, { - "name": "message_relay_topic", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_relay_topic", "required": false, - "default": null + "type": "optional" }, { - "name": "message_relay_context", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_relay_context", "required": false, - "default": null + "type": "optional" }, { - "name": "message_relay_application", - "type": "optional", + "default": null, "kind": "keyword", + "name": "message_relay_application", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -33063,13 +37883,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33077,36 +37897,43 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "max_size", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_size", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -33114,13 +37941,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + }, + { + "name": "resource_id", + "required": true, + "type": "string" }, { - "name": "resource_id", - "type": "string", - "required": true + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33128,8 +37962,8 @@ "get_member": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33144,11 +37978,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33156,8 +37990,8 @@ "get_next_member": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33166,11 +38000,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33178,8 +38012,8 @@ "list_members": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33188,11 +38022,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33200,41 +38034,48 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "max_size", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_size", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -33246,13 +38087,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33260,14 +38101,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33275,8 +38123,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33285,11 +38133,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33297,15 +38145,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33317,13 +38165,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33331,14 +38179,21 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "body", "required": true, "type": "dict" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33346,8 +38201,8 @@ "create_campaign": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33360,6 +38215,13 @@ "name": "body", "required": true, "type": "dict" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33367,8 +38229,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33377,11 +38239,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33389,15 +38251,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33405,8 +38267,8 @@ "list_campaigns": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33415,11 +38277,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33431,13 +38293,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33445,8 +38307,8 @@ "create_order": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33476,11 +38338,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33488,8 +38350,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33498,11 +38360,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33510,8 +38372,8 @@ "list_numbers": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33520,11 +38382,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33532,8 +38394,8 @@ "list_orders": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33542,11 +38404,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33554,8 +38416,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33578,11 +38440,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33594,13 +38456,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33608,14 +38470,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33627,13 +38496,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33641,8 +38510,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33651,11 +38520,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33667,13 +38536,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33681,8 +38550,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33691,11 +38560,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33703,15 +38572,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33719,8 +38588,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -33790,11 +38659,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33806,13 +38675,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33820,15 +38689,15 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33836,8 +38705,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "default": null, @@ -33882,11 +38751,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -33898,13 +38767,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -33912,42 +38781,49 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "number", - "type": "string", "kind": "keyword", - "required": true + "name": "number", + "required": true, + "type": "string" }, { - "name": "name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "name", "required": false, - "default": null + "type": "optional" }, { - "name": "extension", - "type": "optional", + "default": null, "kind": "keyword", + "name": "extension", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -33955,13 +38831,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33969,14 +38852,21 @@ "redial_verification": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -33984,8 +38874,8 @@ "submit_verification": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34007,11 +38897,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34019,33 +38909,40 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "name", - "type": "optional", "kind": "keyword", - "required": true + "name": "name", + "required": true, + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -34061,13 +38958,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34075,8 +38972,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34085,11 +38982,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34097,14 +38994,21 @@ "reset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -34116,13 +39020,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34130,168 +39034,175 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "display_name", - "type": "string", "kind": "keyword", - "required": true + "name": "display_name", + "required": true, + "type": "string" }, { + "default": null, + "kind": "keyword", "name": "name", - "type": "optional", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "keyword", + "name": "description", "required": false, - "default": null + "type": "optional" }, { - "name": "description", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "size", "required": false, - "default": null + "type": "optional" }, { - "name": "size", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_room_previews", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_room_previews", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_chat", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_chat", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_primary", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_primary", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_background", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_background", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_foreground", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_foreground", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_success", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_success", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_negative", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_negative", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_primary", "required": false, - "default": null + "type": "optional" }, { - "name": "light_primary", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_background", "required": false, - "default": null + "type": "optional" }, { - "name": "light_background", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_foreground", "required": false, - "default": null + "type": "optional" }, { - "name": "light_foreground", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_success", "required": false, - "default": null + "type": "optional" }, { - "name": "light_success", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_negative", "required": false, - "default": null + "type": "optional" }, { - "name": "light_negative", - "type": "optional", + "default": {}, "kind": "keyword", + "name": "extras", "required": false, - "default": null + "type": "optional>" }, { - "name": "extras", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -34299,8 +39210,8 @@ "create_stream": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34322,11 +39233,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34334,13 +39245,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -34348,8 +39266,8 @@ "list_conference_tokens": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34358,11 +39276,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34370,8 +39288,8 @@ "list_streams": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34380,11 +39298,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34392,187 +39310,194 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "display_name", - "type": "optional", "kind": "keyword", - "required": true + "name": "display_name", + "required": true, + "type": "optional" }, { - "name": "description", - "type": "optional", + "default": null, "kind": "keyword", + "name": "description", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "size", - "type": "optional", + "default": null, "kind": "keyword", + "name": "size", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "tone_on_entry_and_exit", - "type": "optional", + "default": null, "kind": "keyword", + "name": "tone_on_entry_and_exit", "required": false, - "default": null + "type": "optional" }, { - "name": "room_join_video_off", - "type": "optional", + "default": null, "kind": "keyword", + "name": "room_join_video_off", "required": false, - "default": null + "type": "optional" }, { - "name": "user_join_video_off", - "type": "optional", + "default": null, "kind": "keyword", + "name": "user_join_video_off", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_room_previews", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_room_previews", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_chat", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_chat", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_primary", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_primary", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_background", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_background", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_foreground", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_foreground", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_success", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_success", "required": false, - "default": null + "type": "optional" }, { - "name": "dark_negative", - "type": "optional", + "default": null, "kind": "keyword", + "name": "dark_negative", "required": false, - "default": null + "type": "optional" }, { - "name": "light_primary", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_primary", "required": false, - "default": null + "type": "optional" }, { - "name": "light_background", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_background", "required": false, - "default": null + "type": "optional" }, { - "name": "light_foreground", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_foreground", "required": false, - "default": null + "type": "optional" }, { - "name": "light_success", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_success", "required": false, - "default": null + "type": "optional" }, { - "name": "light_negative", - "type": "optional", + "default": null, "kind": "keyword", + "name": "light_negative", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -34584,13 +39509,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34598,14 +39523,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -34613,8 +39545,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34623,11 +39555,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34635,15 +39567,15 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34651,8 +39583,8 @@ "list_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34661,11 +39593,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34677,13 +39609,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34691,13 +39623,20 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -34705,15 +39644,22 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -34721,8 +39667,8 @@ "list_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34731,11 +39677,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34743,8 +39689,8 @@ "list_members": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34753,11 +39699,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34765,8 +39711,8 @@ "list_recordings": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -34775,11 +39721,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34787,15 +39733,22 @@ "paginate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -34807,13 +39760,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34821,8 +39774,8 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "keyword", @@ -34957,11 +39910,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -34973,13 +39926,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -34987,119 +39940,126 @@ "create": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "kind": "keyword", "name": "name", - "type": "string", + "required": true, + "type": "string" + }, + { + "default": null, "kind": "keyword", - "required": true + "name": "display_name", + "required": false, + "type": "optional" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "description", "required": false, - "default": null + "type": "optional" }, { - "name": "description", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_members", "required": false, - "default": null + "type": "optional" }, { - "name": "max_members", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_at", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_at", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_after_seconds_elapsed", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_after_seconds_elapsed", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_room_previews", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_room_previews", - "type": "optional", + "default": null, "kind": "keyword", + "name": "meta", "required": false, - "default": null + "type": "optional>" }, { - "name": "meta", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "sync_audio_video", "required": false, - "default": null + "type": "optional" }, { - "name": "sync_audio_video", - "type": "optional", + "default": {}, "kind": "keyword", + "name": "extras", "required": false, - "default": null + "type": "optional>" }, { - "name": "extras", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -35107,8 +40067,8 @@ "create_stream": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -35130,11 +40090,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -35142,13 +40102,20 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -35156,8 +40123,8 @@ "list_streams": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -35166,11 +40133,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -35178,118 +40145,125 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "display_name", - "type": "optional", + "default": null, "kind": "keyword", + "name": "display_name", "required": false, - "default": null + "type": "optional" }, { - "name": "description", - "type": "optional", + "default": null, "kind": "keyword", + "name": "description", "required": false, - "default": null + "type": "optional" }, { - "name": "max_members", - "type": "optional", + "default": null, "kind": "keyword", + "name": "max_members", "required": false, - "default": null + "type": "optional" }, { - "name": "quality", - "type": "optional", + "default": null, "kind": "keyword", + "name": "quality", "required": false, - "default": null + "type": "optional" }, { - "name": "join_from", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_from", "required": false, - "default": null + "type": "optional" }, { - "name": "join_until", - "type": "optional", + "default": null, "kind": "keyword", + "name": "join_until", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_at", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_at", "required": false, - "default": null + "type": "optional" }, { - "name": "remove_after_seconds_elapsed", - "type": "optional", + "default": null, "kind": "keyword", + "name": "remove_after_seconds_elapsed", "required": false, - "default": null + "type": "optional" }, { - "name": "layout", - "type": "optional", + "default": null, "kind": "keyword", + "name": "layout", "required": false, - "default": null + "type": "optional" }, { - "name": "record_on_start", - "type": "optional", + "default": null, "kind": "keyword", + "name": "record_on_start", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_room_previews", - "type": "optional", + "default": null, "kind": "keyword", + "name": "enable_room_previews", "required": false, - "default": null + "type": "optional" }, { - "name": "meta", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "meta", "required": false, - "default": null + "type": "optional>" }, { - "name": "sync_audio_video", - "type": "optional", + "default": null, "kind": "keyword", + "name": "sync_audio_video", "required": false, - "default": null + "type": "optional" }, { + "default": {}, + "kind": "keyword", "name": "extras", - "type": "optional>", + "required": false, + "type": "optional>" + }, + { + "default": null, "kind": "keyword", + "name": "request_options", "required": false, - "default": null + "type": "optional" }, { - "name": "kwargs", - "type": "any", + "default": null, "kind": "var_keyword", + "name": "kwargs", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -35301,13 +40275,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -35315,14 +40289,21 @@ "delete": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", "name": "id", "required": true, "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -35330,8 +40311,8 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -35340,11 +40321,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -35352,8 +40333,8 @@ "update": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -35375,11 +40356,11 @@ "type": "optional>" }, { - "default": {}, - "kind": "var_keyword", - "name": "kwargs", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -35395,13 +40376,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "http", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -35409,13 +40390,20 @@ "get": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "resource_id", - "type": "string", - "required": true + "required": true, + "type": "string" + }, + { + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" } ], "returns": "any" @@ -35423,15 +40411,22 @@ "list": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -35439,8 +40434,8 @@ "list_events": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "kind": "positional", @@ -35449,11 +40444,11 @@ "type": "string" }, { - "default": {}, - "kind": "var_keyword", - "name": "params", + "default": null, + "kind": "keyword", + "name": "request_options", "required": false, - "type": "any" + "type": "optional" } ], "returns": "any" @@ -35461,15 +40456,22 @@ "paginate": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "params", - "type": "any", + "default": null, + "kind": "keyword", + "name": "request_options", + "required": false, + "type": "optional" + }, + { + "default": null, "kind": "var_keyword", + "name": "params", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -35497,6 +40499,10 @@ "serverless": { "params": [], "returns": "any" + }, + "suppress_run": { + "params": [], + "returns": "any" } } } @@ -35509,13 +40515,13 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "app", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "void" @@ -35523,19 +40529,19 @@ "call": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "event", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "_context", - "type": "any", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -35544,8 +40550,8 @@ "params": [ { "name": "agent_or_app", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -35561,20 +40567,20 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, "name": "agent", - "type": "any", "required": false, - "default": null + "type": "class:signalwire.core.agent_base.AgentBase" }, { + "default": null, "name": "params", - "type": "any", "required": false, - "default": null + "type": "optional>" } ], "returns": "void" @@ -35582,8 +40588,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35591,8 +40597,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35600,8 +40606,8 @@ "get_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35609,8 +40615,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35618,8 +40624,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35627,8 +40633,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35636,8 +40642,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35645,8 +40651,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35662,8 +40668,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35671,8 +40677,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35680,8 +40686,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35689,8 +40695,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35698,8 +40704,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35707,8 +40713,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35716,8 +40722,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35733,8 +40739,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35742,8 +40748,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35751,8 +40757,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35760,8 +40766,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35769,8 +40775,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35778,8 +40784,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35787,8 +40793,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35796,8 +40802,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35805,8 +40811,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35822,8 +40828,8 @@ "cleanup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35831,8 +40837,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35840,8 +40846,8 @@ "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35849,8 +40855,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35858,8 +40864,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35867,8 +40873,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35876,8 +40882,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35885,8 +40891,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35894,8 +40900,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35903,8 +40909,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35912,8 +40918,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35929,8 +40935,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35938,8 +40944,8 @@ "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35947,8 +40953,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35956,8 +40962,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35965,8 +40971,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35974,8 +40980,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35983,8 +40989,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -35992,8 +40998,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36001,8 +41007,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36010,8 +41016,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36027,8 +41033,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36036,8 +41042,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36045,8 +41051,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36054,8 +41060,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36063,8 +41069,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36072,8 +41078,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36081,8 +41087,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36098,8 +41104,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36107,8 +41113,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36116,8 +41122,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36125,8 +41131,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36134,8 +41140,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36143,8 +41149,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36152,8 +41158,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36169,8 +41175,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36178,8 +41184,8 @@ "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36187,8 +41193,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36196,8 +41202,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36205,8 +41211,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36214,8 +41220,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36223,8 +41229,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36232,8 +41238,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36241,8 +41247,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36258,8 +41264,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36267,8 +41273,8 @@ "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36276,8 +41282,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36285,8 +41291,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36294,8 +41300,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36303,8 +41309,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36312,8 +41318,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36321,8 +41327,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36338,8 +41344,88 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_hints": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_parameter_schema": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_prompt_sections": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "name": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "register_tools": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "setup": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + } + } + } + } + }, + "signalwire.skills.mcp_gateway.skill": { + "classes": { + "MCPGatewaySkill": { + "methods": { + "description": { + "params": [ + { + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "get_global_data": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36347,8 +41433,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36356,8 +41442,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36365,8 +41451,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36374,26 +41460,35 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "register_tools": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "setup": { + "version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36409,8 +41504,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36418,8 +41513,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36427,8 +41522,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36436,8 +41531,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36445,8 +41540,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36454,8 +41549,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36463,8 +41558,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36472,8 +41567,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36489,20 +41584,20 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, "name": "agent", - "type": "any", "required": false, - "default": null + "type": "class:signalwire.core.agent_base.AgentBase" }, { + "default": null, "name": "params", - "type": "any", "required": false, - "default": null + "type": "optional>" } ], "returns": "void" @@ -36510,8 +41605,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36519,8 +41614,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36528,8 +41623,8 @@ "get_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36537,8 +41632,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36546,8 +41641,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36555,8 +41650,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36564,8 +41659,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36573,8 +41668,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36590,8 +41685,8 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "void" @@ -36599,13 +41694,13 @@ "add_skill_directory": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "path", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -36613,8 +41708,8 @@ "discover_skills": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36622,8 +41717,8 @@ "external_paths": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36631,18 +41726,18 @@ "get_all_skills_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" }, - "get_factory": { + "get_skill_class": { "params": [ { "name": "skill_name", - "type": "any", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -36650,8 +41745,8 @@ "last_registered": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36659,8 +41754,8 @@ "list_all_skill_sources": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36668,8 +41763,8 @@ "list_skills": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36677,8 +41772,8 @@ "logger": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36687,15 +41782,15 @@ "params": [ { "name": "skill_name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -36707,19 +41802,19 @@ "register_skill": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "skill_class", - "type": "class:signalwire.core.skill_base.SkillBase", - "required": true + "required": true, + "type": "class:signalwire.core.skill_base.SkillBase" }, { + "default": null, "name": "factory", - "type": "any", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -36728,8 +41823,8 @@ "params": [ { "name": "skill_name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -36748,8 +41843,8 @@ "params": [ { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -36763,20 +41858,20 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, "name": "agent", - "type": "class:signalwire.core.agent_base.AgentBase", "required": false, - "default": null + "type": "class:signalwire.core.agent_base.AgentBase" }, { + "default": null, "name": "params", - "type": "dict", "required": false, - "default": null + "type": "dict" } ], "returns": "void" @@ -36784,8 +41879,8 @@ "cleanup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36793,8 +41888,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36802,8 +41897,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36811,8 +41906,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36820,8 +41915,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36829,8 +41924,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36838,8 +41933,17 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" + } + ], + "returns": "any" + }, + "remove_xpaths": { + "params": [ + { + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36847,8 +41951,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36856,8 +41960,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36873,8 +41977,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36882,8 +41986,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36891,8 +41995,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36900,8 +42004,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36909,8 +42013,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36918,8 +42022,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36927,8 +42031,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36936,8 +42040,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36945,8 +42049,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36962,20 +42066,20 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, "name": "agent", - "type": "any", "required": false, - "default": null + "type": "class:signalwire.core.agent_base.AgentBase" }, { + "default": null, "name": "params", - "type": "any", "required": false, - "default": null + "type": "optional>" } ], "returns": "void" @@ -36983,8 +42087,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -36992,8 +42096,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37001,8 +42105,8 @@ "get_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37010,8 +42114,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37019,8 +42123,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37028,8 +42132,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37045,8 +42149,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37054,8 +42158,8 @@ "get_global_data": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37063,8 +42167,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37072,8 +42176,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37081,8 +42185,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37090,8 +42194,8 @@ "instance_key": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37099,8 +42203,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37108,8 +42212,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37117,8 +42221,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37126,8 +42230,8 @@ "supports_multiple_instances": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37135,8 +42239,8 @@ "version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37152,8 +42256,8 @@ "description": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37161,8 +42265,8 @@ "get_hints": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37170,8 +42274,8 @@ "get_parameter_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37179,8 +42283,8 @@ "get_prompt_sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37188,8 +42292,8 @@ "name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37197,8 +42301,8 @@ "register_tools": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37206,13 +42310,13 @@ "search_wiki": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "query", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -37220,8 +42324,8 @@ "setup": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37237,8 +42341,8 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "void" @@ -37246,54 +42350,54 @@ "array": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "of", - "type": "any", + "default": null, "kind": "keyword", + "name": "of", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" }, { - "name": "enum", - "type": "any", + "default": null, "kind": "keyword", + "name": "enum", "required": false, - "default": null + "type": "any" }, { - "name": "&", - "type": "any", + "default": null, "kind": "keyword", + "name": "&", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37301,33 +42405,33 @@ "boolean": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37335,11 +42439,11 @@ "build": { "params": [ { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37347,45 +42451,45 @@ "enum": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { "name": "values", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" }, { - "name": "type", - "type": "any", + "default": "string", "kind": "keyword", + "name": "type", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37393,47 +42497,47 @@ "integer": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" }, { - "name": "enum", - "type": "any", + "default": null, "kind": "keyword", + "name": "enum", "required": false, - "default": null + "type": "any" }, { - "name": "format", - "type": "any", + "default": null, "kind": "keyword", + "name": "format", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37441,47 +42545,47 @@ "number": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" }, { - "name": "enum", - "type": "any", + "default": null, "kind": "keyword", + "name": "enum", "required": false, - "default": null + "type": "any" }, { - "name": "format", - "type": "any", + "default": null, "kind": "keyword", + "name": "format", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37489,33 +42593,33 @@ "object": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "block", - "type": "any", + "default": null, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37523,15 +42627,15 @@ "require": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "names", - "type": "any", + "default": null, "kind": "var_positional", + "name": "names", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37539,15 +42643,15 @@ "required": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "names", - "type": "any", + "default": null, "kind": "var_positional", + "name": "names", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37555,47 +42659,47 @@ "string": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { + "default": null, "name": "description", - "type": "any", "required": false, - "default": null + "type": "any" }, { - "name": "required", - "type": "any", + "default": false, "kind": "keyword", + "name": "required", "required": false, - "default": null + "type": "any" }, { - "name": "default", - "type": "any", + "default": null, "kind": "keyword", + "name": "default", "required": false, - "default": null + "type": "any" }, { - "name": "enum", - "type": "any", + "default": null, "kind": "keyword", + "name": "enum", "required": false, - "default": null + "type": "any" }, { - "name": "format", - "type": "any", + "default": null, "kind": "keyword", + "name": "format", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37603,8 +42707,8 @@ "to_h": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37612,8 +42716,8 @@ "to_hash": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37621,15 +42725,15 @@ "to_json": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "*", - "type": "any", + "default": null, "kind": "var_positional", + "name": "*", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37657,8 +42761,8 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "void" @@ -37666,13 +42770,13 @@ "add_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37680,18 +42784,18 @@ "add_verb": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { "name": "config", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37699,23 +42803,23 @@ "add_verb_to_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "section", - "type": "any", - "required": true + "required": true, + "type": "any" }, { "name": "verb_name", - "type": "any", - "required": true + "required": true, + "type": "any" }, { "name": "config", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37723,14 +42827,14 @@ "get_verbs": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": "main", "name": "section", - "type": "any", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -37738,13 +42842,13 @@ "has_section": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37752,8 +42856,8 @@ "render": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37761,8 +42865,8 @@ "render_pretty": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37770,8 +42874,8 @@ "reset": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37779,8 +42883,8 @@ "sections": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37788,8 +42892,8 @@ "to_h": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37797,8 +42901,8 @@ "version": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37822,20 +42926,20 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { + "default": null, "name": "schema_path", - "type": "optional", "required": false, - "default": null + "type": "optional" }, { + "default": true, "name": "schema_validation", - "type": "bool", "required": false, - "default": null + "type": "bool" } ], "returns": "void" @@ -37843,8 +42947,8 @@ "full_validation_available": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37852,13 +42956,13 @@ "generate_method_body": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37866,13 +42970,13 @@ "generate_method_signature": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -37880,8 +42984,8 @@ "get_all_verb_names": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37889,13 +42993,13 @@ "get_verb_parameters": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -37903,13 +43007,13 @@ "get_verb_properties": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -37917,13 +43021,13 @@ "get_verb_required_properties": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -37931,8 +43035,8 @@ "load_schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37940,8 +43044,8 @@ "schema": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37949,8 +43053,8 @@ "schema_path": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -37958,13 +43062,13 @@ "validate_document": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "_document", - "type": "any", - "required": true + "name": "document", + "required": true, + "type": "dict" } ], "returns": "any" @@ -37972,18 +43076,18 @@ "validate_verb": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "string", - "required": true + "required": true, + "type": "string" }, { "name": "verb_config", - "type": "dict", - "required": true + "required": true, + "type": "dict" } ], "returns": "any" @@ -37995,18 +43099,18 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "verb_name", - "type": "string", - "required": true + "required": true, + "type": "string" }, { "name": "errors", - "type": "list", - "required": true + "required": true, + "type": "list" } ], "returns": "void" @@ -38014,8 +43118,8 @@ "errors": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38023,8 +43127,8 @@ "verb_name": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38039,14 +43143,14 @@ "params": [ { "name": "url", - "type": "string", - "required": true + "required": true, + "type": "string" }, { + "default": false, "name": "allow_private", - "type": "bool", "required": false, - "default": null + "type": "bool" } ], "returns": "any" @@ -38060,71 +43164,71 @@ "__init__": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "port", - "type": "int", + "default": 8002, "kind": "keyword", + "name": "port", "required": false, - "default": null + "type": "int" }, { - "name": "directories", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "directories", "required": false, - "default": null + "type": "optional>" }, { - "name": "basic_auth", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "basic_auth", "required": false, - "default": null + "type": "optional>" }, { - "name": "config_file", - "type": "optional", + "default": null, "kind": "keyword", + "name": "config_file", "required": false, - "default": null + "type": "optional" }, { - "name": "enable_directory_browsing", - "type": "bool", + "default": false, "kind": "keyword", + "name": "enable_directory_browsing", "required": false, - "default": null + "type": "bool" }, { - "name": "allowed_extensions", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "allowed_extensions", "required": false, - "default": null + "type": "optional>" }, { - "name": "blocked_extensions", - "type": "optional>", + "default": null, "kind": "keyword", + "name": "blocked_extensions", "required": false, - "default": null + "type": "optional>" }, { - "name": "max_file_size", - "type": "int", + "default": null, "kind": "keyword", + "name": "max_file_size", "required": false, - "default": null + "type": "int" }, { - "name": "enable_cors", - "type": "bool", + "default": true, "kind": "keyword", + "name": "enable_cors", "required": false, - "default": null + "type": "bool" } ], "returns": "void" @@ -38132,18 +43236,18 @@ "add_directory": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "route", - "type": "string", - "required": true + "required": true, + "type": "string" }, { "name": "directory", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -38151,8 +43255,8 @@ "allowed_extensions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38160,8 +43264,8 @@ "blocked_extensions": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38169,8 +43273,8 @@ "directories": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38178,8 +43282,8 @@ "enable_cors": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38187,8 +43291,8 @@ "enable_directory_browsing": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38196,13 +43300,13 @@ "file_allowed": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "path", - "type": "any", - "required": true + "required": true, + "type": "any" } ], "returns": "any" @@ -38210,8 +43314,8 @@ "max_file_size": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38219,8 +43323,8 @@ "port": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38228,13 +43332,13 @@ "remove_directory": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { "name": "route", - "type": "string", - "required": true + "required": true, + "type": "string" } ], "returns": "any" @@ -38242,8 +43346,8 @@ "security": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38251,43 +43355,43 @@ "start": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" }, { - "name": "host", - "type": "string", + "default": "0.0.0.0", "kind": "keyword", + "name": "host", "required": false, - "default": null + "type": "string" }, { - "name": "port", - "type": "optional", + "default": null, "kind": "keyword", + "name": "port", "required": false, - "default": null + "type": "optional" }, { - "name": "ssl_cert", - "type": "optional", + "default": null, "kind": "keyword", + "name": "ssl_cert", "required": false, - "default": null + "type": "optional" }, { - "name": "ssl_key", - "type": "optional", + "default": null, "kind": "keyword", + "name": "ssl_key", "required": false, - "default": null + "type": "optional" }, { - "name": "block", - "type": "any", + "default": false, "kind": "keyword", + "name": "block", "required": false, - "default": null + "type": "any" } ], "returns": "any" @@ -38295,8 +43399,8 @@ "stop": { "params": [ { - "name": "self", - "kind": "self" + "kind": "self", + "name": "self" } ], "returns": "any" @@ -38306,5 +43410,5 @@ } } }, - "baseline_version": "3.0.2" + "version": "2" } From 037b395f9daed9985e22cbac329f21ecd639cf64 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 11:35:41 -0400 Subject: [PATCH 16/90] fix(security): compare the auth-scheme case-insensitively and require the Basic colon Two divergences from the reference (fastapi.security.http), both in ruby's hand-rolled Authorization guards. The reference's `get_authorization_scheme_param` partitions the header on the FIRST SPACE and each scheme compares `scheme.lower()` against its literal; `HTTPBasic` then does `username, separator, password = data.partition(":")` and raises when `separator` is empty. (a) CASE-SENSITIVE SCHEME COMPARISON. `auth_handler.rb` matched the scheme with a fixed-offset slice -- `header.start_with?('Bearer ')` + `header[6..]` -- which both hardcoded the scheme's length and could not match a lowercase token. RFC 7235 makes the auth-scheme token case-insensitive, so `authorization: bearer ` was authenticated by the reference and 401'd here. Same shape in `web_service.rb#credentials_match?`. (b) MISSING-COLON BASIC PAYLOAD ACCEPTED WITH AN EMPTY PASSWORD. `auth_handler.rb#parse_basic_auth` destructured the separator into `_sep` and discarded it, so `Basic ` -- no colon at all -- parsed as username "bob" with a defaulted empty password and constructed valid credentials. `web_service.rb` had the identical shape. `swml/service.rb#decode_basic_auth` used `split(':', 2)`, returning the 1-element ['bob']; the 401 there came from a downstream nil-guard rather than the parse, so the outcome was right but incidental. All three now split on the first space, fold the scheme for comparison while carrying it verbatim into the carrier, and reject a decoded payload with no colon. The two Rack middlewares (AgentTimingSafeBasicAuth / TimingSafeBasicAuth) delegate to Rack::Auth::Basic::Request, which already downcases the scheme and requires `credentials.length == 2`; verified correct on both points, unchanged. Tests assert both directions: lowercase/mixed-case `basic`/`bearer` are accepted, and Digest/Negotiate/Basicx/Bearer-on-the-basic-branch/scheme-less headers are still rejected -- the rejection cases pass before and after the fix, so the accept assertions are not vacuous. A colon-less payload is rejected, an explicit trailing colon is still a valid empty password, and a password containing colons keeps everything after the first. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/core/auth_handler.rb | 43 ++++++++--- lib/signalwire/swml/service.rb | 14 +++- lib/signalwire/web/web_service.rb | 14 +++- tests/core_auth_handler_test.rb | 114 ++++++++++++++++++++++++++++ tests/handle_request_core_test.rb | 66 ++++++++++++++++ tests/web_web_service_test.rb | 102 +++++++++++++++++++++++++ 6 files changed, 335 insertions(+), 18 deletions(-) diff --git a/lib/signalwire/core/auth_handler.rb b/lib/signalwire/core/auth_handler.rb index b5e6a979..9076cf98 100644 --- a/lib/signalwire/core/auth_handler.rb +++ b/lib/signalwire/core/auth_handler.rb @@ -32,8 +32,10 @@ class AuthHandler # authorization. # # These carry the fields parsed out of the +Authorization+ header. The - # bearer header is split on the FIRST space: the first part is the - # +scheme+ ("Bearer"), the second the +credentials+ (the token itself). + # header is split on the FIRST space: the first part is the +scheme+ + # ("Bearer"), the second the +credentials+ (the token itself). Per RFC + # 7235 the scheme token is compared case-INSENSITIVELY but carried + # VERBATIM here, mirroring the reference's HTTPAuthorizationCredentials. BasicCredentials = Struct.new(:username, :password) BearerCredentials = Struct.new(:scheme, :credentials) @@ -149,16 +151,27 @@ def authenticate_env(env) def bearer_env_ok?(env) return false unless @auth_methods.dig('bearer', 'enabled') - header = env['HTTP_AUTHORIZATION'].to_s - return false unless header.start_with?('Bearer ') + scheme, credentials = split_authorization(env['HTTP_AUTHORIZATION']) + # RFC 7235: the auth-scheme token is case-INSENSITIVE, so compare it + # folded (the reference does `scheme.lower() != "bearer"`) while + # carrying the scheme VERBATIM into the carrier. + return false unless scheme.downcase == 'bearer' && !credentials.empty? - # Split on the FIRST space only: scheme, then the token verbatim (a - # token may itself contain no space, but splitting on all of them - # would silently truncate a malformed one instead of failing compare). - scheme, credentials = header.split(' ', 2) verify_bearer_token(BearerCredentials.new(scheme, credentials)) end + # Split an Authorization header on the FIRST space into + # +[scheme, credentials]+, mirroring the reference's + # +get_authorization_scheme_param+ (partition on ' ', strip the param). + # A nil/blank header yields +['', '']+. + def split_authorization(header) + value = header.to_s + return ['', ''] if value.empty? + + scheme, _sep, param = value.partition(' ') + [scheme, param.strip] + end + def api_key_env_ok?(env) return false unless @auth_methods.dig('api_key', 'enabled') @@ -177,10 +190,18 @@ def basic_env_ok?(env) end def parse_basic_auth(header) - return nil unless header.start_with?('Basic ') + scheme, param = split_authorization(header) + # RFC 7235 case-insensitive scheme compare (reference: + # `scheme.lower() != "basic"`). + return nil unless scheme.downcase == 'basic' + + decoded = Base64.decode64(param) + user, separator, pass = decoded.partition(':') + # RFC 7617 / reference: `if not separator: raise`. A decoded payload + # with NO colon is NOT a credential pair -- reject it outright rather + # than defaulting the password to ''. + return nil if separator.empty? - decoded = Base64.decode64(header[6..]) - user, _sep, pass = decoded.partition(':') BasicCredentials.new(user, pass) rescue ArgumentError nil diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 96990381..7ab3f056 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -425,11 +425,19 @@ def check_basic_auth_headers(headers) def decode_basic_auth(auth) return [nil, nil] if auth.nil? || auth.empty? - scheme, credentials = auth.split(' ', 2) - return [nil, nil] unless scheme&.downcase == 'basic' && credentials + # FIRST-space split, case-INSENSITIVE scheme compare (RFC 7235; the + # reference does `scheme.lower() != "basic"`). + scheme, _sep, credentials = auth.partition(' ') + return [nil, nil] unless scheme.downcase == 'basic' && !credentials.strip.empty? require 'base64' - Base64.decode64(credentials).split(':', 2) + username, separator, password = Base64.decode64(credentials.strip).partition(':') + # RFC 7617 / the reference's `if not separator: raise` -- a decoded + # payload with NO colon is not a credential pair; reject it at the parse + # rather than returning a 1-element split with a nil password. + return [nil, nil] if separator.empty? + + [username, password] end # Framework-free proxy detection over a URL + plain headers Hash, mirroring diff --git a/lib/signalwire/web/web_service.rb b/lib/signalwire/web/web_service.rb index a48ac1ae..03c231f4 100644 --- a/lib/signalwire/web/web_service.rb +++ b/lib/signalwire/web/web_service.rb @@ -195,11 +195,17 @@ def authorized?(req, res) end def credentials_match?(req, user, pass) - header = req['Authorization'].to_s - return false unless header.start_with?('Basic ') + # Split on the FIRST space and compare the scheme case-INSENSITIVELY + # (RFC 7235; the reference does `scheme.lower() != "basic"`). + scheme, _sep, param = req['Authorization'].to_s.partition(' ') + return false unless scheme.downcase == 'basic' + + decoded = Base64.decode64(param.strip) + input_user, separator, input_pass = decoded.partition(':') + # RFC 7617 / the reference's `if not separator: raise` -- a payload with + # NO colon is not a credential pair; never default the password to ''. + return false if separator.empty? - decoded = Base64.decode64(header[6..]) - input_user, _sep, input_pass = decoded.partition(':') Rack::Utils.secure_compare(user.to_s, input_user) && Rack::Utils.secure_compare(pass.to_s, input_pass) rescue ArgumentError false diff --git a/tests/core_auth_handler_test.rb b/tests/core_auth_handler_test.rb index e653293b..51466ca8 100644 --- a/tests/core_auth_handler_test.rb +++ b/tests/core_auth_handler_test.rb @@ -208,3 +208,117 @@ def test_rack_bearer_path_splits_scheme_from_token assert_equal 'bearer', result['method'] end end + +# RFC 7235 makes the auth-scheme token case-INSENSITIVE, and RFC 7617 requires a +# colon in the decoded Basic payload. The reference (fastapi.security.http) +# partitions the header on the FIRST SPACE, compares `scheme.lower()` against +# "basic"/"bearer", and for Basic does `username, separator, password = +# data.partition(":")` then `if not separator: raise` -- a colon-less payload is +# rejected outright, never defaulted to an empty password. +class CoreAuthSchemeAndColonTest < Minitest::Test + def handler(**) + SignalWire::Core::AuthHandler.new(CoreAuthHandlerTest::FakeConfig.new(**)) + end + + def env(header) + { 'HTTP_AUTHORIZATION' => header, 'REQUEST_METHOD' => 'GET', + 'PATH_INFO' => '/', 'REMOTE_ADDR' => '1.2.3.4' } + end + + def auth(handler, header) + handler.rack_dependency(optional: true).call(env(header)) + end + + def basic_header(scheme, payload) + "#{scheme} #{Base64.strict_encode64(payload)}" + end + + # --- (a) case-insensitive scheme: ACCEPT ------------------------------------ + + def test_lowercase_bearer_scheme_is_accepted + h = handler(bearer_token: 'tok123') + + %w[bearer BEARER BeArEr Bearer].each do |scheme| + result = auth(h, "#{scheme} tok123") + + assert result['authenticated'], "scheme #{scheme.inspect} must authenticate (RFC 7235)" + assert_equal 'bearer', result['method'] + end + end + + def test_lowercase_basic_scheme_is_accepted + h = handler(user: 'alice', password: 'secret') + + %w[basic BASIC BaSiC Basic].each do |scheme| + result = auth(h, basic_header(scheme, 'alice:secret')) + + assert result['authenticated'], "scheme #{scheme.inspect} must authenticate (RFC 7235)" + assert_equal 'basic', result['method'] + end + end + + # --- (a) case-insensitive scheme: still REJECT the wrong ones --------------- + + def test_wrong_schemes_are_still_rejected_on_the_bearer_path + h = handler(user: 'nobody', password: 'nothing', bearer_token: 'tok123') + + ['Digest tok123', 'Negotiate tok123', 'Bearerx tok123', 'bearerx tok123', + 'Basic tok123', 'tok123'].each do |header| + refute auth(h, header)['authenticated'], "#{header.inspect} must NOT authenticate" + end + end + + def test_wrong_schemes_are_still_rejected_on_the_basic_path + h = handler(user: 'alice', password: 'secret') + encoded = Base64.strict_encode64('alice:secret') + + ["Digest #{encoded}", "Negotiate #{encoded}", "Basicx #{encoded}", + "basicx #{encoded}", "Bearer #{encoded}", encoded].each do |header| + refute auth(h, header)['authenticated'], "#{header.inspect} must NOT authenticate" + end + end + + def test_scheme_is_carried_verbatim_into_the_bearer_carrier + h = handler(bearer_token: 'tok123') + seen = nil + h.define_singleton_method(:verify_bearer_token) do |credentials| + seen = credentials + super(credentials) + end + + auth(h, 'bearer tok123') + + assert_equal 'bearer', seen.scheme, 'the scheme must be carried verbatim, not normalized' + assert_equal 'tok123', seen.credentials + end + + # --- (b) a colon-less Basic payload must be REJECTED ------------------------ + + def test_colonless_basic_payload_is_rejected + h = handler(user: 'bob', password: '') + + refute auth(h, basic_header('Basic', 'bob'))['authenticated'], + 'a decoded Basic payload with NO colon must be rejected (RFC 7617 / reference partition-separator check)' + end + + def test_colonless_basic_payload_is_rejected_even_when_the_password_is_empty_by_config + h = handler(user: 'bob', password: nil) + + refute auth(h, basic_header('Basic', 'bob'))['authenticated'], + 'no colon means no credential pair, regardless of the configured password' + end + + def test_empty_password_with_an_explicit_trailing_colon_is_still_parsed + h = handler(user: 'bob', password: '') + + assert auth(h, basic_header('Basic', 'bob:'))['authenticated'], + 'an explicit trailing colon IS a separator -- username "bob", empty password' + end + + def test_password_containing_a_colon_keeps_everything_after_the_first_one + h = handler(user: 'alice', password: 'p:a:s:s') + + assert auth(h, basic_header('Basic', 'alice:p:a:s:s'))['authenticated'], + 'only the FIRST colon separates; the rest belongs to the password' + end +end diff --git a/tests/handle_request_core_test.rb b/tests/handle_request_core_test.rb index faafad77..61578a01 100644 --- a/tests/handle_request_core_test.rb +++ b/tests/handle_request_core_test.rb @@ -54,6 +54,72 @@ def test_wrong_password_is_unauthorized assert_equal 401, status end + # RFC 7235: the auth-scheme token is case-insensitive (the reference compares + # `scheme.lower() != "basic"` after partitioning on the first space). + def test_lowercase_basic_scheme_is_accepted + %w[basic BASIC BaSiC Basic].each do |scheme| + headers = { 'Authorization' => "#{scheme} #{Base64.strict_encode64('u:p')}" } + status, = @svc.handle_request('GET', 'http://host/', headers) + + assert_equal 200, status, "scheme #{scheme.inspect} must authenticate (RFC 7235)" + end + end + + def test_wrong_schemes_are_still_unauthorized + encoded = Base64.strict_encode64('u:p') + + %w[Digest Negotiate Basicx basicx Bearer].each do |scheme| + status, = @svc.handle_request('GET', 'http://host/', { 'Authorization' => "#{scheme} #{encoded}" }) + + assert_equal 401, status, "scheme #{scheme.inspect} must NOT authenticate" + end + end + + def test_schemeless_header_is_unauthorized + headers = { 'Authorization' => Base64.strict_encode64('u:p') } + status, = @svc.handle_request('GET', 'http://host/', headers) + + assert_equal 401, status + end + + # RFC 7617 / the reference's `if not separator: raise` -- a decoded Basic + # payload with NO colon is not a credential pair. `split(':', 2)` used to + # yield the 1-element ['u'] (password nil), leaving the rejection to a + # downstream nil-guard instead of the parse; the parse itself must reject. + def test_colonless_basic_payload_is_unauthorized + svc = SignalWire::SWML::Service.new(name: 'nocolon', basic_auth: ['u', '']) + headers = { 'Authorization' => "Basic #{Base64.strict_encode64('u')}" } + status, = svc.handle_request('GET', 'http://host/', headers) + + assert_equal 401, status, 'a colon-less Basic payload must be rejected' + end + + def test_decode_basic_auth_rejects_a_colonless_payload_at_the_parse + svc = SignalWire::SWML::Service.new(name: 'parse', basic_auth: %w[u p]) + + assert_equal [nil, nil], svc.send(:decode_basic_auth, "Basic #{Base64.strict_encode64('u')}"), + 'no separator means no credential pair -- the parse must reject, not return a 1-element split' + assert_equal %w[u p], svc.send(:decode_basic_auth, "Basic #{Base64.strict_encode64('u:p')}") + assert_equal ['u', ''], svc.send(:decode_basic_auth, "Basic #{Base64.strict_encode64('u:')}") + assert_equal ['u', 'p:a'], svc.send(:decode_basic_auth, "Basic #{Base64.strict_encode64('u:p:a')}") + end + + def test_explicit_trailing_colon_is_a_valid_empty_password + svc = SignalWire::SWML::Service.new(name: 'emptypw', basic_auth: ['u', '']) + headers = { 'Authorization' => "Basic #{Base64.strict_encode64('u:')}" } + status, = svc.handle_request('GET', 'http://host/', headers) + + assert_equal 200, status + end + + def test_password_containing_a_colon_keeps_everything_after_the_first + svc = SignalWire::SWML::Service.new(name: 'coloned', basic_auth: ['u', 'p:a:s:s']) + headers = { 'Authorization' => "Basic #{Base64.strict_encode64('u:p:a:s:s')}" } + status, = svc.handle_request('GET', 'http://host/', headers) + + assert_equal 200, status + end + def test_on_request_modifications_merged svc = SignalWire::SWML::Service.new(name: 'mod', basic_auth: %w[u p]) svc.define_singleton_method(:on_request) { |_body, _cb| { 'version' => '9.9.9' } } diff --git a/tests/web_web_service_test.rb b/tests/web_web_service_test.rb index 0bffa8bf..c5f8d608 100644 --- a/tests/web_web_service_test.rb +++ b/tests/web_web_service_test.rb @@ -136,3 +136,105 @@ def test_explicit_host_overrides_default svc&.stop end end + +# The WebService Authorization guard, over the real WEBrick listener. +# +# RFC 7235 makes the auth-scheme token case-INSENSITIVE and RFC 7617 requires a +# colon in the decoded Basic payload. The reference (fastapi.security.http +# HTTPBasic) partitions the header on the FIRST space, compares +# `scheme.lower() != "basic"`, then does +# `username, separator, password = data.partition(":")` and raises when +# `separator` is empty. Ruby used a fixed-offset `header[6..]` slice (which both +# hardcoded the scheme length and could not match a lowercase scheme) and +# discarded the separator into `_sep`, so `Basic ` -- no colon +# at all -- parsed as username "webuser" with a defaulted empty password. +class WebWebServiceAuthSchemeTest < Minitest::Test + USER = WebWebServiceTest::USER + PASS = WebWebServiceTest::PASS + + def setup + @dir = Dir.mktmpdir + File.write(File.join(@dir, 'hello.txt'), 'hello world') + @services = [] + end + + def teardown + @services.each(&:stop) + FileUtils.remove_entry(@dir) if @dir && File.directory?(@dir) + end + + # Start a WebService on an ephemeral port; returns the port. Registered for + # teardown so nothing is left listening. + def serve(password) + svc = SignalWire::Web::WebService.new(basic_auth: [USER, password]) + svc.add_directory('/static', @dir) + port = svc.start(host: '127.0.0.1', port: 0) + @services << svc + port + end + + def get_with_header(port, header) + uri = URI("http://127.0.0.1:#{port}/static/hello.txt") + req = Net::HTTP::Get.new(uri) + req['Authorization'] = header + Net::HTTP.start(uri.host, uri.port, read_timeout: 5) { |http| http.request(req) } + end + + def basic(scheme, payload) + "#{scheme} #{Base64.strict_encode64(payload)}" + end + + # --- case-insensitive scheme: ACCEPT --------------------------------------- + + def test_lowercase_basic_scheme_is_accepted + port = serve(PASS) + + %w[basic BASIC BaSiC Basic].each do |scheme| + res = get_with_header(port, basic(scheme, "#{USER}:#{PASS}")) + + assert_equal '200', res.code, "scheme #{scheme.inspect} must authenticate (RFC 7235)" + end + end + + # --- case-insensitive scheme: still REJECT the wrong ones ------------------ + + def test_wrong_schemes_are_still_rejected + port = serve(PASS) + + %w[Digest Negotiate Basicx basicx Bearer].each do |scheme| + res = get_with_header(port, basic(scheme, "#{USER}:#{PASS}")) + + assert_equal '401', res.code, "scheme #{scheme.inspect} must NOT authenticate" + end + end + + def test_schemeless_header_is_rejected + port = serve(PASS) + res = get_with_header(port, Base64.strict_encode64("#{USER}:#{PASS}")) + + assert_equal '401', res.code + end + + # --- the colon is mandatory ------------------------------------------------ + + def test_colonless_basic_payload_is_rejected + port = serve('') + res = get_with_header(port, basic('Basic', USER)) + + assert_equal '401', res.code, 'a colon-less Basic payload must be rejected' + end + + def test_explicit_trailing_colon_is_a_valid_empty_password + port = serve('') + res = get_with_header(port, basic('Basic', "#{USER}:")) + + assert_equal '200', res.code, 'an explicit trailing colon IS a separator' + end + + def test_password_containing_a_colon_keeps_everything_after_the_first + port = serve('p:a:s:s') + res = get_with_header(port, basic('Basic', "#{USER}:p:a:s:s")) + + assert_equal '200', res.code + end +end From 1dd8aa02693cf7d5955135274d552b5d886fd6de Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 11:53:30 -0400 Subject: [PATCH 17/90] chore: consolidate the never-published CHANGELOG entries into one 3.0.0 Per the owner's 2026-07-28 ruling, every CHANGELOG heading above a port's last genuinely published tag collapses into a single unreleased 3.0.0 entry. The Ruby port's published tags top out at v2.0.0 (verified against `git ls-remote --tags origin`, not just local tags), so the 3.2.0 / 3.1.0 / 3.0.2 headings were all unreleased drafts -- no released artifact regresses. They are consolidated into one `## 3.0.0` entry with NO content dropped: all twelve bullets survive under the merged Added / Fixed sections, with the two REST-resource additions (client.projects, client.messages) folded in next to the spec-generated REST surface bullet they extend. lib/signalwire/version.rb already declares 3.0.0; this is the static mirror that META-CONSISTENT cross-checks against it: meta_consistent.py --port ruby exit 1 -> exit 0 (was: manifest version '3.0.0' != top CHANGELOG entry '3.2.0') This sets version INTENT only -- no tag, no release. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- CHANGELOG.md | 32 ++++++++++++++------------------ 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d0561040..060f5996 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,32 +3,28 @@ All notable changes to the SignalWire AI Agents SDK for Ruby (`signalwire-sdk`) are documented here. This project adheres to [Semantic Versioning](https://semver.org). -## 3.2.0 +## 3.0.0 -### Added -- `client.messages` — the new `/api/messaging/messages` send/redact REST - resource (`create` to send an SMS/MMS message, `update` to redact a message - body). Distinct from the `client.logs.messages` message-log namespace. - Generated from the canonical `messages` REST spec with full success + error - wire-test coverage. - -## 3.1.0 +Parity release aligning the Ruby SDK with the Python reference SDK across the +REST, RELAY, SWML, and SWAIG surfaces, and the fleet-wide convergence version: +every SignalWire SDK port declares 3.0.0. Nothing in the 3.x range was ever +published — this port's published tags top out at `v2.0.0` — so the +previously-drafted unreleased 3.0.2 / 3.1.0 / 3.2.0 entries are consolidated +here rather than shipped as a staggered series. ### Added +- Spec-generated REST surface: a typed REST client with generated typed I/O and + full success + error wire-test coverage across the SignalWire REST namespaces. - `client.projects` — the new `/api/projects` full-CRUD project-management REST resource (list / create / get / update / delete subprojects, plus `rotate_signing_key`). Distinct from the singular `client.project` token namespace. Generated from the canonical `projects` REST spec with full success + error wire-test coverage. - -## 3.0.2 - -Parity release aligning the Ruby SDK with the Python reference SDK across the -REST, RELAY, SWML, and SWAIG surfaces. - -### Added -- Spec-generated REST surface: a typed REST client with generated typed I/O and - full success + error wire-test coverage across the SignalWire REST namespaces. +- `client.messages` — the new `/api/messaging/messages` send/redact REST + resource (`create` to send an SMS/MMS message, `update` to redact a message + body). Distinct from the `client.logs.messages` message-log namespace. + Generated from the canonical `messages` REST spec with full success + error + wire-test coverage. - `paginate()` parity on read resources via a `PaginatedIterator`. - Typed SWAIG `ParameterSchema` builder for `define_tool`, and typed RELAY state enums (`Device`, `CollectConfig`, record/tap direction/format/codec, skill names). From 65ca770c3e9e51980982253203a748749a8e3a7f Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 12:14:37 -0400 Subject: [PATCH 18/90] =?UTF-8?q?docs:=20add=20.version-frozen=20=E2=80=94?= =?UTF-8?q?=20version=20and=20SemVer=20floor=20pinned=20at=203.0.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Owner ruling 2026-07-28. DOCUMENTATION ONLY: no gate reads this file and nothing fails on its presence. It records why the version looks the way it does, so the next session does not re-derive it or casually bump one — and it carries the delete-before-release checklist in its own body. Nothing 3.x/4.x was ever published (git ls-remote tops out at v1.1.2 for rust/dotnet, v2.0.x for most others), so the freeze rewrote no real history. Exempted in porting-sdk root_hygiene.py 287b7f2. --- .version-frozen | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .version-frozen diff --git a/.version-frozen b/.version-frozen new file mode 100644 index 00000000..c0bc76a8 --- /dev/null +++ b/.version-frozen @@ -0,0 +1,38 @@ +# VERSION FREEZE — TEMPORARY. DELETE THIS FILE BEFORE RELEASING. +# +# Ruled by the owner 2026-07-28. This port declares version 3.0.0, and its SemVer +# release floor (port_signatures.baseline.json -> baseline_version) is pinned at +# 3.0.0 with the recorded surface payload overwritten to match today's surface. +# +# THIS FILE IS DOCUMENTATION ONLY (owner ruling, 2026-07-28). No gate reads it and +# nothing fails if it is present. It exists so that neither a person nor a future +# session has to re-derive why the versions look the way they do — and so nobody +# casually bumps one. +# +# WHY THE FREEZE: versions had drifted to 3.0.2 / 3.2.0 / 3.2.1 / 3.3.0 / 4.0.0 +# across the fleet with NOTHING EVER PUBLISHED above v2.x. `git ls-remote --tags +# origin` tops out at v1.1.2 for rust/dotnet and v2.0.x for most others; php's +# v3.2.0 tag is local-only, zero remote matches. That scatter was never a release +# history, so collapsing it rewrote nothing real. +# +# WHILE THIS FILE EXISTS: +# - do NOT bump this port's version +# - do NOT re-anchor its release floor +# - DO land surface changes freely. The floor is a snapshot of the 3.0.0 wave, +# not of a published release, so SEMVER-DIFF will not flag anything already in +# today's surface. Anything added AFTER the freeze is still caught normally. +# +# BEFORE CUTTING A RELEASE: +# 1. DELETE this file in every port. +# 2. Re-anchor each port_signatures.baseline.json to the actual released +# commit/tag and regenerate its surface payload from that point. +# 3. Re-enable enforcement: ports invoke SEMVER-DIFF with --report-only today +# (the D5 "re-anchor at cut" setting). Dropping that flag turns semver +# enforcement back on. +# +# NOTE: perl is deliberately NOT floor-pinned. It is the only port anchored to a +# genuinely published tag (v2.0.2, sha 83376ff) and already passes at 3.0.0; +# overwriting it would destroy the fleet's only real release anchor. +# +# Owner rulings: porting-sdk tasks #143 (version) and #146 (floor). +# Full context: porting-sdk/SESSION_HANDOFF_2026-07-28.md From 3e50a496f3c1b5bd2d1439cf2e5d8770d1071893 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 13:20:15 -0400 Subject: [PATCH 19/90] fix(security): mint SWAIG tool tokens with PADDED urlsafe base64 + wire TOKEN-INTEROP MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The token envelope used Base64.urlsafe_encode64(token_raw, padding: false). The reference keeps the '=' padding and its validator RAISES on a stripped '=' — so every token this port minted was unusable to the reference and to any port that decodes strictly, even with a correct key and a correct HMAC. In production every secure tool call fails authentication. create_session keeps padding: false — it mirrors secrets.token_urlsafe, which is genuinely unpadded. Only the token envelope changed. port_signatures.json is a fresh regeneration: the enumerator now records the relay handler params as callable<...> rather than a dangling class: ref to the EventHandler/CallHandler type ALIASES. Also wires the TOKEN-INTEROP gate (property 3 of the SWAIG tool-token contract: a token this port MINTS validates under the REFERENCE's own decoder). SECURE-DEFAULT proves a token is minted and the fleet keying check proves the HMAC key; NEITHER sees the base64 ENVELOPE, so a port can ship correct-key correct-HMAC tokens that no other implementation accepts. Per-PR rather than nightly — a security property should not wait. Seven of the ten ports shipped an unpadded envelope, invisible to each port's own tests because every port's DECODER tolerates missing padding while the reference's urlsafe_b64decode RAISES on it — so round-tripping against ourselves could never catch it. That is why the gate validates against the reference's decoder. Verified: TOKEN-INTEROP exit 0; reverting padding: false on the envelope reproduces "urlsafe_b64decode raised Error('Incorrect padding')", so the gate fails for the right reason. rake test 2728 runs / 7662 assertions, 0 failures. Full run-ci PASS. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- bin/token-interop-mint | 57 ++++++++++++++++++++++ lib/signalwire/security/session_manager.rb | 11 ++++- port_signatures.json | 30 ++++++------ scripts/run-ci.sh | 15 ++++++ 4 files changed, 97 insertions(+), 16 deletions(-) create mode 100755 bin/token-interop-mint diff --git a/bin/token-interop-mint b/bin/token-interop-mint new file mode 100755 index 00000000..7870df1b --- /dev/null +++ b/bin/token-interop-mint @@ -0,0 +1,57 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# Copyright (c) 2025 SignalWire +# +# Licensed under the MIT License. +# See LICENSE file in the project root for full license information. + +# +# token-interop-mint — the Ruby port's TOKEN-INTEROP mint fixture for the +# cross-port checker (porting-sdk/scripts/diff_port_token_interop.py). +# +# The contract being proven is property 3 of the SWAIG tool-token contract: a +# token this port MINTS must validate under the REFERENCE's own decoder. The +# other two properties (that a token is minted at all; that the HMAC is keyed +# with the secret_key STRING's bytes) already had coverage — this one did not, +# and a port can pass both and still emit a token no other implementation +# accepts, in which case every secure tool call fails authentication in +# production. +# +# Protocol: read the FIXED mint inputs from the environment (the checker owns +# them, so this fixture cannot drift from the values it is verified against), +# construct a SessionManager with that secret key, mint ONE token, and print +# JUST the token on stdout. Anything else belongs on stderr. +# +# Run from the signalwire-ruby repo root: +# +# bundle exec ruby bin/token-interop-mint + +# Keep stdout PURE (the checker reads the token from it); route setup/logging +# noise to stderr, restoring stdout only to emit the token. +REAL_STDOUT = $stdout.dup +$stdout.reopen($stderr) +require_relative '../lib/signalwire' + +def required(name) + value = ENV.fetch(name, nil) + return value unless value.nil? || value.empty? + + abort("#{name} is not set — the TOKEN-INTEROP checker supplies the fixed mint " \ + 'inputs in the environment; run this via diff_port_token_interop.py --mint-cmd.') +end + +secret_key = required('SW_TOKEN_INTEROP_SECRET_KEY') +call_id = required('SW_TOKEN_INTEROP_CALL_ID') +function_name = required('SW_TOKEN_INTEROP_FUNCTION_NAME') + +# The token must carry a FUTURE expiry, which the checker verifies. 900s is passed +# EXPLICITLY (not left to the default) so every port's fixture mints with the same +# lifetime regardless of what each port's default happens to be — this gate measures +# the ENVELOPE, and a default drifting under it must not silently change what is minted. +# (As of the 2026-07-27 fold this port's default IS 900, matching the reference at +# session_manager.py:30, so the pin is now also a redundant statement of the default; +# it stays explicit because the pin's job is isolating the gate, not tracking the default.) +manager = SignalWire::Security::SessionManager.new(secret_key: secret_key, token_expiry_secs: 900) +REAL_STDOUT.puts(manager.generate_token(function_name, call_id)) +REAL_STDOUT.flush diff --git a/lib/signalwire/security/session_manager.rb b/lib/signalwire/security/session_manager.rb index 96b8201d..8089ff87 100644 --- a/lib/signalwire/security/session_manager.rb +++ b/lib/signalwire/security/session_manager.rb @@ -66,7 +66,16 @@ def create_token(function_name, call_id) nonce = SecureRandom.hex(8) signature = compute_hmac("#{call_id}:#{function_name}:#{expiry}:#{nonce}") token_raw = "#{call_id}.#{function_name}.#{expiry}.#{nonce}.#{signature}" - Base64.urlsafe_encode64(token_raw, padding: false) + # PADDED urlsafe Base64 — the reference is +base64.urlsafe_b64encode+, which + # KEEPS the '=' padding, and its +validate_token+ decodes with + # +urlsafe_b64decode+, which RAISES on a stripped '='. +padding: false+ made + # every token this port minted unusable to the reference (and to any port that + # decodes strictly) even though the message and HMAC were correct. Our own + # +validate_token+ still accepted them, because +urlsafe_decode64+ tolerates + # missing padding on urlsafe input — that asymmetry is why round-tripping + # against ourselves could not catch it, and why TOKEN-INTEROP validates against + # the REFERENCE decoder instead. + Base64.urlsafe_encode64(token_raw) end alias generate_token create_token # Python-surface name for minting. diff --git a/port_signatures.json b/port_signatures.json index 3a1592e2..4505cc6a 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -21739,7 +21739,7 @@ }, { "name": "handler", - "type": "class:signalwire.relay.call.EventHandler", + "type": "callable,void>", "required": true }, { @@ -23284,7 +23284,7 @@ }, { "name": "handler", - "type": "class:signalwire.relay.client.CallHandler", + "type": "callable,void>", "required": true }, { @@ -23321,7 +23321,7 @@ }, { "name": "handler", - "type": "class:signalwire.relay.client.MessageHandler", + "type": "callable,void>", "required": true }, { @@ -37965,13 +37965,13 @@ }, { "name": "agent", - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false, "default": null }, { "name": "params", - "type": "any", + "type": "optional>", "required": false, "default": null } @@ -38982,13 +38982,13 @@ }, { "name": "agent", - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false, "default": null }, { "name": "params", - "type": "any", + "type": "optional>", "required": false, "default": null } @@ -39464,13 +39464,13 @@ }, { "name": "agent", - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false, "default": null }, { "name": "params", - "type": "any", + "type": "optional>", "required": false, "default": null } @@ -43299,11 +43299,11 @@ "signalwire.skills.api_ninjas_trivia.skill.ApiNinjasTriviaSkill": { "params": { "agent": { - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false }, "params": { - "type": "any", + "type": "optional>", "required": false } } @@ -43311,11 +43311,11 @@ "signalwire.skills.play_background_file.skill.PlayBackgroundFileSkill": { "params": { "agent": { - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false }, "params": { - "type": "any", + "type": "optional>", "required": false } } @@ -43335,11 +43335,11 @@ "signalwire.skills.weather_api.skill.WeatherApiSkill": { "params": { "agent": { - "type": "any", + "type": "class:signalwire.core.agent_base.AgentBase", "required": false }, "params": { - "type": "any", + "type": "optional>", "required": false } } diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index 471a752a..3062556d 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -139,6 +139,21 @@ sched_gate BEHAVIORAL-NIGHTLY tier=nightly defer=1 desc="behavioral suite, night -- python3 "$PORTING_SDK_DIR/scripts/suites/behavioral.py" --port ruby --repo "$PORT_ROOT" \ --rules WAIT-LIVENESS,RELAY-LIVENESS,SECRET-SCRUB-LIVE +# TOKEN-INTEROP — property 3 of the SWAIG tool-token contract: a token this port MINTS +# must validate under the REFERENCE's own decoder. SECURE-DEFAULT proves a token is +# minted and the fleet keying check proves the HMAC key; NEITHER sees the base64 +# ENVELOPE, so a port can ship correct-key correct-HMAC tokens that no other +# implementation accepts — in production every secure tool call then fails auth. Six of +# the ten ports shipped exactly that (an unpadded envelope), invisible to their own tests +# because each port's DECODER tolerates missing padding while the reference's +# urlsafe_b64decode RAISES on it — so round-tripping against ourselves could never catch +# it. One mint + a pure-python validation → cheap, per-PR (a security property must not +# wait for nightly). Its OWN line rather than a member of the BEHAVIORAL suite line, +# which is defer=1 (heavy wave). +sched_gate TOKEN-INTEROP desc="a token this port mints validates under the reference's decoder (padded urlsafe base64, ':'-signed / '.'-enveloped, hex HMAC keyed by the secret_key string)" \ + -- python3 "$PORTING_SDK_DIR/scripts/diff_port_token_interop.py" --port ruby \ + --mint-cmd "bundle exec ruby $PORT_ROOT/bin/token-interop-mint" + # DOC-TRUTH (one markdown walk): DOC-AUDIT/DOC-LINKS/DOC-LANG-PURITY/DOC-ENV/COUNT-CLAIM/ # ACCESSOR-TRUTH/STATUS-CLAIM/README-INCLUDE. res=surface: DOC-AUDIT reads port_surface.json # that the SURFACE suite regenerates+restores. From 48bd4fe66a9dec6c3859dfa56e15f90a56a1dc51 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 20:22:00 -0400 Subject: [PATCH 20/90] chore(gate): re-baseline the TYPE-EROSION ratchet onto the corrected differ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit porting-sdk 7034c33 stopped TYPE-EROSION from counting a MISALIGNED slot as an erased type. The gate keyed on position, which is only meaningful while both param lists describe the same parameters; where a port's list has a different SHAPE (different arity, or a variadic catch-all standing in for a named param) index i was a different parameter on each side, and an `any` there was reported as an erased type. Those methods are already reported — correctly — by diff_port_signatures as param-count-mismatch. So this port's old ratchet banked a number that was part real erosion and part double-billed count-mismatch. Re-baselined onto what the corrected differ measures. ratchet 97 -> 16 (the delta is measurement correction, not a surface change) No port code changed and no erosion was fixed by this commit: the number moves because the MEASUREMENT was corrected, not because the surface improved. The ratchet doctrine is unchanged — drive it DOWN, never up — and it now ratchets against a number that means one thing. Fleet-wide the same correction takes 524 -> 257; 292 of the 524 were the artifact. The skip is never silent: each run prints how many methods went unmeasured and names the gate that owns them. Verified: diff_port_type_erosion.py --port ruby --repo . --max 16 -> exit 0. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- scripts/run-ci.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index 3062556d..cdda7e99 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -122,8 +122,8 @@ sched_gate SURFACE desc="surface parity suite (SIGNATURES/DRIFT/SURFACE-FRESH/SU # declared optional> and go still shipped a bare string, with no gate # red. RATCHET, not a hard gate: dynamic languages cannot always express a type, so this # banks the current count and fails only on REGRESSION. Drive the number DOWN; never up. -sched_gate TYPE-EROSION desc="port did not erase a reference-declared param type (ratchet 97)" \ - -- python3 "$PORTING_SDK_DIR/scripts/diff_port_type_erosion.py" --port ruby --repo "$PORT_ROOT" --max 97 +sched_gate TYPE-EROSION desc="port did not erase a reference-declared param type (ratchet 16)" \ + -- python3 "$PORTING_SDK_DIR/scripts/diff_port_type_erosion.py" --port ruby --repo "$PORT_ROOT" --max 16 # GEN (regen-from-specs family): the 5 GEN-FRESH rules. sched_gate GEN defer=1 desc="generated-code freshness suite (GEN-FRESH/-TESTS/-RELAY/-SWAIG/-SWML)" \ From d6a1261610fef377276c9edd55117a2e576a8383 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Tue, 28 Jul 2026 22:53:00 -0400 Subject: [PATCH 21/90] fix(logging): put the control-char scrub ON the emission path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ruby's `strip_control_chars` already matched the reference's contract exactly — event map in, string values scrubbed, non-strings untouched. It also had ZERO call sites. `Logging::Logger#log` wrote the caller's message straight to `@output`, so a NUL, a BEL, or an ESC-[ escape reached the terminal verbatim and could forge log lines. The reference registers this scrub in BOTH of its structlog processor chains (logging_config.py:205,233); here it was a method nobody invoked. That makes ruby the clearest case in the fleet of why a correct signature is not protection: rust/cpp/java each had the WRONG shape AND no callers, and fixing their shape alone would have turned every gate green while leaving the emitter exposed. ruby had the RIGHT shape and no callers, and was equally exposed. The signature was never the thing standing between a caller and a forged log line. strip_control_chars_value NEW internal per-value scrub (the unit the emitter needs; strip_control_chars now delegates to it). Not port surface — the public contract is unchanged. Logger#log now scrubs before `@output.puts` THE TEST IS THE POINT, and ruby had NONE — no logging test file existed at all, and nothing anywhere referenced strip_control_chars. New tests/core_logging_config_test.rb (matching the core_* convention for signalwire/core/ modules) covers the public map contract AND the wiring. The wiring test drives the real Logger and reads what it wrote, so removing the scrub turns it RED: NUL survived into the emitted line: "[2026-07-28 22:50:52] INFO [inject.test] usersaid\e[31mRED\a\n" A test that called strip_control_chars directly passes against that same break. Two harness details the test has to respect, both learned the hard way in sibling ports: the suite sets SIGNALWIRE_LOG_MODE=off process-wide (so the capture helper forces the level for its block and restores it), and the logger writes to $stderr (so that is swapped and restored in the same ensure). Neither leaks to a concurrent sibling. Also asserts tab/newline/CR SURVIVE — a scrub that ate them would satisfy "no control chars" while mangling every multi-line message. Verified: run-tests.sh -> exit 0, 2731 runs, 7678 assertions, 0 failures. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/core/logging_config.rb | 14 +++++++++++++- lib/signalwire/logging.rb | 8 +++++++- tests/core_logging_config_test.rb | Bin 0 -> 2934 bytes 3 files changed, 20 insertions(+), 2 deletions(-) create mode 100644 tests/core_logging_config_test.rb diff --git a/lib/signalwire/core/logging_config.rb b/lib/signalwire/core/logging_config.rb index 7a4555d1..0c76e66d 100644 --- a/lib/signalwire/core/logging_config.rb +++ b/lib/signalwire/core/logging_config.rb @@ -72,11 +72,23 @@ def env_set?(name) # @return [Hash] the same hash with string values sanitised def strip_control_chars(event_dict) event_dict.each do |key, value| - event_dict[key] = value.gsub(CONTROL_CHAR_RE, '') if value.is_a?(String) + event_dict[key] = strip_control_chars_value(value) if value.is_a?(String) end event_dict end + # Strip control characters from a SINGLE string. + # + # INTERNAL: the reference's public contract is the event-map form + # (strip_control_chars above); this is the per-value scrub that form is + # built out of, and the unit the emitter needs. Not port surface. + # + # @param value [String] the raw log string + # @return [String] the sanitised string + def strip_control_chars_value(value) + value.gsub(CONTROL_CHAR_RE, '') + end + # Configure the SDK logging system once, globally, based on the # SIGNALWIRE_LOG_MODE / SIGNALWIRE_LOG_LEVEL environment variables. # Mirrors signalwire.core.logging_config.configure_logging: idempotent — diff --git a/lib/signalwire/logging.rb b/lib/signalwire/logging.rb index 3df28e60..ad77cdd0 100644 --- a/lib/signalwire/logging.rb +++ b/lib/signalwire/logging.rb @@ -64,7 +64,13 @@ def log(level, msg) return if LEVELS[level] < LEVELS[Logging.global_level] timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S') - @output.puts "[#{timestamp}] #{level.upcase} [#{@name}] #{msg}" + # Scrub control characters BEFORE emitting — log-injection defence, and the + # reason the reference registers strip_control_chars in both of its structlog + # processor chains. A port that merely EXPOSES the scrub without putting it on + # the emission path offers no protection at all: a caller-supplied "\u0000" or + # an "\e[" escape reaches the terminal verbatim and can forge log lines. + safe = Core::LoggingConfig.strip_control_chars_value(msg.to_s) + @output.puts "[#{timestamp}] #{level.upcase} [#{@name}] #{safe}" end end diff --git a/tests/core_logging_config_test.rb b/tests/core_logging_config_test.rb new file mode 100644 index 0000000000000000000000000000000000000000..20cf1f31c6988124b5ed8adad34a715cff3b7373 GIT binary patch literal 2934 zcmb_e+in{-5Y1Zw|3Y5|QUTe8EIVnQl)8ZHD2@TeE^G%u8y9QtF12DpksDs5x=Db3 zM8B|K(lg}Bm&5^rq7R0=LKhcEMioP*18}}&{xA` z?A6if(eWYu^Vi?_6d|1@RZ^Zr6{67kimXW&a-qCe_-I9#k2dQW zdY`_C2I*ixdp}WcjwILzE9-RK8?NtXO6oe_iwjX+#NFM8&#IeylkOfrO7b5$R3aM# zUX`CWx(BBjm|Iym*P{SQgr-4?A%!p)vYppmfWIfhcV$Ict%Y)wS*TCP)@)}+tJ<8`!}FMUX2Sbq$&$s|=t_#&w8jQS95vg;qSJ;%nh^{C=kJ@1PUwB;<>Vb zBE6>%_(A4AQ2re$Gqan$h>q~U3sryn`iF-LB;=dk7Ijz#I%1GuQ>9~#IEv*KiX4&P{O1ZWh7&is945Gk zJf1QhMaakpycQksJSL-`U8PLt(0G)H5_n^%X^Ej{8n|v?TL-nxQGj6Hi$?k{0qU)k ztuM4}gf3tO?Y0#a`v#c!5NPVLp@$ctviidC|Bo&lKRH)4dHE{HC41KxyFa^0<|d;p z`T(Z_Cw+R#O(8x1^M1hW&ZCN_WS&gWNqXn#cRu22F3+ z$)26fcz#w$*7i!(k~Te9isWB26?0k^-zR%KlKj@N!1gkpetbRXO=yonROVb zY(wKh^EbZG4oYpSx7}Pu&*Z1U0JbBH-#}u9MJhEkW3e5WDq=z4-DDfvli}*Fn};od z#I8*eb|KTG_L+f`qd+RSqy&O~=R+-Bw(M6}kMe3`Z3173l_9~ki-cK?R*NzNqL}iz z8{O(FI3e-^{6`03!vIR>;?`Au`Q2eZ&1=G_(Y6HWl1Nf1Bd;N_bCy=hqmvP+ly4*! zi}W9@oj@$hcgMHaiTgZ2eq75kHl6$xkN7)FNT-$e5b4 Date: Wed, 29 Jul 2026 00:09:04 -0400 Subject: [PATCH 22/90] fix(logging): drop the port-only strip_control_chars_value; route the emitter through the map contract MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit d6a1261 put the control-char scrub on the emission path via a NEW `strip_control_chars_value`. That method is surface the reference does not have, and the nightly surface gate said so: modules.signalwire.core.logging_config.functions[5]: committed='' fresh='strip_control_chars_value' It is a nightly-tier gate, which is why the per-PR run-ci was green locally. The doc-comment I wrote even claimed "Not port surface" — but a comment is not a mechanism, and nothing enforced it. The rule is not to project or allow-list an invented symbol, it is to not invent one. The emitter now goes through the reference's own event-map contract — one key in, one key out — and the extra method is DELETED. The scrub body moved back inline into `strip_control_chars`, so there is one implementation and one public entry point, matching the reference. strip_control_chars_value DELETED (was port-only surface) strip_control_chars scrubs inline; unchanged contract Logger#log strip_control_chars('event' => msg.to_s)['event'] The wiring test still fails when the scrub is removed — re-verified after the refactor, so the guard is not now vacuous. The failure names the surviving NUL and prints the raw emitted line. Also extracted `with_stderr_and_level` out of the test's capture_log. That was a REAL pre-existing rubocop offense from d6a1261 (Metrics/MethodLength 12/10) which the nightly LINT gate surfaces and the cheap wave does not — confirmed pre-existing by re-running lint with this commit's source changes stashed. Verified: run-tests.sh -> exit 0, 2731 runs / 7681 assertions, 0 failures. run-lint.sh -> 1376 files inspected, no offenses detected. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi --- lib/signalwire/core/logging_config.rb | 14 +------------- lib/signalwire/logging.rb | 6 +++++- tests/core_logging_config_test.rb | Bin 2934 -> 3159 bytes 3 files changed, 6 insertions(+), 14 deletions(-) diff --git a/lib/signalwire/core/logging_config.rb b/lib/signalwire/core/logging_config.rb index 0c76e66d..7a4555d1 100644 --- a/lib/signalwire/core/logging_config.rb +++ b/lib/signalwire/core/logging_config.rb @@ -72,23 +72,11 @@ def env_set?(name) # @return [Hash] the same hash with string values sanitised def strip_control_chars(event_dict) event_dict.each do |key, value| - event_dict[key] = strip_control_chars_value(value) if value.is_a?(String) + event_dict[key] = value.gsub(CONTROL_CHAR_RE, '') if value.is_a?(String) end event_dict end - # Strip control characters from a SINGLE string. - # - # INTERNAL: the reference's public contract is the event-map form - # (strip_control_chars above); this is the per-value scrub that form is - # built out of, and the unit the emitter needs. Not port surface. - # - # @param value [String] the raw log string - # @return [String] the sanitised string - def strip_control_chars_value(value) - value.gsub(CONTROL_CHAR_RE, '') - end - # Configure the SDK logging system once, globally, based on the # SIGNALWIRE_LOG_MODE / SIGNALWIRE_LOG_LEVEL environment variables. # Mirrors signalwire.core.logging_config.configure_logging: idempotent — diff --git a/lib/signalwire/logging.rb b/lib/signalwire/logging.rb index ad77cdd0..fb567b24 100644 --- a/lib/signalwire/logging.rb +++ b/lib/signalwire/logging.rb @@ -69,7 +69,11 @@ def log(level, msg) # processor chains. A port that merely EXPOSES the scrub without putting it on # the emission path offers no protection at all: a caller-supplied "\u0000" or # an "\e[" escape reaches the terminal verbatim and can forge log lines. - safe = Core::LoggingConfig.strip_control_chars_value(msg.to_s) + # Route through the reference's event-map contract rather than a second + # public helper: a port-only `strip_control_chars_value` would be surface + # the reference does not have, and the surface gate reports it as an + # invented addition. One key in, one key out. + safe = Core::LoggingConfig.strip_control_chars('event' => msg.to_s)['event'] @output.puts "[#{timestamp}] #{level.upcase} [#{@name}] #{safe}" end end diff --git a/tests/core_logging_config_test.rb b/tests/core_logging_config_test.rb index 20cf1f31c6988124b5ed8adad34a715cff3b7373..957e019c8f59fdb204d1957640460abd2534b090 100644 GIT binary patch delta 285 zcmaKnJqiLb5QQs2V`U>^;{yd-Lf&WKNu3pW)-htE@JCRyot5h^{2EL zc+Bv<_vYDs^llC2Le`(0bDKql6=X~lD-lULk(}@{NyyBw62!|ifY9#FHg4DMZy7K| zc#e-4y)k$UHY21`^H`#GK%z~(Vvas`wU*p}Dxj}n8ukYRoxa1^-SHBee8n02rCla5(D{#>yC0I2tl>lDn delta 127 zcmcaE@l9+4E7#-%ZokQ_TvGB$sp*+{Tnb>IQe2XfT2!Q9tB_QhmX=xs6rQ}FTb<1+ zB{iuueX={36MJ!KQ7TCIKeznkgWReH#ffF9De*a}WvMw}LsIinz%;}Fz2cIh%)E4< I2uK`+0lAkZ`v3p{ From 1228980aa7ad7f0be4c82f5465af670a7f4fd916 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 11:01:41 -0400 Subject: [PATCH 23/90] docs: finish c36ddd0's required-handler flip in docs/, relay/ and the examples it missed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit SNIPPET-RUN (10 failures) and EXAMPLES-RUN (2 crashes) were red for ONE shared cause, and it is stale docs, not an SDK defect. No source changed. c36ddd0 ("fix(parity): burn required-flip/default-invented/default-mismatch to zero") made the handler a REQUIRED POSITIONAL on the registration methods, matching the reference and the oracle (python_signatures.json records handler required:true). Ruby cannot let a block satisfy a required positional, so `client.on_call { }` became `client.on_call(nil) { }` — the commit message calls this "the intended breaking consequence". That commit updated lib/, tests/ and examples/ but MISSED docs/, relay/docs/, relay/README.md and relay/examples/. SNIPPET-RUN 9 stale snippets raising `missing keyword: :handler` / `wrong number of arguments (given 0, expected 1)` EXAMPLES-RUN relay/examples/relay_answer_and_welcome.rb and relay_ivr_connect.rb still used `client.on_call do` — the relay/examples/ subtree was missed entirely A SECOND DEFECT THAT NO GATE WOULD HAVE CAUGHT. c36ddd0 also REORDERED register_routing_callback from `(path, &block)` to `(callback_fn, path = '/sip', &block)`. Five doc sites still showed `register_routing_callback('/customer') do |...|`, which does NOT raise: it binds the path string into the callback_fn slot and silently leaves path at '/sip'. Anyone copying that doc registered a callback on the WRONG PATH with no error. Fixed at all 5 sites. (Same callback-vs-path confusion found in go, dotnet and cpp this session — ruby is the only one where it fails silently instead of at compile time.) Also corrected 5 stale `def` signature blocks in api_reference.md against real source — define_tool documented `secure: false` where the code says `true`, and was missing wait_file / wait_file_loops. SNIPPET_RUN_ALLOW.md: two EXISTING human-approved entries re-synced 131->132 and 166->167 after a README edit shifted the fences. No new entries, rationales unchanged, approvals intact (burn-ruby, 2026-07-09). Note these have now been re-synced twice — the allowlist keys on path:LINE, which drifts under ordinary doc edits; tracked separately as a gate-design issue. Verification (independently re-run, not the lane's word): sw-verify ruby --gates SNIPPET-RUN,EXAMPLES-RUN -> exit 0 SNIPPET-RUN PASS (was 10 failed / exit 1) EXAMPLES-RUN PASS (was 36 server-started / 2 CRASHED / exit 1) NO-LAUNDER PASS (impossible: 15 · approved: 4 · idiom: 1 · unclassified: 0 · banned: 0) The lane's own run recorded 60 ran (22 exit0, 38 server-started, 0 CRASHED) — the 36->38 is the two fixed examples now genuinely STARTING, not merely failing to crash. run-format.sh -> exit 0, 1376 files inspected, no offenses, no tree changes. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- SNIPPET_RUN_ALLOW.md | 4 +- docs/agent_guide.md | 108 ++++++++++----------- docs/api_reference.md | 60 ++++++------ docs/architecture.md | 8 +- docs/contexts_guide.md | 4 +- docs/datamap_guide.md | 2 +- docs/mcp_integration.md | 4 +- docs/sdk_features.md | 8 +- docs/skills_system.md | 4 +- docs/swaig_reference.md | 2 +- docs/swml_service_guide.md | 6 +- docs/third_party_skills.md | 4 +- relay/README.md | 6 +- relay/docs/client-reference.md | 8 +- relay/docs/events.md | 2 +- relay/docs/getting-started.md | 4 +- relay/docs/messaging.md | 6 +- relay/examples/relay_answer_and_welcome.rb | 2 +- relay/examples/relay_ivr_connect.rb | 2 +- 19 files changed, 125 insertions(+), 119 deletions(-) diff --git a/SNIPPET_RUN_ALLOW.md b/SNIPPET_RUN_ALLOW.md index 2264d8f4..cb928204 100644 --- a/SNIPPET_RUN_ALLOW.md +++ b/SNIPPET_RUN_ALLOW.md @@ -26,5 +26,5 @@ themselves are exercised by EXAMPLES-RUN; here they each start a blocking server make a live REST call and so cannot run standalone under SNIPPET-RUN. - README.md:49 — quickstart_agent: ends with agent.run (blocking WEBrick server) (burn-ruby, 2026-07-09) -- README.md:131 — quickstart_relay: client.run connects to a live RELAY WebSocket (burn-ruby, 2026-07-09; line re-synced 2026-07-15) -- README.md:166 — quickstart_rest: makes live REST calls; base URL derives from the space host, no loopback-mock override; the #rest region also references call_id defined outside the region (burn-ruby, 2026-07-09; line re-synced 2026-07-15) +- README.md:132 — quickstart_relay: client.run connects to a live RELAY WebSocket (burn-ruby, 2026-07-09; line re-synced 2026-07-15, 2026-07-29) +- README.md:167 — quickstart_rest: makes live REST calls; base URL derives from the space host, no loopback-mock override; the #rest region also references call_id defined outside the region (burn-ruby, 2026-07-09; line re-synced 2026-07-15, 2026-07-29) diff --git a/docs/agent_guide.md b/docs/agent_guide.md index 596f52cb..d1328c88 100644 --- a/docs/agent_guide.md +++ b/docs/agent_guide.md @@ -286,7 +286,7 @@ agent.define_tool( 'description' => 'The city or location to get weather for' } }, - secure: true # Optional; pass secure: true to require a per-call token + secure: true, handler: nil # Optional; pass secure: true to require a per-call token ) do |args, _raw_data| # Extract the location parameter location = args['location'] || 'Unknown location' @@ -319,7 +319,7 @@ agent.define_tool( 'description' => 'The city or location to get weather for' } }, - webhook_url: 'https://your-service.com/weather-endpoint' + webhook_url: 'https://your-service.com/weather-endpoint', handler: nil ) do |_args, _raw_data| # This block will never be called locally when webhook_url is provided. # The external service at webhook_url will receive the function call instead. @@ -362,7 +362,7 @@ agent = SignalWire::AgentBase.new(name: 'hybrid-agent', route: '/hybrid') agent.define_tool( name: 'get_help', description: 'Get help information', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new('I can help you with weather and news!') end @@ -374,7 +374,7 @@ agent.define_tool( parameters: { 'location' => { 'type' => 'string', 'description' => 'City name' } }, - webhook_url: 'https://weather-service.com/api/weather' + webhook_url: 'https://weather-service.com/api/weather', handler: nil ) do |_args, _raw_data| # This won't be called for external webhooks end @@ -386,7 +386,7 @@ agent.define_tool( parameters: { 'topic' => { 'type' => 'string', 'description' => 'News topic' } }, - webhook_url: 'https://news-service.com/api/news' + webhook_url: 'https://news-service.com/api/news', handler: nil ) do |_args, _raw_data| # This won't be called for external webhooks end @@ -428,7 +428,7 @@ agent.define_tool( 'description' => 'Temperature units to use', 'enum' => %w[celsius fahrenheit] } - } + }, handler: nil ) do |args, _raw_data| city = args['city'] || 'unknown' units = args['units'] || 'celsius' @@ -459,7 +459,7 @@ agent.define_tool( description: 'Check the current call.', parameters: { 'query' => { 'type' => 'string', 'description' => 'What to check' } - } + }, handler: nil ) do |args, raw_data| call_id = raw_data&.dig('call_id') || 'unknown' SignalWire::Swaig::FunctionResult.new("Call #{call_id}: query=#{args['query']}") @@ -550,7 +550,7 @@ agent.define_tool( name: 'get_account_details', description: 'Get customer account details', parameters: { 'account_id' => { 'type' => 'string' } }, - secure: true # Require a per-call token for this function + secure: true, handler: nil # Require a per-call token for this function ) do |args, raw_data| # Implementation end @@ -588,7 +588,7 @@ agent.define_tool( name: 'get_public_information', description: "Get public information that doesn't require security", parameters: {}, - secure: false # No token required for this function + secure: false, handler: nil # No token required for this function ) do |args, raw_data| # Implementation end @@ -1006,7 +1006,7 @@ Skills work with dynamic configuration: ```ruby agent = SignalWire::AgentBase.new(name: 'dynamic-skill-agent') -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Add different skills based on request parameters tier = query_params['tier'] || 'basic' @@ -1222,7 +1222,7 @@ agent.global_data = { 'service_level' => 'standard' } agent = SignalWire::AgentBase.new(name: 'dynamic-agent') # No static configuration - set up dynamic callback instead -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Configuration happens fresh for each request tier = query_params['tier'] || 'standard' @@ -1257,7 +1257,7 @@ agent = SignalWire::AgentBase.new(name: 'my-agent', route: '/agent') # body (Hash): Parsed JSON body from POST requests # headers (Hash): HTTP headers from the request # ephemeral (AgentBase): The per-request agent copy to configure -agent.set_dynamic_config_callback do |query_params, body, headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, body, headers, ephemeral| # Your dynamic configuration logic here end ``` @@ -1344,7 +1344,7 @@ Your callback function receives detailed information about the incoming request: #### Query Parameters ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Extract query parameters tier = query_params['tier'] || 'standard' language = query_params['language'] || 'en' @@ -1362,7 +1362,7 @@ end #### POST Body Parameters ```ruby -agent.set_dynamic_config_callback do |_query_params, body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |_query_params, body, _headers, ephemeral| # Extract from POST body user_profile = body['user_profile'] || {} preferences = body['preferences'] || {} @@ -1382,7 +1382,7 @@ end #### HTTP Headers ```ruby -agent.set_dynamic_config_callback do |_query_params, _body, headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |_query_params, _body, headers, ephemeral| # Extract headers user_agent = headers['user-agent'] || '' auth_token = headers['authorization'] || '' @@ -1399,7 +1399,7 @@ end #### Simple Multi-Tenant Configuration ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| tenant = query_params['tenant'] || 'default' # Tenant-specific configuration @@ -1426,7 +1426,7 @@ end #### Language and Localization ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| language = query_params['language'] || 'en' region = query_params['region'] || 'us' @@ -1464,7 +1464,7 @@ end #### A/B Testing Configuration ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Determine test group (could be from query param, user ID hash, etc.) test_group = query_params['test_group'] || 'A' @@ -1485,7 +1485,7 @@ end #### Customer Tier-Based Configuration ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| customer_id = query_params['customer_id'] tier = query_params['tier'] || 'standard' @@ -1610,7 +1610,7 @@ After (Dynamic): agent = SignalWire::AgentBase.new(name: 'my-agent') # Set up dynamic configuration -agent.set_dynamic_config_callback do |_query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |_query_params, _body, _headers, ephemeral| # Same configuration, but now dynamic ephemeral.add_language('English', 'en-US', 'rime.spore:mistv2') ephemeral.set_params({ 'end_of_speech_timeout' => 500 }) @@ -1622,7 +1622,7 @@ end **Step 2: Add Parameter-Based Logic** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Start with base configuration ephemeral.add_language('English', 'en-US', 'rime.spore:mistv2') ephemeral.prompt_add_section('Role', 'You are a helpful assistant.') @@ -1653,7 +1653,7 @@ end agent = SignalWire::AgentBase.new(name: 'my-agent') if use_dynamic - agent.set_dynamic_config_callback do |_query_params, _body, _headers, ephemeral| + agent.set_dynamic_config_callback(nil) do |_query_params, _body, _headers, ephemeral| configure(ephemeral) # New dynamic configuration end else @@ -1667,7 +1667,7 @@ end 1. **Keep Callbacks Lightweight** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Good: Simple parameter extraction and configuration tier = query_params['tier'] || 'standard' ephemeral.set_params(TIER_CONFIGS[tier]) @@ -1688,7 +1688,7 @@ TIER_CONFIGS = { agent = SignalWire::AgentBase.new(name: 'my-agent') -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| tier = query_params['tier'] || 'basic' ephemeral.set_params(TIER_CONFIGS.fetch(tier, TIER_CONFIGS['basic'])) end @@ -1696,7 +1696,7 @@ end 3. **Use Default Values** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Always provide defaults language = query_params['language'] || 'en' tier = query_params['tier'] || 'standard' @@ -1710,7 +1710,7 @@ end 1. **Validate Input Parameters** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Validate and sanitize inputs tier = query_params['tier'] || 'standard' tier = 'basic' unless %w[basic premium enterprise].include?(tier) # Safe default @@ -1728,7 +1728,7 @@ end 2. **Protect Sensitive Configuration** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Don't expose internal configuration via parameters # Bad: ephemeral.set_global_data({ 'api_key' => query_params['api_key'] }) @@ -1754,7 +1754,7 @@ def customer_config(customer_id) CUSTOMER_CONFIG_CACHE[customer_id] ||= database.customer_settings(customer_id) end -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| customer_id = query_params['customer_id'] if customer_id config = customer_config(customer_id) @@ -1767,7 +1767,7 @@ end 1. **Graceful Degradation** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| begin # Try custom configuration apply_custom_config(query_params, ephemeral) @@ -1783,7 +1783,7 @@ end 2. **Configuration Validation** ```ruby -agent.set_dynamic_config_callback do |query_params, _body, _headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| # Validate required parameters. Use `next` (not `return`) to bail out of # the block early. if query_params['tenant'].nil? || query_params['tenant'].empty? @@ -1833,7 +1833,7 @@ To act on specific events (alerting, metrics, custom logging), register a handle agent = SignalWire::AgentBase.new(name: 'my_agent') agent.enable_debug_events -agent.on_debug_event do |event_type, data| +agent.on_debug_event(nil) do |event_type, data| call_id = data['call_id'] case event_type @@ -1896,7 +1896,7 @@ sessions = {} agent.define_tool( name: 'startup_hook', description: 'Called when the voice session starts', - parameters: {} + parameters: {}, handler: nil ) do |_args, raw_data| call_id = raw_data['call_id'] from_number = raw_data['from_number'] @@ -1918,7 +1918,7 @@ end agent.define_tool( name: 'hangup_hook', description: 'Called when the voice session ends', - parameters: {} + parameters: {}, handler: nil ) do |_args, raw_data| call_id = raw_data['call_id'] state = sessions[call_id] @@ -1944,7 +1944,7 @@ end agent.define_tool( name: 'startup_hook', description: 'Called when the voice session starts', - parameters: {} + parameters: {}, handler: nil ) do |_args, raw_data| caller_id = raw_data['from_number'] @@ -1967,7 +1967,7 @@ end agent.define_tool( name: 'hangup_hook', description: 'Called when the voice session ends', - parameters: {} + parameters: {}, handler: nil ) do |_args, raw_data| call_id = raw_data['call_id'] state = sessions[call_id] || {} @@ -2065,7 +2065,7 @@ class CustomAgent < SignalWire::AgentBase super(name: 'custom-agent') # Enable custom routing in the constructor or anytime after initialization - register_routing_callback('/customer') do |request_data| + register_routing_callback(nil, '/customer') do |request_data| # Extract any relevant data customer_id = request_data['customer_id'] @@ -2078,7 +2078,7 @@ class CustomAgent < SignalWire::AgentBase nil end - register_routing_callback('/product') do |request_data| + register_routing_callback(nil, '/product') do |request_data| nil end end @@ -2250,13 +2250,13 @@ gatherer.prompt_sections.each do |section| end agent.global_data = gatherer.global_data -agent.define_tool(name: 'start_questions', description: 'Start the question sequence', parameters: {}) do |args, raw_data| +agent.define_tool(name: 'start_questions', description: 'Start the question sequence', parameters: {}, handler: nil) do |args, raw_data| gatherer.handle_start(args, raw_data) end agent.define_tool( name: 'submit_answer', description: 'Submit an answer to the current question', - parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's answer" } } + parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's answer" } }, handler: nil ) do |args, raw_data| gatherer.handle_submit(args, raw_data) end @@ -2294,7 +2294,7 @@ agent.global_data = faq_bot.global_data agent.define_tool( name: 'search_faq', description: 'Search the FAQ knowledge base', - parameters: { 'query' => { 'type' => 'string', 'description' => 'Search query' } } + parameters: { 'query' => { 'type' => 'string', 'description' => 'Search query' } }, handler: nil ) do |args, raw_data| faq_bot.handle_search(args, raw_data) end @@ -2338,14 +2338,14 @@ agent.global_data = concierge.global_data agent.define_tool( name: 'get_amenity_info', description: 'Get information about a venue amenity', - parameters: { 'amenity' => { 'type' => 'string', 'description' => 'Name of the amenity' } } + parameters: { 'amenity' => { 'type' => 'string', 'description' => 'Name of the amenity' } }, handler: nil ) do |args, raw_data| concierge.handle_amenity_info(args, raw_data) end agent.define_tool( name: 'get_service_info', description: 'Get information about a venue service', - parameters: { 'service' => { 'type' => 'string', 'description' => 'Name of the service' } } + parameters: { 'service' => { 'type' => 'string', 'description' => 'Name of the service' } }, handler: nil ) do |args, raw_data| concierge.handle_service_info(args, raw_data) end @@ -2387,13 +2387,13 @@ survey.prompt_sections.each do |section| end agent.global_data = survey.global_data -agent.define_tool(name: 'start_survey', description: 'Start the survey', parameters: {}) do |args, raw_data| +agent.define_tool(name: 'start_survey', description: 'Start the survey', parameters: {}, handler: nil) do |args, raw_data| survey.handle_start(args, raw_data) end agent.define_tool( name: 'submit_survey_answer', description: 'Submit an answer to the current survey question', - parameters: { 'answer' => { 'type' => 'string', 'description' => "The respondent's answer" } } + parameters: { 'answer' => { 'type' => 'string', 'description' => "The respondent's answer" } }, handler: nil ) do |args, raw_data| survey.handle_submit(args, raw_data) end @@ -2433,7 +2433,7 @@ agent.global_data = receptionist.global_data agent.define_tool( name: 'transfer_to_department', description: 'Transfer the caller to a specific department', - parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } } + parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } }, handler: nil ) do |args, raw_data| receptionist.handle_transfer(args, raw_data) end @@ -2488,7 +2488,7 @@ def build_customer_support_agent(product_name:, knowledge_base_path: nil, parameters: { 'issue_summary' => { 'type' => 'string', 'description' => 'Brief summary of the issue' }, 'customer_email' => { 'type' => 'string', 'description' => "Customer's email address" } - } + }, handler: nil ) do |_args, _raw_data| # Implementation... SignalWire::Swaig::FunctionResult.new('Issue escalated successfully.') @@ -2501,7 +2501,7 @@ def build_customer_support_agent(product_name:, knowledge_base_path: nil, 'customer_email' => { 'type' => 'string' }, 'issue_summary' => { 'type' => 'string' }, 'resolution_steps' => { 'type' => 'string' } - } + }, handler: nil ) do |_args, _raw_data| # Implementation... SignalWire::Swaig::FunctionResult.new('Follow-up email sent successfully.') @@ -2558,7 +2558,7 @@ def build_enhanced_gatherer(questions:, **agent_opts) agent.define_tool( name: 'check_customer', description: 'Check customer status in database', - parameters: { 'email' => { 'type' => 'string' } } + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) do |_args, _raw_data| # Implementation... SignalWire::Swaig::FunctionResult.new('Customer status: Active') @@ -2638,7 +2638,7 @@ my-prefab-agents/ ### SWAIG Methods -- `define_tool(name:, description:, parameters: {}, secure: false, fillers: nil, webhook_url: nil, ...) { |args, raw_data| ... }` (block-based; there is no decorator form) +- `define_tool(name:, description:, parameters:, handler:, secure: true, fillers: nil, webhook_url: nil, ...) { |args, raw_data| ... }` — `parameters:` and `handler:` are REQUIRED; the block-based form passes `handler: nil` and supplies the block - `register_swaig_function(func_def)` - `set_native_functions(names)` / `agent.native_functions = names` - `add_function_include(url, functions, meta_data: nil)` @@ -2683,9 +2683,9 @@ a captured Hash or external store (see [Session Lifecycle Hooks](#session-lifecy - `serve(host: nil, port: nil)`: Start the web server (Rack/WEBrick) - `rack_app` (aliased `as_rack_app`): Return a Rack-compatible application for this agent (Ruby uses Rack, not FastAPI) - `on_swml_request(request_data = nil, callback_path = nil, request: nil)`: Customize SWML based on request data and path (override in a subclass) -- `on_summary(...) { |summary, raw_data| ... }`: Handle post-prompt summaries (block form) +- `on_summary(nil) { |summary, raw_data| ... }`: Handle post-prompt summaries. `summary` is a REQUIRED positional — pass `nil` when REGISTERING a block handler; pass the summary to DISPATCH. You may also override `on_summary` in a subclass. - `on_function_call(name, args, raw_data)`: Process SWAIG function calls -- `register_routing_callback(path) { |request_data| ... }`: Register a block for custom path routing +- `register_routing_callback(callback_fn, path = '/sip') { |request_data| ... }`: Register a callback for custom path routing. `callback_fn` is the REQUIRED first positional — the block form passes `nil` for it, e.g. `register_routing_callback(nil, '/customer') { |request_data| ... }` - `set_web_hook_url(url)` / `agent.web_hook_url = url`: Override the default web_hook_url - `set_post_prompt_url(url)` / `agent.post_prompt_url = url`: Override the default post_prompt_url @@ -2774,7 +2774,7 @@ agent.prompt_add_section('Instructions', nil, bullets: [ agent.define_tool( name: 'get_time', description: 'Get the current time', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| formatted_time = Time.now.strftime('%H:%M:%S') SignalWire::Swaig::FunctionResult.new("The current time is #{formatted_time}") @@ -2840,7 +2840,7 @@ agent.define_tool( description: "Check the status of a customer's account", parameters: { 'account_id' => { 'type' => 'string', 'description' => "The customer's account ID" } - } + }, handler: nil ) do |args, _raw_data| account_id = args['account_id'] # In a real implementation, this would query a database @@ -2857,7 +2857,7 @@ agent.define_tool( 'description' => 'Ticket priority', 'enum' => %w[low medium high critical] } - } + }, handler: nil ) do |args, _raw_data| issue = args['issue'] || '' priority = args['priority'] || 'medium' diff --git a/docs/api_reference.md b/docs/api_reference.md index cd49d4fa..f0d0f6be 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -547,10 +547,12 @@ agent.update_global_data({ def define_tool( name:, # String description:, # String - parameters: {}, # Hash — property_name => JSON-schema hash - handler: nil, # Callable (block is canonical; see below) - secure: false, # Boolean + parameters:, # Hash — property_name => JSON-schema hash (REQUIRED) + handler:, # Callable (REQUIRED; pass nil and give a block) + secure: true, # Boolean fillers: nil, # Hash — language code => Array + wait_file: nil, # String — audio URL played while the tool runs + wait_file_loops: nil, # Integer — loop count for wait_file webhook_url: nil, # String required: nil, # Array — required parameter names is_typed_handler: false, # Boolean @@ -563,9 +565,9 @@ Define a custom SWAIG function/tool. **Parameters:** - `name` (str): Function name - `description` (str): Function description for AI -- `parameters` (Dict[str, Any]): JSON schema for function parameters. If omitted when using the decorator and the handler has type-hinted parameters, the schema is inferred automatically from the type hints. -- `handler` (Callable): Function to execute when called -- `secure` (bool): Require security token (default: True) +- `parameters` (Hash): REQUIRED. JSON schema for function parameters; state `{}` explicitly for a tool that takes none. +- `handler` (Callable): REQUIRED. The callable to execute when called. Ruby cannot let a block satisfy a required positional, so the canonical block form passes `handler: nil` and supplies the block (which wins). +- `secure` (Boolean): Require security token (default: `true`) - `fillers` (Optional[Dict[str, List[str]]]): Language-specific filler phrases - `webhook_url` (Optional[str]): Custom webhook URL - `**swaig_fields`: Additional SWAIG function properties @@ -582,7 +584,7 @@ agent.define_tool( } }, required: ["location"], - fillers: { "en-US" => ["Checking weather...", "Looking up forecast..."] } + fillers: { "en-US" => ["Checking weather...", "Looking up forecast..."] }, handler: nil ) do |args, raw_data| location = args["location"] || "Unknown" SignalWire::Swaig::FunctionResult.new("The weather in #{location} is sunny and 75°F") @@ -608,7 +610,7 @@ class MyAgent < SignalWire::AgentBase define_tool( name: "get_time", description: "Get current time", - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| SignalWire::Swaig::FunctionResult.new("Current time: #{Time.now}") end @@ -629,7 +631,7 @@ class MyAgent < SignalWire::AgentBase "city" => { "type" => "string", "description" => "Name of the city" }, "units" => { "type" => "string", "description" => "Temperature units" } }, - required: ["city"] + required: ["city"], handler: nil ) do |args, raw_data| SignalWire::Swaig::FunctionResult.new("Weather in #{args['city']}") end @@ -669,7 +671,7 @@ Called when a new conversation/call begins. agent.define_tool( name: "startup_hook", description: "Called when a new conversation starts to initialize state", - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| call_id = raw_data["call_id"] # Initialize session resources, load user data, etc. @@ -685,7 +687,7 @@ Called when a conversation/call ends. agent.define_tool( name: "hangup_hook", description: "Called when conversation ends to clean up resources", - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| call_id = raw_data["call_id"] # Clean up resources, save session data, etc. @@ -971,7 +973,7 @@ This is useful for preserving dynamic configuration state across SWAIG callbacks **Usage:** ```ruby # In dynamic config callback, preserve configuration parameters -agent.set_dynamic_config_callback do |query_params, body, headers, config| +agent.set_dynamic_config_callback(nil) do |query_params, body, headers, config| customer_id = query_params["customer_id"] if customer_id # Pass through to SWAIG callbacks @@ -1152,7 +1154,7 @@ Set callback for per-request dynamic configuration. **Usage:** ```ruby -agent.set_dynamic_config_callback do |query_params, body, headers, config| +agent.set_dynamic_config_callback(nil) do |query_params, body, headers, config| # Configure based on request config.add_language("Spanish", "es-ES", "nova.luna") if query_params["language"] == "spanish" @@ -1200,9 +1202,10 @@ agent.register_sip_username("sales") ```ruby -# The routing logic is supplied as a block returning the agent route -# (or nil) based on the request; path is the routing endpoint. -def register_routing_callback(path, &block) # => nil +# `callback_fn` is a REQUIRED positional (reference parity): pass a callable, or +# pass `nil` and supply the block. The routing logic returns the agent route +# (or nil) for the request; `path` is the routing endpoint. +def register_routing_callback(callback_fn, path = '/sip', &block) # => nil ``` Register custom routing logic for SIP calls. @@ -1212,7 +1215,7 @@ Register custom routing logic for SIP calls. **Usage:** ```ruby -agent.register_routing_callback("/sip") do |body, headers| +agent.register_routing_callback(nil, "/sip") do |body, headers| case body["sip_username"] when "support" then "/support-agent" when "sales" then "/sales-agent" @@ -1254,8 +1257,10 @@ end.to_app ```ruby -# Register a handler with a block, or override this method in a subclass. -def on_summary(summary = nil, raw_data = nil, &block) # => self / nil +# `summary` is a REQUIRED positional (reference parity). To REGISTER a handler, +# call `on_summary(nil) { |summary, raw_data| … }`; to DISPATCH one, pass the +# summary. You may also override this method in a subclass. +def on_summary(summary, raw_data = nil, &block) # => self / nil ``` Override to handle conversation summaries. This callback is triggered when the AI generates a summary based on your `post_prompt` configuration. @@ -1307,11 +1312,12 @@ end ```ruby -# Register a handler by passing a block; the block receives -# |event_type, data|. Requires enable_debug_events first. -def on_debug_event(&block) # => AgentBase +# `handler` is a REQUIRED positional (reference parity). Pass a callable, or +# pass `nil` and supply the block; the block receives |event_type, data|. +# Requires enable_debug_events first. +def on_debug_event(handler, &block) # => AgentBase ``` -Register a handler for debug webhook events. Use as a decorator. Requires `enable_debug_events()` to be called first. +Register a handler for debug webhook events. Ruby has no decorator; pass the handler as a block (with `nil` in the required positional slot). Requires `enable_debug_events()` to be called first. The handler receives: - `event_type` (str): The event label (e.g. `"barge"`, `"llm_error"`, `"session_start"`) @@ -1319,12 +1325,12 @@ The handler receives: The handler may be sync or async. -**Usage (decorator style):** +**Usage (block style):** ```ruby agent = SignalWire::AgentBase.new(name: "my_agent") agent.enable_debug_events -agent.on_debug_event do |event_type, data| +agent.on_debug_event(nil) do |event_type, data| call_id = data["call_id"] case event_type when "llm_error" @@ -1343,7 +1349,7 @@ class MyAgent < SignalWire::AgentBase def initialize super(name: "debug-agent", route: "/agent") enable_debug_events(2) - on_debug_event { |event_type, data| handle_debug(event_type, data) } + on_debug_event(nil) { |event_type, data| handle_debug(event_type, data) } end def handle_debug(event_type, data) @@ -3385,7 +3391,7 @@ class ComprehensiveAgent < SignalWire::AgentBase define_tool( name: "transfer_to_billing", description: "Transfer call to billing department", - parameters: { "type" => "object", "properties" => {} } + parameters: { "type" => "object", "properties" => {} }, handler: nil ) do |args, raw_data| SignalWire::Swaig::FunctionResult.new("Transferring you to our billing department") .update_global_data({ "last_action" => "transfer_to_billing" }) diff --git a/docs/architecture.md b/docs/architecture.md index 21139ca1..cab02547 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -362,7 +362,7 @@ The SDK is designed to be highly extensible: name: 'tool_name', description: 'Tool description', parameters: {}, - secure: true + secure: true, handler: nil ) do |args, raw_data| # Tool implementation SignalWire::Swaig::FunctionResult.new('Done') @@ -440,7 +440,7 @@ The SDK is designed to be highly extensible: def register_tools # Register tools with the agent using the wrapper method # This automatically includes swaig_fields - define_tool(name: 'my_tool', description: '...', parameters: {}) do |args, raw_data| + define_tool(name: 'my_tool', description: '...', parameters: {}, handler: nil) do |args, raw_data| SignalWire::Swaig::FunctionResult.new('...') end end @@ -729,7 +729,7 @@ Key steps for creating custom prefabs: define_tool( name: 'specialized_function', description: 'Do something specialized', - parameters: {} + parameters: {}, handler: nil ) do |args, raw_data| # Implementation SignalWire::Swaig::FunctionResult.new('Function result') @@ -1025,7 +1025,7 @@ define_tool( 'type' => 'string', 'description' => 'The city or location to get weather for' } - } + }, handler: nil ) do |args, raw_data| location = args.fetch('location', 'Unknown location') SignalWire::Swaig::FunctionResult.new("It's sunny and 72°F in #{location}.") diff --git a/docs/contexts_guide.md b/docs/contexts_guide.md index 1596a0b2..6edf7ce7 100644 --- a/docs/contexts_guide.md +++ b/docs/contexts_guide.md @@ -1349,7 +1349,7 @@ support.add_step('diagnose').set_text('Help diagnose and resolve technical issue agent.define_tool( name: 'transfer_to_support', description: 'Transfer the customer to technical support', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| # Use swml_change_context to switch contexts SignalWire::Swaig::FunctionResult.new('Transferring you to technical support...') @@ -1359,7 +1359,7 @@ end agent.define_tool( name: 'transfer_to_sales', description: 'Transfer the customer to sales', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new('Transferring you to sales...') .swml_change_context('sales') diff --git a/docs/datamap_guide.md b/docs/datamap_guide.md index a89a81d7..f5a7ba12 100644 --- a/docs/datamap_guide.md +++ b/docs/datamap_guide.md @@ -145,7 +145,7 @@ Function Call → Template Expansion → HTTP Request → Response Processing define_tool( name: 'search_knowledge', description: 'Search the knowledge base', - parameters: { 'query' => { 'type' => 'string' } } + parameters: { 'query' => { 'type' => 'string' } }, handler: nil ) do |args, raw_data| # Custom HTTP request logic uri = URI('https://api.example.com/search') diff --git a/docs/mcp_integration.md b/docs/mcp_integration.md index 3515697b..39d36834 100644 --- a/docs/mcp_integration.md +++ b/docs/mcp_integration.md @@ -80,7 +80,7 @@ class MyAgent < SignalWire::AgentBase description: 'Get weather for a location', parameters: { 'location' => { 'type' => 'string', 'description' => 'City name' } - } + }, handler: nil ) do |args, _raw_data| location = args['location'] || 'unknown' SignalWire::Swaig::FunctionResult.new("72F sunny in #{location}") @@ -134,7 +134,7 @@ class MyAgent < SignalWire::AgentBase define_tool( name: 'transfer_call', description: 'Transfer the caller', - parameters: {} + parameters: {}, handler: nil ) do |_args, _raw_data| # This tool is available both as MCP AND as SWAIG webhook SignalWire::Swaig::FunctionResult.new('Transferring now.') diff --git a/docs/sdk_features.md b/docs/sdk_features.md index bc20176f..c275a6da 100644 --- a/docs/sdk_features.md +++ b/docs/sdk_features.md @@ -47,7 +47,7 @@ agent.define_tool( description: 'Get weather', parameters: { 'city' => { 'type' => 'string', 'description' => 'The city to look up' } - } + }, handler: nil ) do |args, _raw_data| city = args['city'] # ... fetch weather ... @@ -88,7 +88,7 @@ agent.define_tool( description: 'Look up an order', parameters: { 'order_id' => { 'type' => 'string', 'description' => 'The order ID to look up' } - } + }, handler: nil ) do |args, _raw_data| order = db.get(args['order_id']) result = SignalWire::Swaig::FunctionResult.new("Order #{order.id}: #{order.status}") @@ -219,7 +219,7 @@ The `you_lost` step has zero functions and zero valid transitions. The game is o The tool handler demonstrates execution authority -- the model has no idea a step change is about to happen: ```ruby -agent.define_tool(name: 'hit', description: 'Draw another card') do |_args, raw_data| +agent.define_tool(name: 'hit', description: 'Draw another card', handler: nil) do |_args, raw_data| game = raw_data['global_data']['game_state'] card = game['deck'].pop game['player_hand'] << card @@ -311,7 +311,7 @@ One process, multiple agents, route-based dispatch. Each agent gets its own SWML ## Dynamic Configuration and Multi-Tenancy ```ruby -agent.set_dynamic_config_callback do |_query_params, _body, headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |_query_params, _body, headers, ephemeral| tenant = headers['X-Tenant-ID'] || 'default' config = load_tenant_config(tenant) ephemeral.prompt_add_section('Company', config['company_info']) diff --git a/docs/skills_system.md b/docs/skills_system.md index 754362d7..00323ecf 100644 --- a/docs/skills_system.md +++ b/docs/skills_system.md @@ -348,7 +348,7 @@ class MyCustomSkill < SignalWire::Skills::SkillBase 'type' => 'string', 'description' => 'Input parameter' } - } + }, handler: nil ) do |args, raw_data| handle_my_function(args, raw_data) end @@ -449,7 +449,7 @@ class WebSearchAgent < SignalWire::AgentBase def initialize super(name: "WebSearchAgent") # ... application-specific search setup ... - define_tool(name: "web_search", description: "...", parameters: {}) do |args, _raw| + define_tool(name: "web_search", description: "...", parameters: {}, handler: nil) do |args, _raw| # Lots of manual code... end end diff --git a/docs/swaig_reference.md b/docs/swaig_reference.md index 7af98658..eadbe840 100644 --- a/docs/swaig_reference.md +++ b/docs/swaig_reference.md @@ -643,7 +643,7 @@ result = SignalWire::Swaig::FunctionResult.new('Profile saved.') result.replace_in_history("I've saved your profile information.") # Practical example: data collection function that shouldn't clutter history -agent.define_tool(name: 'save_answer', description: "Save the user's answer") do |args, raw_data| +agent.define_tool(name: 'save_answer', description: "Save the user's answer", handler: nil) do |args, raw_data| answer = args['answer'] result = SignalWire::Swaig::FunctionResult.new("Answer recorded: #{answer}") result.replace_in_history # Keep history clean diff --git a/docs/swml_service_guide.md b/docs/swml_service_guide.md index 4a019c9b..23619c4d 100644 --- a/docs/swml_service_guide.md +++ b/docs/swml_service_guide.md @@ -258,7 +258,7 @@ You can use the `register_routing_callback` method to register a function that w # Example: Route based on a field in the request body. If the block returns a # string, the request is redirected to that URL with HTTP 307. Returning nil # causes the request to be processed normally by `on_request`. -service.register_routing_callback("/customer") do |request_data| +service.register_routing_callback(nil, "/customer") do |request_data| if request_data["customer_id"] next "/customer/#{request_data['customer_id']}" end @@ -326,7 +326,7 @@ class MultiSectionService < SignalWire::SWML::Service { "url" => "say:Welcome to customer service!" }) document.add_verb_to_section("customer_section", "hangup", {}) - register_routing_callback("/customer") do |body| + register_routing_callback(nil, "/customer") do |body| puts "Processing request for customer ID: #{body['customer_id']}" if body["customer_id"] nil end @@ -338,7 +338,7 @@ class MultiSectionService < SignalWire::SWML::Service { "url" => "say:Welcome to product support!" }) document.add_verb_to_section("product_section", "hangup", {}) - register_routing_callback("/product") do |body| + register_routing_callback(nil, "/product") do |body| puts "Processing request for product ID: #{body['product_id']}" if body["product_id"] nil end diff --git a/docs/third_party_skills.md b/docs/third_party_skills.md index 29422854..cec7b274 100644 --- a/docs/third_party_skills.md +++ b/docs/third_party_skills.md @@ -84,7 +84,7 @@ class WeatherSkill < SignalWire::Skills::SkillBase 'type' => 'string', 'description' => 'City name or coordinates' } - } + }, handler: nil ) do |args, raw_data| handle_get_weather(args, raw_data) end @@ -405,7 +405,7 @@ def register_tools define_tool( name: tool_name, description: "Get weather using #{service}", - parameters: { } # ... + parameters: { }, handler: nil # ... ) do |args, raw_data| handle_get_weather(args, raw_data) end diff --git a/relay/README.md b/relay/README.md index f397e76e..71b4b997 100644 --- a/relay/README.md +++ b/relay/README.md @@ -15,7 +15,7 @@ client = SignalWire::Relay::Client.new( contexts: ['default'] ) -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play([{ 'type' => 'tts', 'params' => { 'text' => 'Welcome to SignalWire!' } }]) action.wait @@ -39,7 +39,7 @@ client.run ### Answer and Play TTS ```ruby -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play([{ 'type' => 'tts', 'params' => { 'text' => 'Hello!' } }]) action.wait @@ -62,7 +62,7 @@ call.hangup ### Collect DTMF ```ruby -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play_and_collect( [{ 'type' => 'tts', 'params' => { 'text' => 'Press 1 for sales, 2 for support.' } }], diff --git a/relay/docs/client-reference.md b/relay/docs/client-reference.md index 43163431..10f84627 100644 --- a/relay/docs/client-reference.md +++ b/relay/docs/client-reference.md @@ -59,10 +59,10 @@ end ### `on_call(handler)` -Register the inbound call handler by passing a block. The block receives a `Call` object. +Register the inbound call handler. `handler` is a REQUIRED positional — pass a callable, or pass `nil` and supply a block. The block receives a `Call` object. ```ruby -client.on_call do |call| +client.on_call(nil) do |call| call.answer end ``` @@ -83,10 +83,10 @@ call = client.dial([ ### `on_message(handler)` -Register the inbound message handler by passing a block. The block receives a `Message` object. +Register the inbound message handler. `handler` is a REQUIRED positional — pass a callable, or pass `nil` and supply a block. The block receives a `Message` object. ```ruby -client.on_message do |message| +client.on_message(nil) do |message| puts "SMS from #{message.from_number}: #{message.body}" end ``` diff --git a/relay/docs/events.md b/relay/docs/events.md index d3c5da96..aec5af12 100644 --- a/relay/docs/events.md +++ b/relay/docs/events.md @@ -7,7 +7,7 @@ RELAY events are server-pushed notifications about call state changes and operat ### On a Call ```ruby -client.on_call do |call| +client.on_call(nil) do |call| # Register a listener call.on('calling.call.play') { |event| puts "Play: #{event.params}" } diff --git a/relay/docs/getting-started.md b/relay/docs/getting-started.md index 0605c660..2ae49105 100644 --- a/relay/docs/getting-started.md +++ b/relay/docs/getting-started.md @@ -49,7 +49,7 @@ client = SignalWire::Relay::Client.new( contexts: ['default'] ) -client.on_call do |call| +client.on_call(nil) do |call| call.answer action = call.play_tts('Hello!') action.wait @@ -73,7 +73,7 @@ require 'signalwire' client = SignalWire::Relay::Client.new(contexts: ['default']) -client.on_call do |call| +client.on_call(nil) do |call| call.answer call.hangup end diff --git a/relay/docs/messaging.md b/relay/docs/messaging.md index 275dec45..c5e0630f 100644 --- a/relay/docs/messaging.md +++ b/relay/docs/messaging.md @@ -90,7 +90,7 @@ client = SignalWire::Relay::Client.new( contexts: ['default'] ) -client.on_message do |message| +client.on_message(nil) do |message| puts "From: #{message.from_number}" puts "To: #{message.to_number}" puts "Body: #{message.body}" @@ -169,13 +169,13 @@ The same `RelayClient` handles both calls and messages: ```ruby client = SignalWire::Relay::Client.new(project: '...', token: '...', contexts: ['default']) -client.on_call do |call| +client.on_call(nil) do |call| call.answer call.play([{ 'type' => 'tts', 'params' => { 'text' => 'Hello!' } }]) call.hangup end -client.on_message do |message| +client.on_message(nil) do |message| puts "SMS from #{message.from_number}: #{message.body}" end diff --git a/relay/examples/relay_answer_and_welcome.rb b/relay/examples/relay_answer_and_welcome.rb index dd62282a..77461bb2 100644 --- a/relay/examples/relay_answer_and_welcome.rb +++ b/relay/examples/relay_answer_and_welcome.rb @@ -12,7 +12,7 @@ client = SignalWire::Relay::Client.new(contexts: ['default']) -client.on_call do |call| +client.on_call(nil) do |call| puts "Incoming call: #{call.call_id}" call.answer diff --git a/relay/examples/relay_ivr_connect.rb b/relay/examples/relay_ivr_connect.rb index 7faea8cd..9d9293bd 100644 --- a/relay/examples/relay_ivr_connect.rb +++ b/relay/examples/relay_ivr_connect.rb @@ -24,7 +24,7 @@ def tts(text) { 'type' => 'tts', 'params' => { 'text' => text } } end -client.on_call do |call| +client.on_call(nil) do |call| puts "Incoming call: #{call.call_id}" call.answer From 45d7cc1e019269923c2d98cd9bad6fda5f9fa1f6 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 11:17:51 -0400 Subject: [PATCH 24/90] =?UTF-8?q?fix(ledger):=20delete=202=20false=20signa?= =?UTF-8?q?ture=20omissions=20=E2=80=94=20neither=20divergence=20exists?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Part of the fleet-wide false-ledger sweep. Both entries excused a divergence the source does not have, and both deletions are drift-neutral (proof the symbols matched all along and the entries were pure blind spots). RelayClient.dial claimed: "Python collects late args via **var_keyword" actual: dial(self, devices, *, tag=None, max_duration=None, dial_timeout=None) — there is no **kwargs; the oracle records all three as `keyword`. Ruby's dial(devices, tag:, max_duration:, dial_timeout:) matched from the start. logging_config.strip_control_chars claimed: Python has the 3-arg structlog processor signature (logger, method_name, event_dict) actual: Python takes ONE parameter. Its docstring states the design explicitly — the public function is kept to one parameter and the structlog plumbing confined to the two registration sites. The reference was deliberately built to NOT have the shape this entry attributes to it. An omission excuses the WHOLE symbol from comparison, so each of these was a permanent blind spot: a future real change to either would have gone unseen. Deleted outright, not commented out — a tombstone keeps the symbol name and the false claim greppable, so an audit of "which symbols are excused" gets a false positive. Git history is the record. Verification: sw-verify ruby --gates SURFACE,LEDGER -> exit 0 SURFACE PASS · LEDGER PASS NO-LAUNDER PASS (impossible: 15 · approved: 4 · idiom: 1 · unclassified: 0 · banned: 0) Drift-neutrality established against a stashed baseline, not just an after-state run. NOTE: the identical false strip_control_chars claim was also found and deleted in perl. False in 2 of 2 ports that carried it — worth grepping for in the remaining ports. NOT TOUCHED, for a human: - lib/signalwire/core/logging_config.rb:69 repeats the same false premise in a code comment (not gate-load-bearing). - PORT_OMISSIONS.md:134 SkillRegistry.get_skill_class is a RENAME recorded as an omission, which that file's own header forbids. Fixing it is an emitter change, not a deletion — belongs to the idiom-fold campaign. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- PORT_SIGNATURE_OMISSIONS.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 79522071..820c9258 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -133,10 +133,6 @@ signalwire.relay.call.Call.send_fax: kwargs-collapse — Ruby keeps required arg signalwire.relay.call.Call.stream: kwargs-collapse — Ruby keeps required args explicit, optionals collapse into **kwargs signalwire.relay.call.Call.transcribe: kwargs-collapse — Ruby keeps required args explicit, optionals collapse into **kwargs -# Single-case: kind 'keyword' vs 'var_keyword' (RelayClient.dial) - -signalwire.relay.client.RelayClient.dial: kwargs-spread — Ruby `dial_timeout:` keyword arg projects as keyword while Python collects late args via var_keyword - # Prompt Object Model — Ruby keyword-arg idiom signalwire.pom.pom.PromptObjectModel.to_json: Ruby JSON convention — `to_json(*_args)` accepts the optional state argument that Ruby's JSON.generate forwards @@ -162,7 +158,6 @@ signalwire.prefabs.info_gatherer.InfoGathererAgent.on_swml_request: kwargs-idiom # --- Ruby keyword-arg / **kwargs / block / classmethod idiom (kind & count) --- signalwire.relay.call.PlayAction.volume: untyped-idiom — Ruby is dynamically typed; the `volume` param carries no static type (untyped `any`) where Python types it `float`. Same value on the wire (`play.volume` with `volume` key); the type divergence is Ruby's runtime-typed idiom, not a wire difference. signalwire.relay.call.CollectAction.volume: untyped-idiom — Ruby is dynamically typed; the `volume` param carries no static type (untyped `any`) where Python types it `float`. Same value on the wire (`play_and_collect.volume` with `volume` key); the type divergence is Ruby's runtime-typed idiom, not a wire difference. -signalwire.core.logging_config.strip_control_chars: Ruby structlog processor closure takes only `event_dict`; Python's (logger, method_name, event_dict) processor signature — same processor contract signalwire.core.pom_builder.PomBuilder.from_sections: classmethod idiom — Ruby `def self.` factory has no explicit `cls` receiver signalwire.core.skill_base.SkillBase.define_tool: Ruby explicit keyword args (`name:`, `description:`, `parameters:`, &handler) ≡ Python `**kwargs` — same define_tool contract as named Ruby kwargs signalwire.core.skill_manager.SkillManager.load_skill: Ruby SkillManager idiom — `load(key, skill)` takes a pre-built skill + instance key; Python `load_skill(skill_name, skill_class, params)` constructs it — same load contract, different split From 8b1a6679e17ce05ad261bf233e8b0b2b3b8a412f Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 13:06:38 -0400 Subject: [PATCH 25/90] =?UTF-8?q?docs(claude):=20fix=20the=20define=5Ftool?= =?UTF-8?q?=20example=20=E2=80=94=20it=20raised=20ArgumentError=20as=20wri?= =?UTF-8?q?tten?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CLAUDE.md's Tool Definition example omitted `handler:`, which c36ddd0 made a REQUIRED keyword. Typed verbatim by a user (or an agent reading this file for instructions), it does not work: before: ArgumentError: missing keyword: :handler after: tool registered, exit 0 Both halves executed against the real SDK, not inferred — a scratch script outside the repo requiring lib/signalwire and calling the example as written, then as corrected. source of truth: lib/signalwire/agent/agent_base.rb:720 def define_tool(name:, description:, parameters:, handler:, ...) The two lines above it already document the intended form: "a block-bodied tool states ``handler: nil`` and passes the block." Also corrected the prose at line 89, which said SWAIG functions are defined "via `define_tool` with block handlers". That is now only half true — the block is still accepted, but it is no longer sufficient on its own. It names the required keyword instead. c36ddd0 DID update README.md:57-64 and docs/api_reference.md:577-588 (both carry `handler: nil`). CLAUDE.md was the one file the commit missed, so ruby's doc tree was otherwise consistent. ROOT CAUSE OF THE CLASS, worth more than this one fix: this defect lives exactly where the automated checker is not looking. typescript, java and cpp CLAUDE.md files carry `` preambles and rust carries per-block `` markers — those four are wired into porting-sdk's snippet_extract/compile/run. Ruby and perl carry NO snippet markers at all, and ruby and perl are the only two ports where a fleet-wide sweep of every CLAUDE.md found a broken example (18 executable examples checked, 2 wrong). Extending snippet extraction to ruby's and perl's CLAUDE.md would have caught this mechanically at c36ddd0 time. Filed separately; not done here. The perl finding is worse and is NOT fixed in this commit (different repo): CLAUDE.md:188-191 passes `prompt => ...` to `add_context`, which takes a name only (Contexts.pm:754). It does not die — the pair is silently swallowed and the context renders with no prompt at all. Verification: scripts/run-format.sh -> exit 0, 1376 files inspected, no offenses; changed nothing. git status: CLAUDE.md only. No SDK source touched. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- CLAUDE.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index b1291717..a092f8b7 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -86,7 +86,7 @@ ruby bin/sw-search ./docs --output knowledge.swsearch #### Agent Creation Agents inherit from `SignalWire::AgentBase` and define: - Prompt Object Model (POM) sections via `prompt_add_section` -- SWAIG functions via `define_tool` with block handlers +- SWAIG functions via `define_tool` (`handler:` is a required keyword; pass `handler: nil` to use a block) - Skills integration via `add_skill` method - All configuration methods return `self` for chaining @@ -97,7 +97,8 @@ agent.define_tool( description: 'Get current weather', parameters: { 'city' => { 'type' => 'string', 'description' => 'City name' } - } + }, + handler: nil ) do |args, raw_data| SignalWire::Swaig::FunctionResult.new("Weather in #{args['city']}: 72F") end From dde05165dc7d036cbc86539ee8e72ea2022dbb3e Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 15:18:18 -0400 Subject: [PATCH 26/90] =?UTF-8?q?ci(gates):=20schedule=20TLS-VERIFY=20?= =?UTF-8?q?=E2=80=94=20defined,=20passing,=20never=20run?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit TLS-VERIFY was offered to ruby by porting-sdk and absent from the BEHAVIORAL suite's --rules list, so it had never executed in this port. It is a SECURITY property and should not be optional per port. (ruby already scheduled CA-VAR, SECURE-DEFAULT and SECRET-SCRUB; TLS-VERIFY was the one gap.) BURNED TO ZERO BEFORE WIRING, per the standing rule: run standalone against the current tree first — ruby TLS-VERIFY PASS. This adds coverage without adding a red. TIER: BLOCKING (per-PR), measured not assumed — timed at 0s on this tree. Nothing here justifies the nightly tier, where a regression would sit unseen until the next scheduled run. The gate `desc` string is updated alongside the --rules list; a desc that enumerates rules it does not schedule reads as coverage and is worse than no desc. Verification — the full suite as CI will now run it, not the new rule in isolation: behavioral.py --port ruby --rules -> [BEHAVIORAL] all 20 rules PASS Found by the fleet-wide gate-wiring audit (task #55); part of that item's tier-1. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- scripts/run-ci.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index cdda7e99..10e4c953 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -131,9 +131,9 @@ sched_gate GEN defer=1 desc="generated-code freshness suite (GEN-FRESH/-TESTS/-R # BEHAVIORAL (one Layer-D pass per rule): the per-PR rules. WAIT-LIVENESS (nightly) # is the separate line below. -sched_gate BEHAVIORAL defer=1 desc="behavioral suite (BEHAVIORAL-*/EMISSION/ERROR-ENVELOPE/PAGINATION-WIRED/PAGINATION-CORPUS/DOC-WIRE/REST-COVERAGE/SPEC-PARITY/SKILL-CONTRACT/SWAIG-COVERAGE/SWAIG-CLI/CA-VAR/SECURE-DEFAULT/SECRET-SCRUB)" \ +sched_gate BEHAVIORAL defer=1 desc="behavioral suite (BEHAVIORAL-*/EMISSION/ERROR-ENVELOPE/PAGINATION-WIRED/PAGINATION-CORPUS/DOC-WIRE/REST-COVERAGE/SPEC-PARITY/SKILL-CONTRACT/SWAIG-COVERAGE/SWAIG-CLI/CA-VAR/SECURE-DEFAULT/SECRET-SCRUB/TLS-VERIFY)" \ -- python3 "$PORTING_SDK_DIR/scripts/suites/behavioral.py" --port ruby --repo "$PORT_ROOT" \ - --rules BEHAVIORAL-WIRE,BEHAVIORAL-SWML,BEHAVIORAL-STRICT-RENDER,BEHAVIORAL-STATE,BEHAVIORAL-HTTP,BEHAVIORAL-WIRE-RELAY,EMISSION,ERROR-ENVELOPE,PAGINATION-WIRED,PAGINATION-CORPUS,DOC-WIRE,REST-COVERAGE,SPEC-PARITY,SKILL-CONTRACT,SWAIG-COVERAGE,SWAIG-CLI,CA-VAR,SECURE-DEFAULT,SECRET-SCRUB + --rules BEHAVIORAL-WIRE,BEHAVIORAL-SWML,BEHAVIORAL-STRICT-RENDER,BEHAVIORAL-STATE,BEHAVIORAL-HTTP,BEHAVIORAL-WIRE-RELAY,EMISSION,ERROR-ENVELOPE,PAGINATION-WIRED,PAGINATION-CORPUS,DOC-WIRE,REST-COVERAGE,SPEC-PARITY,SKILL-CONTRACT,SWAIG-COVERAGE,SWAIG-CLI,CA-VAR,SECURE-DEFAULT,SECRET-SCRUB,TLS-VERIFY sched_gate BEHAVIORAL-NIGHTLY tier=nightly defer=1 desc="behavioral suite, nightly rules (WAIT-LIVENESS/RELAY-LIVENESS/SECRET-SCRUB-LIVE)" \ -- python3 "$PORTING_SDK_DIR/scripts/suites/behavioral.py" --port ruby --repo "$PORT_ROOT" \ From aa9f284d44d7a9f654f7fb627718f4c6c7e2cee8 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 16:49:47 -0400 Subject: [PATCH 27/90] chore(doc-surface): re-pin floor 51.8 -> 52.4 after the gate stopped counting private symbols MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit porting-sdk 481b435 corrected DOC-SURFACE's ruby decl regex, which matched a LEADING UNDERSCORE and so counted `_name` methods as public surface. Ruby barely moves — 52.8% (1802/3412) -> 52.4% (1764/3366) — which is the expected shape: privacy in idiomatic ruby is `private`, not a naming sigil, so there were few to exclude. Python is where the same defect was actually distorting the number. The floor is re-pinned rather than left at 51.8 so it describes the measurement the gate now produces. Gate exit 0. Full rationale in 481b435. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- .doc_surface_floor | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.doc_surface_floor b/.doc_surface_floor index 3fc288b5..00394b32 100644 --- a/.doc_surface_floor +++ b/.doc_surface_floor @@ -1 +1 @@ -51.8 +52.4 From 5bce988484cf34856841837ad0d1efc91ff691bf Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:41:18 -0400 Subject: [PATCH 28/90] docs(gen): emit a doc comment on every nested namespace module emit_methodless_class opened `module Core` / `module SwmlVerbsGenerated` (and the relay / swaig / post-prompt equivalents) with no preceding comment, so 602 public declarations across 301 generated files counted as undocumented. The namespace nesting is public surface; give each intermediate segment a one-line doc comment at the emitter and regenerate. DOC-SURFACE ruby: 52.4% -> 70.3% (1764 -> 2366 of 3366). --- lib/signalwire/core/post_prompt_generated/post_prompt.rb | 2 ++ .../post_prompt_generated/post_prompt_assistant_entry.rb | 2 ++ .../core/post_prompt_generated/post_prompt_data.rb | 2 ++ .../core/post_prompt_generated/post_prompt_entity.rb | 2 ++ .../core/post_prompt_generated/post_prompt_eot.rb | 2 ++ .../core/post_prompt_generated/post_prompt_stamps_us.rb | 2 ++ .../post_prompt_generated/post_prompt_swaig_log_entry.rb | 2 ++ .../core/post_prompt_generated/post_prompt_system_entry.rb | 2 ++ .../post_prompt_generated/post_prompt_system_log_entry.rb | 2 ++ .../post_prompt_generated/post_prompt_thinking_entry.rb | 2 ++ .../core/post_prompt_generated/post_prompt_times_entry.rb | 2 ++ .../core/post_prompt_generated/post_prompt_timing.rb | 2 ++ .../core/post_prompt_generated/post_prompt_tool_entry.rb | 2 ++ .../core/post_prompt_generated/post_prompt_user_entry.rb | 2 ++ .../core/swaig_actions_generated/context_switch_action.rb | 2 ++ lib/signalwire/core/swaig_actions_generated/hold_action.rb | 2 ++ .../core/swaig_actions_generated/playback_bg_action.rb | 2 ++ .../core/swaig_actions_generated/transfer_action.rb | 2 ++ .../core/swaig_request_generated/swaig_argument.rb | 2 ++ .../core/swaig_request_generated/swaig_request.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/a_i.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/a_i_object.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/a_i_params.rb | 2 ++ .../core/swml_verbs_generated/a_i_post_prompt_pom.rb | 2 ++ .../core/swml_verbs_generated/a_i_post_prompt_text.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb | 2 ++ .../core/swml_verbs_generated/a_i_prompt_text.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb | 2 ++ .../core/swml_verbs_generated/ai_sidecar_config.rb | 2 ++ .../core/swml_verbs_generated/all_of_property.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb | 2 ++ .../core/swml_verbs_generated/amazon_bedrock_object.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/answer.rb | 2 ++ .../core/swml_verbs_generated/any_of_property.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/array_property.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/bedrock_params.rb | 2 ++ .../core/swml_verbs_generated/bedrock_s_w_a_i_g.rb | 2 ++ .../core/swml_verbs_generated/boolean_property.rb | 2 ++ .../core/swml_verbs_generated/change_context_action.rb | 2 ++ .../core/swml_verbs_generated/change_step_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/cond.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/cond_else.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/cond_reg.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/connect.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/connect_config.rb | 2 ++ .../core/swml_verbs_generated/connect_device_parallel.rb | 2 ++ .../core/swml_verbs_generated/connect_device_serial.rb | 2 ++ .../swml_verbs_generated/connect_device_serial_parallel.rb | 2 ++ .../core/swml_verbs_generated/connect_device_single.rb | 2 ++ .../core/swml_verbs_generated/connect_headers.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/connect_switch.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/const_property.rb | 2 ++ .../core/swml_verbs_generated/context_p_o_m_steps.rb | 2 ++ .../core/swml_verbs_generated/context_switch_action.rb | 2 ++ .../core/swml_verbs_generated/context_text_steps.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/contexts.rb | 2 ++ .../core/swml_verbs_generated/contexts_p_o_m_object.rb | 2 ++ .../core/swml_verbs_generated/contexts_text_object.rb | 2 ++ .../core/swml_verbs_generated/conversation_message.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/data_map.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/denoise.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/detect_machine.rb | 2 ++ .../core/swml_verbs_generated/detect_machine_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/enter_queue.rb | 2 ++ .../core/swml_verbs_generated/enter_queue_object.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/execute.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/execute_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/execute_switch.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/expression.rb | 2 ++ .../core/swml_verbs_generated/function_parameters.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/goto.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/goto_config.rb | 2 ++ .../hang_up_hook_s_w_a_i_g_function.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/hangup.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/hangup_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/hint.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/hold_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/inject_action.rb | 2 ++ .../core/swml_verbs_generated/integer_property.rb | 2 ++ .../core/swml_verbs_generated/join_conference.rb | 2 ++ .../core/swml_verbs_generated/join_conference_object.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/join_room.rb | 2 ++ .../core/swml_verbs_generated/join_room_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/label.rb | 2 ++ .../core/swml_verbs_generated/language_params.rb | 2 ++ .../core/swml_verbs_generated/languages_with_fillers.rb | 2 ++ .../swml_verbs_generated/languages_with_solo_fillers.rb | 2 ++ .../core/swml_verbs_generated/live_transcribe.rb | 2 ++ .../core/swml_verbs_generated/live_transcribe_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/live_translate.rb | 2 ++ .../core/swml_verbs_generated/live_translate_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/null_property.rb | 2 ++ .../core/swml_verbs_generated/number_property.rb | 2 ++ .../core/swml_verbs_generated/object_property.rb | 2 ++ ...perties_bedrock_post_pompt_text_omitted_prompt_props.rb | 2 ++ ...perties_bedrock_post_prompt_pom_omitted_prompt_props.rb | 2 ++ ...t_properties_bedrock_prompt_pom_omitted_prompt_props.rb | 2 ++ ..._properties_bedrock_prompt_text_omitted_prompt_props.rb | 2 ++ .../core/swml_verbs_generated/one_of_property.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/output.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/pay.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/pay_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/pay_parameters.rb | 2 ++ .../core/swml_verbs_generated/pay_prompt_play_action.rb | 2 ++ .../core/swml_verbs_generated/pay_prompt_say_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/pay_prompts.rb | 2 ++ ...k_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb | 2 ++ ...k_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb | 2 ++ ...n_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb | 2 ++ ...r_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/play.rb | 2 ++ .../core/swml_verbs_generated/play_with_u_r_l.rb | 2 ++ .../core/swml_verbs_generated/play_with_u_r_l_s.rb | 2 ++ .../core/swml_verbs_generated/playback_b_g_action.rb | 2 ++ .../core/swml_verbs_generated/pom_section_body_content.rb | 2 ++ .../swml_verbs_generated/pom_section_bullets_content.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/prompt.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/prompt_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/pronounce.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/receive_fax.rb | 2 ++ .../core/swml_verbs_generated/receive_fax_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/record.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/record_call.rb | 2 ++ .../core/swml_verbs_generated/record_call_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/record_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/request.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/request_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/return.rb | 2 ++ .../core/swml_verbs_generated/ringback_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb | 2 ++ .../core/swml_verbs_generated/s_m_s_with_body.rb | 2 ++ .../core/swml_verbs_generated/s_m_s_with_media.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb | 2 ++ .../core/swml_verbs_generated/s_w_a_i_g_defaults.rb | 2 ++ .../core/swml_verbs_generated/s_w_a_i_g_includes.rb | 2 ++ .../core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/say_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/section.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/send_digits.rb | 2 ++ .../core/swml_verbs_generated/send_digits_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/send_fax.rb | 2 ++ .../core/swml_verbs_generated/send_fax_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/set.rb | 2 ++ .../core/swml_verbs_generated/set_global_data_action.rb | 2 ++ .../core/swml_verbs_generated/set_meta_data_action.rb | 2 ++ .../core/swml_verbs_generated/sip_refer_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/sleep.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/start_action.rb | 2 ++ .../start_up_hook_s_w_a_i_g_function.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/stop_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/stop_denoise.rb | 2 ++ .../core/swml_verbs_generated/stop_playback_b_g_action.rb | 2 ++ .../core/swml_verbs_generated/stop_record_call.rb | 2 ++ .../core/swml_verbs_generated/stop_record_call_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/stop_tap.rb | 2 ++ .../core/swml_verbs_generated/stop_tap_config.rb | 2 ++ .../core/swml_verbs_generated/string_property.rb | 2 ++ .../core/swml_verbs_generated/summarize_action.rb | 2 ++ .../summarize_conversation_s_w_a_i_g_function.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/switch.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/switch_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/tap.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/tap_config.rb | 2 ++ .../core/swml_verbs_generated/toggle_functions_action.rb | 2 ++ .../core/swml_verbs_generated/transcribe_start_action.rb | 2 ++ .../swml_verbs_generated/transcribe_summarize_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/transfer.rb | 2 ++ .../core/swml_verbs_generated/transfer_config.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/unset.rb | 2 ++ .../core/swml_verbs_generated/unset_global_data_action.rb | 2 ++ .../core/swml_verbs_generated/unset_meta_data_action.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/user_event.rb | 2 ++ .../core/swml_verbs_generated/user_event_config.rb | 2 ++ .../core/swml_verbs_generated/user_input_action.rb | 2 ++ .../core/swml_verbs_generated/user_s_w_a_i_g_function.rb | 2 ++ lib/signalwire/core/swml_verbs_generated/webhook.rb | 2 ++ .../protocol_types_generated/calling_ai_hold_params.rb | 2 ++ .../protocol_types_generated/calling_ai_hold_result.rb | 2 ++ .../protocol_types_generated/calling_ai_message_params.rb | 2 ++ .../protocol_types_generated/calling_ai_message_result.rb | 2 ++ .../protocol_types_generated/calling_ai_unhold_params.rb | 2 ++ .../protocol_types_generated/calling_ai_unhold_result.rb | 2 ++ .../calling_amazon_bedrock_params.rb | 2 ++ .../calling_amazon_bedrock_result.rb | 2 ++ .../protocol_types_generated/calling_answer_params.rb | 2 ++ .../protocol_types_generated/calling_answer_result.rb | 2 ++ .../relay/protocol_types_generated/calling_begin_params.rb | 2 ++ .../relay/protocol_types_generated/calling_begin_result.rb | 2 ++ .../protocol_types_generated/calling_bind_digit_params.rb | 2 ++ .../protocol_types_generated/calling_bind_digit_result.rb | 2 ++ .../calling_clear_digit_bindings_params.rb | 2 ++ .../calling_clear_digit_bindings_result.rb | 2 ++ .../protocol_types_generated/calling_collect_params.rb | 2 ++ .../protocol_types_generated/calling_collect_result.rb | 2 ++ .../calling_collect_start_input_timers_params.rb | 2 ++ .../calling_collect_start_input_timers_result.rb | 2 ++ .../calling_collect_stop_params.rb | 2 ++ .../calling_collect_stop_result.rb | 2 ++ .../protocol_types_generated/calling_connect_params.rb | 2 ++ .../protocol_types_generated/calling_connect_result.rb | 2 ++ .../protocol_types_generated/calling_denoise_params.rb | 2 ++ .../protocol_types_generated/calling_denoise_result.rb | 2 ++ .../calling_denoise_stop_params.rb | 2 ++ .../calling_denoise_stop_result.rb | 2 ++ .../protocol_types_generated/calling_detect_params.rb | 2 ++ .../protocol_types_generated/calling_detect_result.rb | 2 ++ .../protocol_types_generated/calling_detect_stop_params.rb | 2 ++ .../protocol_types_generated/calling_detect_stop_result.rb | 2 ++ .../relay/protocol_types_generated/calling_dial_params.rb | 2 ++ .../relay/protocol_types_generated/calling_dial_result.rb | 2 ++ .../protocol_types_generated/calling_disconnect_params.rb | 2 ++ .../protocol_types_generated/calling_disconnect_result.rb | 2 ++ .../relay/protocol_types_generated/calling_echo_params.rb | 2 ++ .../relay/protocol_types_generated/calling_echo_result.rb | 2 ++ .../relay/protocol_types_generated/calling_end_params.rb | 2 ++ .../relay/protocol_types_generated/calling_end_result.rb | 2 ++ .../calling_join_conference_params.rb | 2 ++ .../calling_join_conference_result.rb | 2 ++ .../protocol_types_generated/calling_join_room_params.rb | 2 ++ .../protocol_types_generated/calling_join_room_result.rb | 2 ++ .../calling_leave_conference_params.rb | 2 ++ .../calling_leave_conference_result.rb | 2 ++ .../protocol_types_generated/calling_leave_room_params.rb | 2 ++ .../protocol_types_generated/calling_leave_room_result.rb | 2 ++ .../calling_live_transcribe_params.rb | 2 ++ .../calling_live_transcribe_result.rb | 2 ++ .../calling_live_translate_params.rb | 2 ++ .../calling_live_translate_result.rb | 2 ++ .../relay/protocol_types_generated/calling_pass_params.rb | 2 ++ .../relay/protocol_types_generated/calling_pass_result.rb | 2 ++ .../relay/protocol_types_generated/calling_pay_params.rb | 2 ++ .../relay/protocol_types_generated/calling_pay_result.rb | 2 ++ .../protocol_types_generated/calling_pay_stop_params.rb | 2 ++ .../protocol_types_generated/calling_pay_stop_result.rb | 2 ++ .../calling_play_and_collect_params.rb | 2 ++ .../calling_play_and_collect_result.rb | 2 ++ .../calling_play_and_collect_stop_params.rb | 2 ++ .../calling_play_and_collect_stop_result.rb | 2 ++ .../calling_play_and_collect_volume_params.rb | 2 ++ .../calling_play_and_collect_volume_result.rb | 2 ++ .../relay/protocol_types_generated/calling_play_params.rb | 2 ++ .../protocol_types_generated/calling_play_pause_params.rb | 2 ++ .../protocol_types_generated/calling_play_pause_result.rb | 2 ++ .../relay/protocol_types_generated/calling_play_result.rb | 2 ++ .../protocol_types_generated/calling_play_resume_params.rb | 2 ++ .../protocol_types_generated/calling_play_resume_result.rb | 2 ++ .../protocol_types_generated/calling_play_stop_params.rb | 2 ++ .../protocol_types_generated/calling_play_stop_result.rb | 2 ++ .../protocol_types_generated/calling_play_volume_params.rb | 2 ++ .../protocol_types_generated/calling_play_volume_result.rb | 2 ++ .../protocol_types_generated/calling_queue_enter_params.rb | 2 ++ .../protocol_types_generated/calling_queue_enter_result.rb | 2 ++ .../protocol_types_generated/calling_queue_leave_params.rb | 2 ++ .../protocol_types_generated/calling_queue_leave_result.rb | 2 ++ .../protocol_types_generated/calling_receive_fax_params.rb | 2 ++ .../protocol_types_generated/calling_receive_fax_result.rb | 2 ++ .../calling_receive_fax_stop_params.rb | 2 ++ .../calling_receive_fax_stop_result.rb | 2 ++ .../protocol_types_generated/calling_receive_params.rb | 2 ++ .../protocol_types_generated/calling_receive_result.rb | 2 ++ .../protocol_types_generated/calling_record_params.rb | 2 ++ .../calling_record_pause_params.rb | 2 ++ .../calling_record_pause_result.rb | 2 ++ .../protocol_types_generated/calling_record_result.rb | 2 ++ .../calling_record_resume_params.rb | 2 ++ .../calling_record_resume_result.rb | 2 ++ .../protocol_types_generated/calling_record_stop_params.rb | 2 ++ .../protocol_types_generated/calling_record_stop_result.rb | 2 ++ .../relay/protocol_types_generated/calling_refer_params.rb | 2 ++ .../relay/protocol_types_generated/calling_refer_result.rb | 2 ++ .../protocol_types_generated/calling_send_digits_params.rb | 2 ++ .../protocol_types_generated/calling_send_digits_result.rb | 2 ++ .../protocol_types_generated/calling_send_fax_params.rb | 2 ++ .../protocol_types_generated/calling_send_fax_result.rb | 2 ++ .../calling_send_fax_stop_params.rb | 2 ++ .../calling_send_fax_stop_result.rb | 2 ++ .../protocol_types_generated/calling_stream_params.rb | 2 ++ .../protocol_types_generated/calling_stream_result.rb | 2 ++ .../protocol_types_generated/calling_stream_stop_params.rb | 2 ++ .../protocol_types_generated/calling_stream_stop_result.rb | 2 ++ .../relay/protocol_types_generated/calling_tap_params.rb | 2 ++ .../relay/protocol_types_generated/calling_tap_result.rb | 2 ++ .../protocol_types_generated/calling_tap_stop_params.rb | 2 ++ .../protocol_types_generated/calling_tap_stop_result.rb | 2 ++ .../protocol_types_generated/calling_transfer_params.rb | 2 ++ .../protocol_types_generated/calling_transfer_result.rb | 2 ++ .../protocol_types_generated/calling_user_event_params.rb | 2 ++ .../protocol_types_generated/calling_user_event_result.rb | 2 ++ .../protocol_types_generated/messaging_send_params.rb | 2 ++ .../protocol_types_generated/messaging_send_result.rb | 2 ++ .../protocol_types_generated/signalwire_connect_params.rb | 2 ++ .../protocol_types_generated/signalwire_connect_result.rb | 2 ++ .../signalwire_disconnect_params.rb | 2 ++ .../protocol_types_generated/signalwire_execute_params.rb | 2 ++ .../protocol_types_generated/signalwire_execute_result.rb | 2 ++ .../protocol_types_generated/signalwire_ping_params.rb | 2 ++ .../protocol_types_generated/signalwire_ping_result.rb | 2 ++ .../signalwire_reauthenticate_params.rb | 2 ++ .../signalwire_reauthenticate_result.rb | 2 ++ scripts/generate_rest.py | 7 ++++++- 302 files changed, 608 insertions(+), 1 deletion(-) diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt.rb b/lib/signalwire/core/post_prompt_generated/post_prompt.rb index 0b5c04f7..1e26c4d4 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPrompt' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPrompt — generated read-side payload (post-prompt components/schemas 'PostPrompt'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb index 4a37bd60..d84e8917 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptAssistantEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptAssistantEntry — generated read-side payload (post-prompt components/schemas 'PostPromptAssistantEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb index e09cc929..5fe49f31 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptData' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptData — generated read-side payload (post-prompt components/schemas 'PostPromptData'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb index e86e8af5..4d67a144 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptEntity' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptEntity — generated read-side payload (post-prompt components/schemas 'PostPromptEntity'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb index 442c820f..f373f480 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptEot' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptEot — generated read-side payload (post-prompt components/schemas 'PostPromptEot'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb index 9363de0c..2f0fae39 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptStampsUs' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptStampsUs — generated read-side payload (post-prompt components/schemas 'PostPromptStampsUs'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb index c026086d..9beb6340 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptSwaigLogEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptSwaigLogEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSwaigLogEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb index be5f6176..b27c713c 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptSystemEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptSystemEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSystemEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb index 25975b21..4a38d57d 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptSystemLogEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptSystemLogEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSystemLogEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb index 9b4f25e8..f3348aaa 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptThinkingEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptThinkingEntry — generated read-side payload (post-prompt components/schemas 'PostPromptThinkingEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb index 83f12e2f..82a7edac 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptTimesEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptTimesEntry — generated read-side payload (post-prompt components/schemas 'PostPromptTimesEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb index ce2f3e07..24692ad0 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb @@ -9,7 +9,9 @@ # post-prompt components/schemas 'PostPromptTiming' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptTiming — generated read-side payload (post-prompt components/schemas 'PostPromptTiming'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb index 6fbfce31..aff67413 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptToolEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptToolEntry — generated read-side payload (post-prompt components/schemas 'PostPromptToolEntry'). # diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb index 33e14540..a8f1a59c 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb @@ -10,7 +10,9 @@ # post-prompt components/schemas 'PostPromptUserEntry' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::PostPromptGenerated — namespace for this generated data-class tree. module PostPromptGenerated # PostPromptUserEntry — generated read-side payload (post-prompt components/schemas 'PostPromptUserEntry'). # diff --git a/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb b/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb index 9f52463e..043a087f 100644 --- a/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb @@ -9,7 +9,9 @@ # swaig-response action 'context_switch' value object module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigActionsGenerated — namespace for this generated data-class tree. module SwaigActionsGenerated # ContextSwitchAction — generated data type (swaig-response action 'context_switch' value object). # diff --git a/lib/signalwire/core/swaig_actions_generated/hold_action.rb b/lib/signalwire/core/swaig_actions_generated/hold_action.rb index 850ee5d6..2868a570 100644 --- a/lib/signalwire/core/swaig_actions_generated/hold_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/hold_action.rb @@ -9,7 +9,9 @@ # swaig-response action 'hold' value object module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigActionsGenerated — namespace for this generated data-class tree. module SwaigActionsGenerated # HoldAction — generated data type (swaig-response action 'hold' value object). # diff --git a/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb b/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb index 242bbdf8..181efbe0 100644 --- a/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb @@ -9,7 +9,9 @@ # swaig-response action 'playback_bg' value object module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigActionsGenerated — namespace for this generated data-class tree. module SwaigActionsGenerated # PlaybackBgAction — generated data type (swaig-response action 'playback_bg' value object). # diff --git a/lib/signalwire/core/swaig_actions_generated/transfer_action.rb b/lib/signalwire/core/swaig_actions_generated/transfer_action.rb index 54b7e407..63cff88d 100644 --- a/lib/signalwire/core/swaig_actions_generated/transfer_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/transfer_action.rb @@ -9,7 +9,9 @@ # swaig-response action 'transfer' value object module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigActionsGenerated — namespace for this generated data-class tree. module SwaigActionsGenerated # TransferAction — generated data type (swaig-response action 'transfer' value object). # diff --git a/lib/signalwire/core/swaig_request_generated/swaig_argument.rb b/lib/signalwire/core/swaig_request_generated/swaig_argument.rb index d3039842..77c66a4f 100644 --- a/lib/signalwire/core/swaig_request_generated/swaig_argument.rb +++ b/lib/signalwire/core/swaig_request_generated/swaig_argument.rb @@ -9,7 +9,9 @@ # inline swaig-request `argument` object module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigRequestGenerated — namespace for this generated data-class tree. module SwaigRequestGenerated # SwaigArgument — generated read-side payload (inline swaig-request `argument` object). # diff --git a/lib/signalwire/core/swaig_request_generated/swaig_request.rb b/lib/signalwire/core/swaig_request_generated/swaig_request.rb index e83cdc9c..1492d5c7 100644 --- a/lib/signalwire/core/swaig_request_generated/swaig_request.rb +++ b/lib/signalwire/core/swaig_request_generated/swaig_request.rb @@ -10,7 +10,9 @@ # swaig-request `SwaigRequest` schema module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwaigRequestGenerated — namespace for this generated data-class tree. module SwaigRequestGenerated # SwaigRequest — generated read-side payload (swaig-request `SwaigRequest` schema). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i.rb b/lib/signalwire/core/swml_verbs_generated/a_i.rb index ac531a9a..d14858a8 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'AI' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AI — generated read-side payload (schema.json $defs schema 'AI'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_object.rb b/lib/signalwire/core/swml_verbs_generated/a_i_object.rb index e989168b..78be0761 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_object.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AIObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIObject — generated read-side payload (schema.json $defs schema 'AIObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_params.rb b/lib/signalwire/core/swml_verbs_generated/a_i_params.rb index 99910358..d75335ee 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_params.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AIParams' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIParams — generated read-side payload (schema.json $defs schema 'AIParams'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb index f5ac59bb..8f196fe7 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'AIPostPromptPom' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIPostPromptPom — generated read-side payload (schema.json $defs schema 'AIPostPromptPom'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb index 8034e955..601f2bc2 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'AIPostPromptText' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIPostPromptText — generated read-side payload (schema.json $defs schema 'AIPostPromptText'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb index 53482b8e..387682ec 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AIPromptPom' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIPromptPom — generated read-side payload (schema.json $defs schema 'AIPromptPom'). # diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb index 1ba55889..6ec4cf1b 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AIPromptText' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AIPromptText — generated read-side payload (schema.json $defs schema 'AIPromptText'). # diff --git a/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb b/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb index 1a026b6b..c662be45 100644 --- a/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb +++ b/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'AiSidecar' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AiSidecar — generated read-side payload (schema.json $defs schema 'AiSidecar'). # diff --git a/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb b/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb index 7a45c2fa..25694fd4 100644 --- a/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'ai_sidecar' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AiSidecarConfig — generated read-side payload (flattened SWMLMethod verb 'ai_sidecar' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/all_of_property.rb b/lib/signalwire/core/swml_verbs_generated/all_of_property.rb index 97df4738..ec969701 100644 --- a/lib/signalwire/core/swml_verbs_generated/all_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/all_of_property.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AllOfProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AllOfProperty — generated read-side payload (schema.json $defs schema 'AllOfProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb index d02c2b77..545a6195 100644 --- a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb +++ b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'AmazonBedrock' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AmazonBedrock — generated read-side payload (schema.json $defs schema 'AmazonBedrock'). # diff --git a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb index 1e92ee6d..770b04af 100644 --- a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AmazonBedrockObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AmazonBedrockObject — generated read-side payload (schema.json $defs schema 'AmazonBedrockObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/answer.rb b/lib/signalwire/core/swml_verbs_generated/answer.rb index 78716680..7773e081 100644 --- a/lib/signalwire/core/swml_verbs_generated/answer.rb +++ b/lib/signalwire/core/swml_verbs_generated/answer.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Answer' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Answer — generated read-side payload (schema.json $defs schema 'Answer'). # diff --git a/lib/signalwire/core/swml_verbs_generated/any_of_property.rb b/lib/signalwire/core/swml_verbs_generated/any_of_property.rb index 00dae107..67485650 100644 --- a/lib/signalwire/core/swml_verbs_generated/any_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/any_of_property.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'AnyOfProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # AnyOfProperty — generated read-side payload (schema.json $defs schema 'AnyOfProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/array_property.rb b/lib/signalwire/core/swml_verbs_generated/array_property.rb index 84c2d1b7..5a74cd35 100644 --- a/lib/signalwire/core/swml_verbs_generated/array_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/array_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ArrayProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ArrayProperty — generated read-side payload (schema.json $defs schema 'ArrayProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb b/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb index 10758655..0ef751f0 100644 --- a/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'BedrockParams' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # BedrockParams — generated read-side payload (schema.json $defs schema 'BedrockParams'). # diff --git a/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb b/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb index cd960e2f..35f9c7e3 100644 --- a/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb +++ b/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'BedrockSWAIG' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # BedrockSWAIG — generated read-side payload (schema.json $defs schema 'BedrockSWAIG'). # diff --git a/lib/signalwire/core/swml_verbs_generated/boolean_property.rb b/lib/signalwire/core/swml_verbs_generated/boolean_property.rb index 9f98fb80..6fd5a873 100644 --- a/lib/signalwire/core/swml_verbs_generated/boolean_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/boolean_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'BooleanProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # BooleanProperty — generated read-side payload (schema.json $defs schema 'BooleanProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/change_context_action.rb b/lib/signalwire/core/swml_verbs_generated/change_context_action.rb index ccfc9ad5..6b6ce13a 100644 --- a/lib/signalwire/core/swml_verbs_generated/change_context_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/change_context_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ChangeContextAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ChangeContextAction — generated read-side payload (schema.json $defs schema 'ChangeContextAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/change_step_action.rb b/lib/signalwire/core/swml_verbs_generated/change_step_action.rb index 139f82e3..840e928e 100644 --- a/lib/signalwire/core/swml_verbs_generated/change_step_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/change_step_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ChangeStepAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ChangeStepAction — generated read-side payload (schema.json $defs schema 'ChangeStepAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/cond.rb b/lib/signalwire/core/swml_verbs_generated/cond.rb index e1c24029..c1e229f5 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Cond' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Cond — generated read-side payload (schema.json $defs schema 'Cond'). # diff --git a/lib/signalwire/core/swml_verbs_generated/cond_else.rb b/lib/signalwire/core/swml_verbs_generated/cond_else.rb index c048f038..e26a8302 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond_else.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond_else.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'CondElse' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # CondElse — generated read-side payload (schema.json $defs schema 'CondElse'). # diff --git a/lib/signalwire/core/swml_verbs_generated/cond_reg.rb b/lib/signalwire/core/swml_verbs_generated/cond_reg.rb index 3473eacc..1f7f728f 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond_reg.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond_reg.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'CondReg' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # CondReg — generated read-side payload (schema.json $defs schema 'CondReg'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect.rb b/lib/signalwire/core/swml_verbs_generated/connect.rb index 0881ef00..eab7a5c0 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Connect' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Connect — generated read-side payload (schema.json $defs schema 'Connect'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_config.rb b/lib/signalwire/core/swml_verbs_generated/connect_config.rb index ac7ae320..1f66f457 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'connect' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectConfig — generated read-side payload (flattened SWMLMethod verb 'connect' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb index d7a61199..a6b7516b 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'ConnectDeviceParallel' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectDeviceParallel — generated read-side payload (schema.json $defs schema 'ConnectDeviceParallel'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb index 546b7a4d..4e3166f2 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'ConnectDeviceSerial' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectDeviceSerial — generated read-side payload (schema.json $defs schema 'ConnectDeviceSerial'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb index bb603c2e..520a3384 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'ConnectDeviceSerialParallel' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectDeviceSerialParallel — generated read-side payload (schema.json $defs schema 'ConnectDeviceSerialParallel'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb index a4d9a965..2f13c209 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'ConnectDeviceSingle' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectDeviceSingle — generated read-side payload (schema.json $defs schema 'ConnectDeviceSingle'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_headers.rb b/lib/signalwire/core/swml_verbs_generated/connect_headers.rb index ffba2b76..ece6db33 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_headers.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_headers.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ConnectHeaders' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectHeaders — generated read-side payload (schema.json $defs schema 'ConnectHeaders'). # diff --git a/lib/signalwire/core/swml_verbs_generated/connect_switch.rb b/lib/signalwire/core/swml_verbs_generated/connect_switch.rb index 03e11a64..b6afe4a1 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_switch.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ConnectSwitch' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConnectSwitch — generated read-side payload (schema.json $defs schema 'ConnectSwitch'). # diff --git a/lib/signalwire/core/swml_verbs_generated/const_property.rb b/lib/signalwire/core/swml_verbs_generated/const_property.rb index 5378d24c..a829ea00 100644 --- a/lib/signalwire/core/swml_verbs_generated/const_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/const_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ConstProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConstProperty — generated read-side payload (schema.json $defs schema 'ConstProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb b/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb index ebb9540d..ca66c197 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ContextPOMSteps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ContextPOMSteps — generated read-side payload (schema.json $defs schema 'ContextPOMSteps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb b/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb index dc9a10d9..9a33f598 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ContextSwitchAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ContextSwitchAction — generated read-side payload (schema.json $defs schema 'ContextSwitchAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb b/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb index a3d02b3d..c5380cb9 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ContextTextSteps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ContextTextSteps — generated read-side payload (schema.json $defs schema 'ContextTextSteps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/contexts.rb b/lib/signalwire/core/swml_verbs_generated/contexts.rb index d25bca14..65e609fb 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Contexts' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Contexts — generated read-side payload (schema.json $defs schema 'Contexts'). # diff --git a/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb b/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb index 225c915a..e963ec9a 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ContextsPOMObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ContextsPOMObject — generated read-side payload (schema.json $defs schema 'ContextsPOMObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb b/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb index c9de6c1a..506fe131 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ContextsTextObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ContextsTextObject — generated read-side payload (schema.json $defs schema 'ContextsTextObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/conversation_message.rb b/lib/signalwire/core/swml_verbs_generated/conversation_message.rb index 5112d099..adcd7168 100644 --- a/lib/signalwire/core/swml_verbs_generated/conversation_message.rb +++ b/lib/signalwire/core/swml_verbs_generated/conversation_message.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ConversationMessage' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ConversationMessage — generated read-side payload (schema.json $defs schema 'ConversationMessage'). # diff --git a/lib/signalwire/core/swml_verbs_generated/data_map.rb b/lib/signalwire/core/swml_verbs_generated/data_map.rb index fc90a3d4..92d900ab 100644 --- a/lib/signalwire/core/swml_verbs_generated/data_map.rb +++ b/lib/signalwire/core/swml_verbs_generated/data_map.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'DataMap' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # DataMap — generated read-side payload (schema.json $defs schema 'DataMap'). # diff --git a/lib/signalwire/core/swml_verbs_generated/denoise.rb b/lib/signalwire/core/swml_verbs_generated/denoise.rb index b9f05e4a..ea0cbe35 100644 --- a/lib/signalwire/core/swml_verbs_generated/denoise.rb +++ b/lib/signalwire/core/swml_verbs_generated/denoise.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Denoise' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Denoise — generated read-side payload (schema.json $defs schema 'Denoise'). # diff --git a/lib/signalwire/core/swml_verbs_generated/detect_machine.rb b/lib/signalwire/core/swml_verbs_generated/detect_machine.rb index 8de80013..3ea844ab 100644 --- a/lib/signalwire/core/swml_verbs_generated/detect_machine.rb +++ b/lib/signalwire/core/swml_verbs_generated/detect_machine.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'DetectMachine' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # DetectMachine — generated read-side payload (schema.json $defs schema 'DetectMachine'). # diff --git a/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb b/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb index 3c7e223e..8fb012d3 100644 --- a/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'detect_machine' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # DetectMachineConfig — generated read-side payload (flattened SWMLMethod verb 'detect_machine' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/enter_queue.rb b/lib/signalwire/core/swml_verbs_generated/enter_queue.rb index 5a4d72a0..ac0524b4 100644 --- a/lib/signalwire/core/swml_verbs_generated/enter_queue.rb +++ b/lib/signalwire/core/swml_verbs_generated/enter_queue.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'EnterQueue' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # EnterQueue — generated read-side payload (schema.json $defs schema 'EnterQueue'). # diff --git a/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb b/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb index 745c1c05..a47893aa 100644 --- a/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'EnterQueueObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # EnterQueueObject — generated read-side payload (schema.json $defs schema 'EnterQueueObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/execute.rb b/lib/signalwire/core/swml_verbs_generated/execute.rb index 7857b164..bdbbff5e 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Execute' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Execute — generated read-side payload (schema.json $defs schema 'Execute'). # diff --git a/lib/signalwire/core/swml_verbs_generated/execute_config.rb b/lib/signalwire/core/swml_verbs_generated/execute_config.rb index 99fde1a2..54ec1d15 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'execute' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ExecuteConfig — generated read-side payload (flattened SWMLMethod verb 'execute' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/execute_switch.rb b/lib/signalwire/core/swml_verbs_generated/execute_switch.rb index 0effbf31..743af79b 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute_switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute_switch.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ExecuteSwitch' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ExecuteSwitch — generated read-side payload (schema.json $defs schema 'ExecuteSwitch'). # diff --git a/lib/signalwire/core/swml_verbs_generated/expression.rb b/lib/signalwire/core/swml_verbs_generated/expression.rb index d3fd0a5a..f0efde2e 100644 --- a/lib/signalwire/core/swml_verbs_generated/expression.rb +++ b/lib/signalwire/core/swml_verbs_generated/expression.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Expression' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Expression — generated read-side payload (schema.json $defs schema 'Expression'). # diff --git a/lib/signalwire/core/swml_verbs_generated/function_parameters.rb b/lib/signalwire/core/swml_verbs_generated/function_parameters.rb index 3a13d2f4..7bcaa29f 100644 --- a/lib/signalwire/core/swml_verbs_generated/function_parameters.rb +++ b/lib/signalwire/core/swml_verbs_generated/function_parameters.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'FunctionParameters' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # FunctionParameters — generated read-side payload (schema.json $defs schema 'FunctionParameters'). # diff --git a/lib/signalwire/core/swml_verbs_generated/goto.rb b/lib/signalwire/core/swml_verbs_generated/goto.rb index 5788fa6e..eec851a1 100644 --- a/lib/signalwire/core/swml_verbs_generated/goto.rb +++ b/lib/signalwire/core/swml_verbs_generated/goto.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Goto' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Goto — generated read-side payload (schema.json $defs schema 'Goto'). # diff --git a/lib/signalwire/core/swml_verbs_generated/goto_config.rb b/lib/signalwire/core/swml_verbs_generated/goto_config.rb index c1e42304..0cb0de2d 100644 --- a/lib/signalwire/core/swml_verbs_generated/goto_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/goto_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'goto' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # GotoConfig — generated read-side payload (flattened SWMLMethod verb 'goto' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb index ef60c0b3..b97906c2 100644 --- a/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'HangUpHookSWAIGFunction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # HangUpHookSWAIGFunction — generated read-side payload (schema.json $defs schema 'HangUpHookSWAIGFunction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/hangup.rb b/lib/signalwire/core/swml_verbs_generated/hangup.rb index 29e3b85a..5727588e 100644 --- a/lib/signalwire/core/swml_verbs_generated/hangup.rb +++ b/lib/signalwire/core/swml_verbs_generated/hangup.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Hangup' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Hangup — generated read-side payload (schema.json $defs schema 'Hangup'). # diff --git a/lib/signalwire/core/swml_verbs_generated/hangup_action.rb b/lib/signalwire/core/swml_verbs_generated/hangup_action.rb index 551065ca..d3357491 100644 --- a/lib/signalwire/core/swml_verbs_generated/hangup_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/hangup_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'HangupAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # HangupAction — generated read-side payload (schema.json $defs schema 'HangupAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/hint.rb b/lib/signalwire/core/swml_verbs_generated/hint.rb index eefa9898..7dda897a 100644 --- a/lib/signalwire/core/swml_verbs_generated/hint.rb +++ b/lib/signalwire/core/swml_verbs_generated/hint.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Hint' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Hint — generated read-side payload (schema.json $defs schema 'Hint'). # diff --git a/lib/signalwire/core/swml_verbs_generated/hold_action.rb b/lib/signalwire/core/swml_verbs_generated/hold_action.rb index 1c8db529..9f7a1502 100644 --- a/lib/signalwire/core/swml_verbs_generated/hold_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/hold_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'HoldAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # HoldAction — generated read-side payload (schema.json $defs schema 'HoldAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/inject_action.rb b/lib/signalwire/core/swml_verbs_generated/inject_action.rb index dc8e5256..73c0ae55 100644 --- a/lib/signalwire/core/swml_verbs_generated/inject_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/inject_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'InjectAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # InjectAction — generated read-side payload (schema.json $defs schema 'InjectAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/integer_property.rb b/lib/signalwire/core/swml_verbs_generated/integer_property.rb index dc61d8f8..9019e161 100644 --- a/lib/signalwire/core/swml_verbs_generated/integer_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/integer_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'IntegerProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # IntegerProperty — generated read-side payload (schema.json $defs schema 'IntegerProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/join_conference.rb b/lib/signalwire/core/swml_verbs_generated/join_conference.rb index abd266b6..86ce4daa 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_conference.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_conference.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'JoinConference' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # JoinConference — generated read-side payload (schema.json $defs schema 'JoinConference'). # diff --git a/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb b/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb index d076eb3d..5ed4424b 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'JoinConferenceObject' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # JoinConferenceObject — generated read-side payload (schema.json $defs schema 'JoinConferenceObject'). # diff --git a/lib/signalwire/core/swml_verbs_generated/join_room.rb b/lib/signalwire/core/swml_verbs_generated/join_room.rb index ef3c5de5..91a111a1 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_room.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_room.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'JoinRoom' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # JoinRoom — generated read-side payload (schema.json $defs schema 'JoinRoom'). # diff --git a/lib/signalwire/core/swml_verbs_generated/join_room_config.rb b/lib/signalwire/core/swml_verbs_generated/join_room_config.rb index b30a7603..2d763957 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_room_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_room_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'join_room' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # JoinRoomConfig — generated read-side payload (flattened SWMLMethod verb 'join_room' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/label.rb b/lib/signalwire/core/swml_verbs_generated/label.rb index cec64c4e..fb9e86c3 100644 --- a/lib/signalwire/core/swml_verbs_generated/label.rb +++ b/lib/signalwire/core/swml_verbs_generated/label.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Label' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Label — generated read-side payload (schema.json $defs schema 'Label'). # diff --git a/lib/signalwire/core/swml_verbs_generated/language_params.rb b/lib/signalwire/core/swml_verbs_generated/language_params.rb index b130554c..e67dffa3 100644 --- a/lib/signalwire/core/swml_verbs_generated/language_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/language_params.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'LanguageParams' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LanguageParams — generated read-side payload (schema.json $defs schema 'LanguageParams'). # diff --git a/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb b/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb index dac00126..09221f97 100644 --- a/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb +++ b/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'LanguagesWithFillers' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LanguagesWithFillers — generated read-side payload (schema.json $defs schema 'LanguagesWithFillers'). # diff --git a/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb b/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb index 597f9435..024b87a3 100644 --- a/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb +++ b/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'LanguagesWithSoloFillers' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LanguagesWithSoloFillers — generated read-side payload (schema.json $defs schema 'LanguagesWithSoloFillers'). # diff --git a/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb b/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb index c91c4d71..1bbdd9a7 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'LiveTranscribe' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LiveTranscribe — generated read-side payload (schema.json $defs schema 'LiveTranscribe'). # diff --git a/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb b/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb index 78b138d1..844c05fc 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'live_transcribe' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LiveTranscribeConfig — generated read-side payload (flattened SWMLMethod verb 'live_transcribe' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/live_translate.rb b/lib/signalwire/core/swml_verbs_generated/live_translate.rb index 979dc439..ca475c92 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_translate.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_translate.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'LiveTranslate' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LiveTranslate — generated read-side payload (schema.json $defs schema 'LiveTranslate'). # diff --git a/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb b/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb index 3a099e2d..7d22a020 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'live_translate' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # LiveTranslateConfig — generated read-side payload (flattened SWMLMethod verb 'live_translate' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/null_property.rb b/lib/signalwire/core/swml_verbs_generated/null_property.rb index 14be54e2..06772a13 100644 --- a/lib/signalwire/core/swml_verbs_generated/null_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/null_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'NullProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # NullProperty — generated read-side payload (schema.json $defs schema 'NullProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/number_property.rb b/lib/signalwire/core/swml_verbs_generated/number_property.rb index e5c0f163..eada8161 100644 --- a/lib/signalwire/core/swml_verbs_generated/number_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/number_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'NumberProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # NumberProperty — generated read-side payload (schema.json $defs schema 'NumberProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/object_property.rb b/lib/signalwire/core/swml_verbs_generated/object_property.rb index a8adfa97..f1de2e38 100644 --- a/lib/signalwire/core/swml_verbs_generated/object_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/object_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ObjectProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ObjectProperty — generated read-side payload (schema.json $defs schema 'ObjectProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb index da9277d3..5565fa0c 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'OmitPropertiesBedrockPostPomptTextOmittedPromptProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # OmitPropertiesBedrockPostPomptTextOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPostPomptTextOmittedPromptProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb index a49fb220..793eebf3 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'OmitPropertiesBedrockPostPromptPomOmittedPromptProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # OmitPropertiesBedrockPostPromptPomOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPostPromptPomOmittedPromptProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb index adfcf2c6..bf88953a 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'OmitPropertiesBedrockPromptPomOmittedPromptProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # OmitPropertiesBedrockPromptPomOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPromptPomOmittedPromptProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb index 118b6ec5..b8833262 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'OmitPropertiesBedrockPromptTextOmittedPromptProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # OmitPropertiesBedrockPromptTextOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPromptTextOmittedPromptProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/one_of_property.rb b/lib/signalwire/core/swml_verbs_generated/one_of_property.rb index b1b18b68..667f6c2b 100644 --- a/lib/signalwire/core/swml_verbs_generated/one_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/one_of_property.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'OneOfProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # OneOfProperty — generated read-side payload (schema.json $defs schema 'OneOfProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/output.rb b/lib/signalwire/core/swml_verbs_generated/output.rb index f508cff6..c5219d40 100644 --- a/lib/signalwire/core/swml_verbs_generated/output.rb +++ b/lib/signalwire/core/swml_verbs_generated/output.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Output' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Output — generated read-side payload (schema.json $defs schema 'Output'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay.rb b/lib/signalwire/core/swml_verbs_generated/pay.rb index 100dfa35..7f0041bf 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Pay' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Pay — generated read-side payload (schema.json $defs schema 'Pay'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay_config.rb b/lib/signalwire/core/swml_verbs_generated/pay_config.rb index 5aab5c71..a990a9b9 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'pay' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PayConfig — generated read-side payload (flattened SWMLMethod verb 'pay' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb b/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb index 8b46f2ad..2e189bd4 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PayParameters' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PayParameters — generated read-side payload (schema.json $defs schema 'PayParameters'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb index ac32f435..dec47ba3 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PayPromptPlayAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PayPromptPlayAction — generated read-side payload (schema.json $defs schema 'PayPromptPlayAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb index 4bbe8874..a39201b1 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PayPromptSayAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PayPromptSayAction — generated read-side payload (schema.json $defs schema 'PayPromptSayAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb index c580e1a4..15ffb696 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PayPrompts' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PayPrompts — generated read-side payload (schema.json $defs schema 'PayPrompts'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index 07991475..ab6457e2 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index 09e4f6bb..21d19b25 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index ab386d86..ae311dd7 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index d6121455..71d0cfd0 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps'). # diff --git a/lib/signalwire/core/swml_verbs_generated/play.rb b/lib/signalwire/core/swml_verbs_generated/play.rb index 9b5d7559..1b7373d3 100644 --- a/lib/signalwire/core/swml_verbs_generated/play.rb +++ b/lib/signalwire/core/swml_verbs_generated/play.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Play' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Play — generated read-side payload (schema.json $defs schema 'Play'). # diff --git a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb index 2ce1a924..0eb681e1 100644 --- a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb +++ b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PlayWithURL' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PlayWithURL — generated read-side payload (schema.json $defs schema 'PlayWithURL'). # diff --git a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb index 27832328..0039e7e8 100644 --- a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb +++ b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PlayWithURLS' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PlayWithURLS — generated read-side payload (schema.json $defs schema 'PlayWithURLS'). # diff --git a/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb b/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb index a959f5f6..20477198 100644 --- a/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'PlaybackBGAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PlaybackBGAction — generated read-side payload (schema.json $defs schema 'PlaybackBGAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb b/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb index 43094988..cca5a0f8 100644 --- a/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb +++ b/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PomSectionBodyContent' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PomSectionBodyContent — generated read-side payload (schema.json $defs schema 'PomSectionBodyContent'). # diff --git a/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb b/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb index f1276136..d284f98b 100644 --- a/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb +++ b/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'PomSectionBulletsContent' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PomSectionBulletsContent — generated read-side payload (schema.json $defs schema 'PomSectionBulletsContent'). # diff --git a/lib/signalwire/core/swml_verbs_generated/prompt.rb b/lib/signalwire/core/swml_verbs_generated/prompt.rb index 8310fcec..d446ece6 100644 --- a/lib/signalwire/core/swml_verbs_generated/prompt.rb +++ b/lib/signalwire/core/swml_verbs_generated/prompt.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Prompt' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Prompt — generated read-side payload (schema.json $defs schema 'Prompt'). # diff --git a/lib/signalwire/core/swml_verbs_generated/prompt_config.rb b/lib/signalwire/core/swml_verbs_generated/prompt_config.rb index 2f79595c..b1a89233 100644 --- a/lib/signalwire/core/swml_verbs_generated/prompt_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/prompt_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'prompt' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # PromptConfig — generated read-side payload (flattened SWMLMethod verb 'prompt' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/pronounce.rb b/lib/signalwire/core/swml_verbs_generated/pronounce.rb index 5879a65b..c5eac36c 100644 --- a/lib/signalwire/core/swml_verbs_generated/pronounce.rb +++ b/lib/signalwire/core/swml_verbs_generated/pronounce.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Pronounce' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Pronounce — generated read-side payload (schema.json $defs schema 'Pronounce'). # diff --git a/lib/signalwire/core/swml_verbs_generated/receive_fax.rb b/lib/signalwire/core/swml_verbs_generated/receive_fax.rb index 3e5abdfa..11033071 100644 --- a/lib/signalwire/core/swml_verbs_generated/receive_fax.rb +++ b/lib/signalwire/core/swml_verbs_generated/receive_fax.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ReceiveFax' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ReceiveFax — generated read-side payload (schema.json $defs schema 'ReceiveFax'). # diff --git a/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb b/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb index ce26d9f7..3c2705ab 100644 --- a/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'receive_fax' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ReceiveFaxConfig — generated read-side payload (flattened SWMLMethod verb 'receive_fax' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/record.rb b/lib/signalwire/core/swml_verbs_generated/record.rb index 1527aa06..cd84b8e7 100644 --- a/lib/signalwire/core/swml_verbs_generated/record.rb +++ b/lib/signalwire/core/swml_verbs_generated/record.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Record' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Record — generated read-side payload (schema.json $defs schema 'Record'). # diff --git a/lib/signalwire/core/swml_verbs_generated/record_call.rb b/lib/signalwire/core/swml_verbs_generated/record_call.rb index 091784f3..56dfac95 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_call.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_call.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'RecordCall' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # RecordCall — generated read-side payload (schema.json $defs schema 'RecordCall'). # diff --git a/lib/signalwire/core/swml_verbs_generated/record_call_config.rb b/lib/signalwire/core/swml_verbs_generated/record_call_config.rb index 91964bbb..50ecb0f9 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_call_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_call_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'record_call' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # RecordCallConfig — generated read-side payload (flattened SWMLMethod verb 'record_call' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/record_config.rb b/lib/signalwire/core/swml_verbs_generated/record_config.rb index be3cf078..8397011a 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_config.rb @@ -10,7 +10,9 @@ # flattened SWMLMethod verb 'record' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # RecordConfig — generated read-side payload (flattened SWMLMethod verb 'record' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/request.rb b/lib/signalwire/core/swml_verbs_generated/request.rb index 454acfa5..794c6f89 100644 --- a/lib/signalwire/core/swml_verbs_generated/request.rb +++ b/lib/signalwire/core/swml_verbs_generated/request.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Request' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Request — generated read-side payload (schema.json $defs schema 'Request'). # diff --git a/lib/signalwire/core/swml_verbs_generated/request_config.rb b/lib/signalwire/core/swml_verbs_generated/request_config.rb index 3d29c83f..f11d5935 100644 --- a/lib/signalwire/core/swml_verbs_generated/request_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/request_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'request' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # RequestConfig — generated read-side payload (flattened SWMLMethod verb 'request' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/return.rb b/lib/signalwire/core/swml_verbs_generated/return.rb index feab03a1..9693cfa3 100644 --- a/lib/signalwire/core/swml_verbs_generated/return.rb +++ b/lib/signalwire/core/swml_verbs_generated/return.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Return' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Return — generated read-side payload (schema.json $defs schema 'Return'). # diff --git a/lib/signalwire/core/swml_verbs_generated/ringback_config.rb b/lib/signalwire/core/swml_verbs_generated/ringback_config.rb index e0f7a122..626af242 100644 --- a/lib/signalwire/core/swml_verbs_generated/ringback_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/ringback_config.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'RingbackConfig' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # RingbackConfig — generated read-side payload (schema.json $defs schema 'RingbackConfig'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb b/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb index 84683061..bda40631 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SIPRefer' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SIPRefer — generated read-side payload (schema.json $defs schema 'SIPRefer'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb index 29024c72..3d4d04aa 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SMSWithBody' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SMSWithBody — generated read-side payload (schema.json $defs schema 'SMSWithBody'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb index 654c35bd..e07b9645 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SMSWithMedia' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SMSWithMedia — generated read-side payload (schema.json $defs schema 'SMSWithMedia'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb index 34e24c53..4558a4de 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SWAIG' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SWAIG — generated read-side payload (schema.json $defs schema 'SWAIG'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb index b334bffa..c5a7820e 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SWAIGDefaults' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SWAIGDefaults — generated read-side payload (schema.json $defs schema 'SWAIGDefaults'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb index 5361b0c0..cd5fd408 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SWAIGIncludes' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SWAIGIncludes — generated read-side payload (schema.json $defs schema 'SWAIGIncludes'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb index c52e1f0d..b56f05e4 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'SWAIGInternalFiller' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SWAIGInternalFiller — generated read-side payload (schema.json $defs schema 'SWAIGInternalFiller'). # diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb b/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb index 90e53fcc..c96bc72b 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'SWMLAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SWMLAction — generated read-side payload (schema.json $defs schema 'SWMLAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/say_action.rb b/lib/signalwire/core/swml_verbs_generated/say_action.rb index 3cc6328a..0efa7178 100644 --- a/lib/signalwire/core/swml_verbs_generated/say_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/say_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SayAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SayAction — generated read-side payload (schema.json $defs schema 'SayAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/section.rb b/lib/signalwire/core/swml_verbs_generated/section.rb index cc45e7c0..b19bc960 100644 --- a/lib/signalwire/core/swml_verbs_generated/section.rb +++ b/lib/signalwire/core/swml_verbs_generated/section.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Section' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Section — generated read-side payload (schema.json $defs schema 'Section'). # diff --git a/lib/signalwire/core/swml_verbs_generated/send_digits.rb b/lib/signalwire/core/swml_verbs_generated/send_digits.rb index 321006ea..24dc3134 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_digits.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_digits.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SendDigits' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SendDigits — generated read-side payload (schema.json $defs schema 'SendDigits'). # diff --git a/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb b/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb index 6efc4699..7eb7f441 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'send_digits' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SendDigitsConfig — generated read-side payload (flattened SWMLMethod verb 'send_digits' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/send_fax.rb b/lib/signalwire/core/swml_verbs_generated/send_fax.rb index ab712d1e..8ea48273 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_fax.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_fax.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SendFax' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SendFax — generated read-side payload (schema.json $defs schema 'SendFax'). # diff --git a/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb b/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb index 35f075c9..400667ba 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'send_fax' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SendFaxConfig — generated read-side payload (flattened SWMLMethod verb 'send_fax' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb b/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb index fcade836..170e9b65 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SendSMS' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SendSMS — generated read-side payload (schema.json $defs schema 'SendSMS'). # diff --git a/lib/signalwire/core/swml_verbs_generated/set.rb b/lib/signalwire/core/swml_verbs_generated/set.rb index d9be4975..c42f2abb 100644 --- a/lib/signalwire/core/swml_verbs_generated/set.rb +++ b/lib/signalwire/core/swml_verbs_generated/set.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Set' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Set — generated read-side payload (schema.json $defs schema 'Set'). # diff --git a/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb b/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb index 818c1429..2112787a 100644 --- a/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SetGlobalDataAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SetGlobalDataAction — generated read-side payload (schema.json $defs schema 'SetGlobalDataAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb b/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb index 166a39f1..2e1745ff 100644 --- a/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SetMetaDataAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SetMetaDataAction — generated read-side payload (schema.json $defs schema 'SetMetaDataAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb b/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb index f2df1af9..f9cce9a8 100644 --- a/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'sip_refer' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SipReferConfig — generated read-side payload (flattened SWMLMethod verb 'sip_refer' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/sleep.rb b/lib/signalwire/core/swml_verbs_generated/sleep.rb index 10d64c4a..e2d8575b 100644 --- a/lib/signalwire/core/swml_verbs_generated/sleep.rb +++ b/lib/signalwire/core/swml_verbs_generated/sleep.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Sleep' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Sleep — generated read-side payload (schema.json $defs schema 'Sleep'). # diff --git a/lib/signalwire/core/swml_verbs_generated/start_action.rb b/lib/signalwire/core/swml_verbs_generated/start_action.rb index 9dd8fcb6..67a05947 100644 --- a/lib/signalwire/core/swml_verbs_generated/start_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/start_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StartAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StartAction — generated read-side payload (schema.json $defs schema 'StartAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb index f2501f6f..a4366f3f 100644 --- a/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'StartUpHookSWAIGFunction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StartUpHookSWAIGFunction — generated read-side payload (schema.json $defs schema 'StartUpHookSWAIGFunction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_action.rb b/lib/signalwire/core/swml_verbs_generated/stop_action.rb index 2008f65c..0b13958b 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StopAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopAction — generated read-side payload (schema.json $defs schema 'StopAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb b/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb index eb776783..c791bd7d 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StopDenoise' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopDenoise — generated read-side payload (schema.json $defs schema 'StopDenoise'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb b/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb index 12cba77c..6399f85f 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StopPlaybackBGAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopPlaybackBGAction — generated read-side payload (schema.json $defs schema 'StopPlaybackBGAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb b/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb index fcc496fd..2a4cb15a 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StopRecordCall' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopRecordCall — generated read-side payload (schema.json $defs schema 'StopRecordCall'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb b/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb index 9ca7baea..0a706017 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'stop_record_call' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopRecordCallConfig — generated read-side payload (flattened SWMLMethod verb 'stop_record_call' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_tap.rb b/lib/signalwire/core/swml_verbs_generated/stop_tap.rb index 71754f7c..d2f172b0 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_tap.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_tap.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StopTap' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopTap — generated read-side payload (schema.json $defs schema 'StopTap'). # diff --git a/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb b/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb index a2c97d65..2c465277 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'stop_tap' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StopTapConfig — generated read-side payload (flattened SWMLMethod verb 'stop_tap' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/string_property.rb b/lib/signalwire/core/swml_verbs_generated/string_property.rb index 386ab1eb..d4b94a9c 100644 --- a/lib/signalwire/core/swml_verbs_generated/string_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/string_property.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'StringProperty' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # StringProperty — generated read-side payload (schema.json $defs schema 'StringProperty'). # diff --git a/lib/signalwire/core/swml_verbs_generated/summarize_action.rb b/lib/signalwire/core/swml_verbs_generated/summarize_action.rb index 212c4578..36147a78 100644 --- a/lib/signalwire/core/swml_verbs_generated/summarize_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/summarize_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'SummarizeAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SummarizeAction — generated read-side payload (schema.json $defs schema 'SummarizeAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb index 6f0ff1bb..bec73f28 100644 --- a/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'SummarizeConversationSWAIGFunction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SummarizeConversationSWAIGFunction — generated read-side payload (schema.json $defs schema 'SummarizeConversationSWAIGFunction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/switch.rb b/lib/signalwire/core/swml_verbs_generated/switch.rb index e0cfa88e..131ac577 100644 --- a/lib/signalwire/core/swml_verbs_generated/switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/switch.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Switch' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Switch — generated read-side payload (schema.json $defs schema 'Switch'). # diff --git a/lib/signalwire/core/swml_verbs_generated/switch_config.rb b/lib/signalwire/core/swml_verbs_generated/switch_config.rb index 5da76e27..b81b29e8 100644 --- a/lib/signalwire/core/swml_verbs_generated/switch_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/switch_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'switch' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # SwitchConfig — generated read-side payload (flattened SWMLMethod verb 'switch' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/tap.rb b/lib/signalwire/core/swml_verbs_generated/tap.rb index d0aa2696..c0392858 100644 --- a/lib/signalwire/core/swml_verbs_generated/tap.rb +++ b/lib/signalwire/core/swml_verbs_generated/tap.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Tap' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Tap — generated read-side payload (schema.json $defs schema 'Tap'). # diff --git a/lib/signalwire/core/swml_verbs_generated/tap_config.rb b/lib/signalwire/core/swml_verbs_generated/tap_config.rb index 3098e236..ea62425d 100644 --- a/lib/signalwire/core/swml_verbs_generated/tap_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/tap_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'tap' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # TapConfig — generated read-side payload (flattened SWMLMethod verb 'tap' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb b/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb index 94e75493..d1aa4f6e 100644 --- a/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'ToggleFunctionsAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # ToggleFunctionsAction — generated read-side payload (schema.json $defs schema 'ToggleFunctionsAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb b/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb index 3e81f406..533f07f7 100644 --- a/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'TranscribeStartAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # TranscribeStartAction — generated read-side payload (schema.json $defs schema 'TranscribeStartAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb b/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb index 2b7e0adb..8990cdab 100644 --- a/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'TranscribeSummarizeAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # TranscribeSummarizeAction — generated read-side payload (schema.json $defs schema 'TranscribeSummarizeAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/transfer.rb b/lib/signalwire/core/swml_verbs_generated/transfer.rb index af0a6b8b..641195c1 100644 --- a/lib/signalwire/core/swml_verbs_generated/transfer.rb +++ b/lib/signalwire/core/swml_verbs_generated/transfer.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Transfer' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Transfer — generated read-side payload (schema.json $defs schema 'Transfer'). # diff --git a/lib/signalwire/core/swml_verbs_generated/transfer_config.rb b/lib/signalwire/core/swml_verbs_generated/transfer_config.rb index 68aed11e..194cb00a 100644 --- a/lib/signalwire/core/swml_verbs_generated/transfer_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/transfer_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'transfer' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # TransferConfig — generated read-side payload (flattened SWMLMethod verb 'transfer' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/unset.rb b/lib/signalwire/core/swml_verbs_generated/unset.rb index 583070e7..d9639d23 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'Unset' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Unset — generated read-side payload (schema.json $defs schema 'Unset'). # diff --git a/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb b/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb index f5d4213e..f81cd335 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'UnsetGlobalDataAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UnsetGlobalDataAction — generated read-side payload (schema.json $defs schema 'UnsetGlobalDataAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb b/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb index 32c2838a..ea41eb74 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'UnsetMetaDataAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UnsetMetaDataAction — generated read-side payload (schema.json $defs schema 'UnsetMetaDataAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/user_event.rb b/lib/signalwire/core/swml_verbs_generated/user_event.rb index 5750f8fc..36727969 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_event.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_event.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'UserEvent' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UserEvent — generated read-side payload (schema.json $defs schema 'UserEvent'). # diff --git a/lib/signalwire/core/swml_verbs_generated/user_event_config.rb b/lib/signalwire/core/swml_verbs_generated/user_event_config.rb index c66161a8..7c5d1fc1 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_event_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_event_config.rb @@ -9,7 +9,9 @@ # flattened SWMLMethod verb 'user_event' config module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UserEventConfig — generated read-side payload (flattened SWMLMethod verb 'user_event' config). # diff --git a/lib/signalwire/core/swml_verbs_generated/user_input_action.rb b/lib/signalwire/core/swml_verbs_generated/user_input_action.rb index 0037d35b..a81ae67f 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_input_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_input_action.rb @@ -9,7 +9,9 @@ # schema.json $defs schema 'UserInputAction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UserInputAction — generated read-side payload (schema.json $defs schema 'UserInputAction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb index 39097d0e..5ac3ed65 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'UserSWAIGFunction' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # UserSWAIGFunction — generated read-side payload (schema.json $defs schema 'UserSWAIGFunction'). # diff --git a/lib/signalwire/core/swml_verbs_generated/webhook.rb b/lib/signalwire/core/swml_verbs_generated/webhook.rb index 8d25b530..b4ff484f 100644 --- a/lib/signalwire/core/swml_verbs_generated/webhook.rb +++ b/lib/signalwire/core/swml_verbs_generated/webhook.rb @@ -10,7 +10,9 @@ # schema.json $defs schema 'Webhook' module SignalWire + # SignalWire::Core — namespace for this generated data-class tree. module Core + # SignalWire::Core::SwmlVerbsGenerated — namespace for this generated data-class tree. module SwmlVerbsGenerated # Webhook — generated read-side payload (schema.json $defs schema 'Webhook'). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb index 8201eaec..124a140d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_hold', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiHoldParams — generated data type (RELAY method 'calling.ai_hold', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb index fbdfd11f..a415e9de 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_hold', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiHoldResult — generated data type (RELAY method 'calling.ai_hold', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb index 80d6fb90..4f834492 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_message', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiMessageParams — generated data type (RELAY method 'calling.ai_message', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb index a362597e..9eb6ce64 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_message', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiMessageResult — generated data type (RELAY method 'calling.ai_message', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb index 7bd40a7f..d7e5831c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_unhold', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiUnholdParams — generated data type (RELAY method 'calling.ai_unhold', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb index fb96e84b..2fc3cbbb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.ai_unhold', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAiUnholdResult — generated data type (RELAY method 'calling.ai_unhold', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb index 9a9c0a13..0c2272fb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.amazon_bedrock', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAmazonBedrockParams — generated data type (RELAY method 'calling.amazon_bedrock', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb index 3b32d77b..df7ed381 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.amazon_bedrock', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAmazonBedrockResult — generated data type (RELAY method 'calling.amazon_bedrock', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb index 66c899fd..1b93c093 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.answer', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAnswerParams — generated data type (RELAY method 'calling.answer', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb index e3100727..0dedeb25 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.answer', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingAnswerResult — generated data type (RELAY method 'calling.answer', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb index dc1ed2e1..73736179 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.begin', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingBeginParams — generated data type (RELAY method 'calling.begin', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb index 040866af..e05160f1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.begin', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingBeginResult — generated data type (RELAY method 'calling.begin', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb index 3495eb1f..cd3235df 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.bind_digit', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingBindDigitParams — generated data type (RELAY method 'calling.bind_digit', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb index db040559..d2a1a4a4 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.bind_digit', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingBindDigitResult — generated data type (RELAY method 'calling.bind_digit', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb index 94874732..54ef1057 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.clear_digit_bindings', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingClearDigitBindingsParams — generated data type (RELAY method 'calling.clear_digit_bindings', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb index bb93d5e1..c0e2ce2c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.clear_digit_bindings', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingClearDigitBindingsResult — generated data type (RELAY method 'calling.clear_digit_bindings', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb index 8cdcc36c..9d5a0cc5 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.collect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectParams — generated data type (RELAY method 'calling.collect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb index 5277f65a..45c9e51d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.collect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectResult — generated data type (RELAY method 'calling.collect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb index 2efb3d74..233e853f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb @@ -10,7 +10,9 @@ # RELAY method 'calling.collect.start_input_timers', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectStartInputTimersParams — generated data type (RELAY method 'calling.collect.start_input_timers', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb index 7132f283..bbdf48d6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb @@ -10,7 +10,9 @@ # RELAY method 'calling.collect.start_input_timers', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectStartInputTimersResult — generated data type (RELAY method 'calling.collect.start_input_timers', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb index 9395ada1..bd402ae4 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.collect.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectStopParams — generated data type (RELAY method 'calling.collect.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb index 69081822..0e25039a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.collect.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingCollectStopResult — generated data type (RELAY method 'calling.collect.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb index 1ba90dbd..76fd726f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.connect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingConnectParams — generated data type (RELAY method 'calling.connect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb index 47bbc61d..46867a7e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.connect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingConnectResult — generated data type (RELAY method 'calling.connect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb index 8830b45e..556e2026 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.denoise', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDenoiseParams — generated data type (RELAY method 'calling.denoise', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb index ac4dd04a..77aeeebd 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.denoise', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDenoiseResult — generated data type (RELAY method 'calling.denoise', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb index ae18c4a9..b7cde6df 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.denoise.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDenoiseStopParams — generated data type (RELAY method 'calling.denoise.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb index c0057dd5..58a2aa54 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.denoise.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDenoiseStopResult — generated data type (RELAY method 'calling.denoise.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb index b9320b7b..6d3f3b0e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.detect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDetectParams — generated data type (RELAY method 'calling.detect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb index 903103a7..13d50184 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.detect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDetectResult — generated data type (RELAY method 'calling.detect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb index f6435f2c..f3854fc9 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.detect.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDetectStopParams — generated data type (RELAY method 'calling.detect.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb index 84f942c4..6287d23f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.detect.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDetectStopResult — generated data type (RELAY method 'calling.detect.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb index e3d57b4d..a638085d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.dial', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDialParams — generated data type (RELAY method 'calling.dial', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb index 743faba3..7055273b 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.dial', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDialResult — generated data type (RELAY method 'calling.dial', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb index 6e68e38c..71ebc6e6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.disconnect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDisconnectParams — generated data type (RELAY method 'calling.disconnect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb index c72203a9..299ff72f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.disconnect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingDisconnectResult — generated data type (RELAY method 'calling.disconnect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb index b2d32dc7..a3551b8f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.echo', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingEchoParams — generated data type (RELAY method 'calling.echo', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb index 291cd9c4..87d9ac0a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.echo', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingEchoResult — generated data type (RELAY method 'calling.echo', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb index 40dcaf79..4bd11d07 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.end', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingEndParams — generated data type (RELAY method 'calling.end', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb index a71e2d05..32d44048 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.end', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingEndResult — generated data type (RELAY method 'calling.end', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb index 2692c932..3fe914a9 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.join_conference', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingJoinConferenceParams — generated data type (RELAY method 'calling.join_conference', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb index f60c2f4b..c95e7839 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.join_conference', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingJoinConferenceResult — generated data type (RELAY method 'calling.join_conference', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb index c3b7c28e..37df1961 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.join_room', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingJoinRoomParams — generated data type (RELAY method 'calling.join_room', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb index df9812bb..9bb5368f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.join_room', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingJoinRoomResult — generated data type (RELAY method 'calling.join_room', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb index f0cebf38..9472a5ea 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.leave_conference', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLeaveConferenceParams — generated data type (RELAY method 'calling.leave_conference', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb index 95c0051a..a8f28e12 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.leave_conference', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLeaveConferenceResult — generated data type (RELAY method 'calling.leave_conference', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb index 288651c8..21296b49 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.leave_room', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLeaveRoomParams — generated data type (RELAY method 'calling.leave_room', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb index e1306f07..8e0da883 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.leave_room', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLeaveRoomResult — generated data type (RELAY method 'calling.leave_room', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb index b7646459..2da636ce 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.live_transcribe', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLiveTranscribeParams — generated data type (RELAY method 'calling.live_transcribe', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb index 60bafd4d..29743c88 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.live_transcribe', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLiveTranscribeResult — generated data type (RELAY method 'calling.live_transcribe', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb index d9bc85b3..9c9f84f1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.live_translate', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLiveTranslateParams — generated data type (RELAY method 'calling.live_translate', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb index 68e31a57..7d8f0a84 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.live_translate', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingLiveTranslateResult — generated data type (RELAY method 'calling.live_translate', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb index 6dc2db18..8751e566 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pass', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPassParams — generated data type (RELAY method 'calling.pass', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb index 0eeaa43f..e3a4fef8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pass', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPassResult — generated data type (RELAY method 'calling.pass', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb index f3b9e741..67fbd81c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pay', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPayParams — generated data type (RELAY method 'calling.pay', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb index a3962f84..51dabe1e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pay', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPayResult — generated data type (RELAY method 'calling.pay', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb index 4ca37670..a78d08f2 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pay.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPayStopParams — generated data type (RELAY method 'calling.pay.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb index cd318e6c..ad325754 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.pay.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPayStopResult — generated data type (RELAY method 'calling.pay.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb index 08e91774..4246077b 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play_and_collect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectParams — generated data type (RELAY method 'calling.play_and_collect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb index f5618f8b..066a56c9 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play_and_collect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectResult — generated data type (RELAY method 'calling.play_and_collect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb index 9a9596ea..5e650a5d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play_and_collect.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectStopParams — generated data type (RELAY method 'calling.play_and_collect.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb index 363b7346..9e9c4ff0 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play_and_collect.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectStopResult — generated data type (RELAY method 'calling.play_and_collect.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb index 070d57e2..45c84f11 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb @@ -10,7 +10,9 @@ # RELAY method 'calling.play_and_collect.volume', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectVolumeParams — generated data type (RELAY method 'calling.play_and_collect.volume', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb index bf2e86c6..66094839 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb @@ -10,7 +10,9 @@ # RELAY method 'calling.play_and_collect.volume', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayAndCollectVolumeResult — generated data type (RELAY method 'calling.play_and_collect.volume', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb index e8df049b..96d1b88a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayParams — generated data type (RELAY method 'calling.play', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb index 05680c45..494b656a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.pause', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayPauseParams — generated data type (RELAY method 'calling.play.pause', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb index a81a02d3..cec8489a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.pause', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayPauseResult — generated data type (RELAY method 'calling.play.pause', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb index d025f1af..92a0f7de 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayResult — generated data type (RELAY method 'calling.play', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb index 42194c46..485b410a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.resume', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayResumeParams — generated data type (RELAY method 'calling.play.resume', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb index ad2ef262..f8f5de1b 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.resume', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayResumeResult — generated data type (RELAY method 'calling.play.resume', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb index 9b08a572..4d505229 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayStopParams — generated data type (RELAY method 'calling.play.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb index 3e8eca2f..7d52bfbb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayStopResult — generated data type (RELAY method 'calling.play.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb index dda0e2d2..a027a93e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.volume', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayVolumeParams — generated data type (RELAY method 'calling.play.volume', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb index 70d36ad3..178c97a6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.play.volume', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingPlayVolumeResult — generated data type (RELAY method 'calling.play.volume', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb index 941386f4..2f7a8d07 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.queue.enter', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingQueueEnterParams — generated data type (RELAY method 'calling.queue.enter', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb index 2c2cc5da..df8008b6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.queue.enter', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingQueueEnterResult — generated data type (RELAY method 'calling.queue.enter', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb index 598380f1..739dd5e5 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.queue.leave', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingQueueLeaveParams — generated data type (RELAY method 'calling.queue.leave', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb index f59aa105..8b3fe2b8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.queue.leave', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingQueueLeaveResult — generated data type (RELAY method 'calling.queue.leave', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb index 4b429678..d3f3e862 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive_fax', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveFaxParams — generated data type (RELAY method 'calling.receive_fax', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb index eb8807a6..8e0069a5 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive_fax', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveFaxResult — generated data type (RELAY method 'calling.receive_fax', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb index a4d9f735..8a0e5f2e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive_fax.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveFaxStopParams — generated data type (RELAY method 'calling.receive_fax.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb index 6c61834c..7776f7d4 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive_fax.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveFaxStopResult — generated data type (RELAY method 'calling.receive_fax.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb index 238cb217..b96b8239 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveParams — generated data type (RELAY method 'calling.receive', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb index c71cf025..d34d6187 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.receive', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReceiveResult — generated data type (RELAY method 'calling.receive', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb index 37d11db5..2c5a0358 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordParams — generated data type (RELAY method 'calling.record', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb index 4e3ab5da..6657b20d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.pause', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordPauseParams — generated data type (RELAY method 'calling.record.pause', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb index 0f3a8083..b5411eb3 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.pause', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordPauseResult — generated data type (RELAY method 'calling.record.pause', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb index 1d1c7ede..256e014e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordResult — generated data type (RELAY method 'calling.record', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb index d103241c..e5179e7d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.resume', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordResumeParams — generated data type (RELAY method 'calling.record.resume', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb index 9256eb90..60ae3254 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.resume', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordResumeResult — generated data type (RELAY method 'calling.record.resume', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb index b66f029b..8d786cf3 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordStopParams — generated data type (RELAY method 'calling.record.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb index 552221dc..375f8f8a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.record.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingRecordStopResult — generated data type (RELAY method 'calling.record.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb index 391a620d..bcf164ab 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.refer', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReferParams — generated data type (RELAY method 'calling.refer', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb index cb36495b..466e19fc 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.refer', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingReferResult — generated data type (RELAY method 'calling.refer', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb index 1cd63015..c9774cc8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_digits', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendDigitsParams — generated data type (RELAY method 'calling.send_digits', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb index 9da938de..93dff018 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_digits', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendDigitsResult — generated data type (RELAY method 'calling.send_digits', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb index 3ec49b15..14b3401d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_fax', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendFaxParams — generated data type (RELAY method 'calling.send_fax', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb index 865a9c11..a217a3d8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_fax', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendFaxResult — generated data type (RELAY method 'calling.send_fax', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb index 4fe03a80..6773ed2d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_fax.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendFaxStopParams — generated data type (RELAY method 'calling.send_fax.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb index cc4c4421..4efbcdd6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.send_fax.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingSendFaxStopResult — generated data type (RELAY method 'calling.send_fax.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb index 0f4cfff6..77bf14c1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.stream', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingStreamParams — generated data type (RELAY method 'calling.stream', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb index 1f612bb6..e66c374c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.stream', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingStreamResult — generated data type (RELAY method 'calling.stream', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb index d2f165b6..1a767cc3 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.stream.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingStreamStopParams — generated data type (RELAY method 'calling.stream.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb index 63fed8e5..a197562e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.stream.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingStreamStopResult — generated data type (RELAY method 'calling.stream.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb index 8bc613d4..a860d8c7 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.tap', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTapParams — generated data type (RELAY method 'calling.tap', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb index 359d4a9b..ef69b9ce 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.tap', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTapResult — generated data type (RELAY method 'calling.tap', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb index 4ac1f87e..8c2c6fdf 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.tap.stop', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTapStopParams — generated data type (RELAY method 'calling.tap.stop', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb index befe047d..9abb33fa 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.tap.stop', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTapStopResult — generated data type (RELAY method 'calling.tap.stop', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb index 330d15a5..8c972201 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.transfer', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTransferParams — generated data type (RELAY method 'calling.transfer', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb index db3b7ec9..a525304d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.transfer', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingTransferResult — generated data type (RELAY method 'calling.transfer', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb index 57153a69..0a17a0e8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.user_event', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingUserEventParams — generated data type (RELAY method 'calling.user_event', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb index d82a11ae..686add29 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb @@ -9,7 +9,9 @@ # RELAY method 'calling.user_event', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # CallingUserEventResult — generated data type (RELAY method 'calling.user_event', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb b/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb index 08edf0e1..3e0926e0 100644 --- a/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb @@ -9,7 +9,9 @@ # RELAY method 'messaging.send', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # MessagingSendParams — generated data type (RELAY method 'messaging.send', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb b/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb index c183e0be..9af6aec0 100644 --- a/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb @@ -9,7 +9,9 @@ # RELAY method 'messaging.send', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # MessagingSendResult — generated data type (RELAY method 'messaging.send', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb index e78e48de..fee3b2fe 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.connect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireConnectParams — generated data type (RELAY method 'signalwire.connect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb index fac1364a..78b8a4e7 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.connect', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireConnectResult — generated data type (RELAY method 'signalwire.connect', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb index 466f4f81..779c3db7 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.disconnect', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireDisconnectParams — generated data type (RELAY method 'signalwire.disconnect', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb index 2ae20eaa..93134d8f 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.execute', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireExecuteParams — generated data type (RELAY method 'signalwire.execute', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb index 6b0640a2..1effd423 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.execute', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireExecuteResult — generated data type (RELAY method 'signalwire.execute', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb index e9b258eb..eb9844a8 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.ping', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwirePingParams — generated data type (RELAY method 'signalwire.ping', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb index c0e63570..e864ebdb 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.ping', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwirePingResult — generated data type (RELAY method 'signalwire.ping', result). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb index 0de417f8..62e3e547 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.reauthenticate', params module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireReauthenticateParams — generated data type (RELAY method 'signalwire.reauthenticate', params). # diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb index 768cf0fc..92351bfd 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb @@ -9,7 +9,9 @@ # RELAY method 'signalwire.reauthenticate', result module SignalWire + # SignalWire::Relay — namespace for this generated data-class tree. module Relay + # SignalWire::Relay::ProtocolTypesGenerated — namespace for this generated data-class tree. module ProtocolTypesGenerated # SignalwireReauthenticateResult — generated data type (RELAY method 'signalwire.reauthenticate', result). # diff --git a/scripts/generate_rest.py b/scripts/generate_rest.py index 29dab955..f744f48e 100644 --- a/scripts/generate_rest.py +++ b/scripts/generate_rest.py @@ -1631,7 +1631,12 @@ def emit_methodless_class(module_segments: list, rb_name: str, properties: dict, port-side state accessors (zero-arg, ``any`` return).""" indent = "" lines: list[str] = [] - for seg in module_segments: + for depth, seg in enumerate(module_segments): + # Every module segment carries a doc comment: this file's namespace nesting is + # public surface and the DOC-SURFACE gate reads the nearest preceding comment. + if depth: + lines.append(f"{indent}# {'::'.join(module_segments[:depth + 1])} — " + f"namespace for this generated data-class tree.") lines.append(f"{indent}module {seg}") indent += " " kind = "data type" if not emit_readers else "read-side payload" From 859c8637aa86a0245a72a76b77b423079217a7cc Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:43:49 -0400 Subject: [PATCH 29/90] docs(relay,contexts): document relay_event.rb + context_builder.rb relay_event.rb (73 decls): every typed event's from_payload decoder, initialize kwargs and private event_fields hook, naming the RELAY event each class decodes and the wire keys behind the renamed accessors (DialEvent's `call` -> #call_data, QueueEvent's `id`/`name` -> #queue_id/#queue_name, RecordEvent's nested `record` fallback). context_builder.rb (48 decls): the Step / Context setters, the to_h wire serializers, and the validation passes, stating what each field means to the runtime and what each validator rejects. DOC-SURFACE ruby: 70.3% -> 73.9% (2487/3366). --- lib/signalwire/contexts/context_builder.rb | 230 +++++++++++++++ lib/signalwire/relay/relay_event.rb | 327 +++++++++++++++++++++ 2 files changed, 557 insertions(+) diff --git a/lib/signalwire/contexts/context_builder.rb b/lib/signalwire/contexts/context_builder.rb index a1fdf9e1..8c03cefa 100644 --- a/lib/signalwire/contexts/context_builder.rb +++ b/lib/signalwire/contexts/context_builder.rb @@ -6,6 +6,7 @@ # See LICENSE file in the project root for full license information. module SignalWire + # Contexts — the multi-step / multi-context AI workflow builder surface. module Contexts MAX_CONTEXTS = 50 MAX_STEPS_PER_CONTEXT = 100 @@ -86,6 +87,12 @@ def initialize(key:, question:, type: 'string', confirm: false, prompt: nil, @isolated = isolated end + # Serialize this question to its wire shape. `key` and `question` are always + # present; the optional fields are emitted only when they differ from the + # runtime default, except `isolated`, which is emitted whenever it is set + # (including `false`) so a question can override an isolated gather. + # + # @return [Hash{String => Object}] def to_h h = { 'key' => @key, 'question' => @question } h['type'] = @type if @type != 'string' @@ -129,6 +136,13 @@ def add_question(key:, question:, **opts) self end + # Serialize this gather to its wire shape: the `questions` array plus any + # of `prompt` / `output_key` / `completion_action` that were set, and + # `isolated` only when true. + # + # @return [Hash{String => Object}] + # @raise [ArgumentError] if no question has been added — the runtime + # rejects an empty gather def to_h raise ArgumentError, 'gather_info must have at least one question' if @questions.empty? @@ -147,6 +161,11 @@ def to_h class Step attr_reader :name + # Create an empty step. Every field starts unset; use the `set_*` mutators + # (or the matching `x=` writers) to configure it. + # + # @param name [String] the step's name — how `valid_steps`, `initial_step` + # and a gather's `completion_action` refer to it def initialize(name) @name = name @text = @step_criteria = @valid_steps = @valid_contexts = @gather_info = nil @@ -187,6 +206,11 @@ def add_bullets(title, bullets) self end + # Set the natural-language condition the model must satisfy before it may + # advance out of this step. Emitted as the step's `step_criteria`. + # + # @param criteria [String] the completion condition, e.g. "User has provided their account number" + # @return [Step] self, for chaining def set_step_criteria(criteria) @step_criteria = criteria self @@ -228,11 +252,24 @@ def set_functions(functions) self end + # Set which steps the model may navigate to from this step. Declaring this + # makes the runtime inject the native `next_step` tool with these names as + # its enum. The literal `"next"` is accepted and means the next step in + # declaration order. + # + # @param steps [Array] step names within this context + # @return [Step] self, for chaining def set_valid_steps(steps) @valid_steps = steps self end + # Set which contexts the model may switch to from this step. Declaring this + # makes the runtime inject the native `change_context` tool with these names + # as its enum. Overrides the enclosing context's `valid_contexts`. + # + # @param contexts [Array] context names known to the builder + # @return [Step] self, for chaining def set_valid_contexts(contexts) @valid_contexts = contexts self @@ -255,11 +292,23 @@ def set_end(is_end) self end + # Skip waiting for the user to speak when this step is entered — the model + # produces its turn immediately instead of listening first. Use it for a + # step whose whole job is to say something. + # + # @param skip [Boolean] + # @return [Step] self, for chaining def set_skip_user_turn(skip) @skip_user_turn = skip self end + # Advance out of this step without a model turn at all: the step's + # instructions are applied and the runtime immediately moves to the next + # step. Use it for a step that only mutates state. + # + # @param skip [Boolean] + # @return [Step] self, for chaining def set_skip_to_next_step(skip) @skip_to_next_step = skip self @@ -348,26 +397,52 @@ def clear_sections self end + # Set the `system_prompt` of this step's `reset` object, replacing the + # system prompt when the reset fires. + # + # @param prompt [String] + # @return [Step] self, for chaining def set_reset_system_prompt(prompt) @reset_system_prompt = prompt self end + # Set the `user_prompt` of this step's `reset` object — the message injected + # as the user turn when the reset fires. + # + # @param prompt [String] + # @return [Step] self, for chaining def set_reset_user_prompt(prompt) @reset_user_prompt = prompt self end + # When true, the reset summarizes the prior conversation into a single + # message instead of dropping it. Emitted as `reset.consolidate`. + # + # @param val [Boolean] + # @return [Step] self, for chaining def set_reset_consolidate(val) @reset_consolidate = val self end + # When true, the reset discards the prior conversation outright rather than + # consolidating it. Emitted as `reset.full_reset`. + # + # @param val [Boolean] + # @return [Step] self, for chaining def set_reset_full_reset(val) @reset_full_reset = val self end + # Serialize this step to its wire shape: `name` and the rendered `text`, + # plus whichever of the navigation/behavior fields were set, a `reset` + # object when any reset field is set, and `gather_info` when configured. + # + # @return [Hash{String => Object}] + # @raise [ArgumentError] if the step has neither text nor POM sections def to_h step_h = { 'name' => @name, 'text' => render_text } add_step_fields(step_h) @@ -378,6 +453,8 @@ def to_h step_h end + # @api private — add the criteria/functions/navigation/history fields to the + # step hash, each only when set, then delegate to {#add_step_flags}. def add_step_fields(step_h) step_h['step_criteria'] = @step_criteria if @step_criteria step_h['functions'] = @functions unless @functions.nil? @@ -388,6 +465,8 @@ def add_step_fields(step_h) end private :add_step_fields + # @api private — add the boolean behavior flags to the step hash. Each is + # emitted only when true; the runtime treats absence as false. def add_step_flags(step_h) step_h['end'] = true if @end step_h['skip_user_turn'] = true if @skip_user_turn @@ -395,6 +474,9 @@ def add_step_flags(step_h) end private :add_step_flags + # @api private — build the step's `reset` object from the four reset fields, + # each included only when set. An empty Hash means "no reset" and the caller + # omits the key entirely. def reset_hash reset = {} reset['system_prompt'] = @reset_system_prompt if @reset_system_prompt @@ -423,6 +505,10 @@ def reset_hash private + # @api private — the step's prompt text: the literal `set_text` value when + # one was given, otherwise the POM sections rendered to markdown. + # + # @raise [ArgumentError] if neither was supplied def render_text return @text if @text @@ -536,21 +622,42 @@ def set_initial_step(step_name) self end + # Set the default list of contexts the model may switch to from any step in + # this context. A step's own {Step#set_valid_contexts} overrides it. + # + # @param contexts [Array] context names known to the builder + # @return [Context] self, for chaining def set_valid_contexts(contexts) @valid_contexts = contexts self end + # Set the default list of steps the model may navigate to from any step in + # this context. A step's own {Step#set_valid_steps} overrides it. + # + # @param steps [Array] step names within this context + # @return [Context] self, for chaining def set_valid_steps(steps) @valid_steps = steps self end + # Set the post-prompt run after the conversation ends while this context is + # active — typically the summarization instruction. + # + # @param prompt [String] + # @return [Context] self, for chaining def set_post_prompt(prompt) @post_prompt = prompt self end + # Set the system prompt applied while this context is active, replacing the + # agent's base system prompt. Mutually exclusive with POM system sections. + # + # @param prompt [String] + # @return [Context] self, for chaining + # @raise [ArgumentError] if {#add_system_section} / {#add_system_bullets} was already used def set_system_prompt(prompt) if @system_prompt_sections.any? raise ArgumentError, @@ -561,6 +668,12 @@ def set_system_prompt(prompt) self end + # Set this context's prompt text directly. Mutually exclusive with the POM + # prompt sections added via {#add_section} / {#add_bullets}. + # + # @param prompt [String] + # @return [Context] self, for chaining + # @raise [ArgumentError] if POM prompt sections were already added def set_prompt(prompt) raise ArgumentError, 'Cannot use set_prompt when POM prompt sections exist' if @prompt_sections.any? @@ -568,16 +681,32 @@ def set_prompt(prompt) self end + # When true, entering this context summarizes the prior conversation into a + # single message rather than carrying it verbatim. Takes precedence over + # {#set_isolated}'s wipe. + # + # @param val [Boolean] + # @return [Context] self, for chaining def set_consolidate(val) @consolidate = val self end + # When true, entering this context discards the prior conversation outright. + # Takes precedence over {#set_isolated}'s wipe. + # + # @param val [Boolean] + # @return [Context] self, for chaining def set_full_reset(val) @full_reset = val self end + # Set the message injected as the user turn when this context is entered + # with a reset. Emitted as the context's `user_prompt`. + # + # @param prompt [String] + # @return [Context] self, for chaining def set_user_prompt(prompt) @user_prompt = prompt self @@ -656,16 +785,35 @@ def add_system_bullets(title, bullets) self end + # Replace the map of language code to filler phrases spoken while entering + # this context. A non-Hash or empty Hash is ignored, leaving the current + # value in place. + # + # @param fillers [Hash{String => Array}] language code (e.g. "en-US") to phrases + # @return [Context] self, for chaining def set_enter_fillers(fillers) @enter_fillers = fillers if fillers.is_a?(Hash) && fillers.any? self end + # Replace the map of language code to filler phrases spoken while leaving + # this context. A non-Hash or empty Hash is ignored, leaving the current + # value in place. + # + # @param fillers [Hash{String => Array}] language code (e.g. "en-US") to phrases + # @return [Context] self, for chaining def set_exit_fillers(fillers) @exit_fillers = fillers if fillers.is_a?(Hash) && fillers.any? self end + # Add or replace the enter fillers for a single language, keeping any other + # languages already configured. A blank code or a non-Array / empty phrase + # list is ignored. + # + # @param lang_code [String] e.g. "en-US" + # @param fillers [Array] phrases spoken while entering this context + # @return [Context] self, for chaining def add_enter_filler(lang_code, fillers) if lang_code && fillers.is_a?(Array) && fillers.any? @enter_fillers = {} unless defined?(@enter_fillers) && @enter_fillers @@ -674,6 +822,13 @@ def add_enter_filler(lang_code, fillers) self end + # Add or replace the exit fillers for a single language, keeping any other + # languages already configured. A blank code or a non-Array / empty phrase + # list is ignored. + # + # @param lang_code [String] e.g. "en-US" + # @param fillers [Array] phrases spoken while leaving this context + # @return [Context] self, for chaining def add_exit_filler(lang_code, fillers) if lang_code && fillers.is_a?(Array) && fillers.any? @exit_fillers = {} unless defined?(@exit_fillers) && @exit_fillers @@ -682,6 +837,12 @@ def add_exit_filler(lang_code, fillers) self end + # Serialize this context to its wire shape: the `steps` array in declaration + # order, plus the navigation, reset, prompt, filler and history fields that + # were set. + # + # @return [Hash{String => Object}] + # @raise [ArgumentError] if the context has no steps def to_h raise ArgumentError, "Context '#{@name}' has no steps defined" if @steps.empty? @@ -719,6 +880,9 @@ def _initial_step = @initial_step private + # @api private — the context's system prompt: the literal `set_system_prompt` + # value when one was given, otherwise the POM system sections rendered to + # markdown, or nil when neither was supplied. def render_system_prompt return @system_prompt if @system_prompt return nil if @system_prompt_sections.empty? @@ -726,6 +890,9 @@ def render_system_prompt Contexts._render_pom_sections(@system_prompt_sections) end + # @api private — add the navigation fields (`valid_contexts`, `valid_steps`, + # `initial_step`, `post_prompt`, `system_prompt`) to the context hash, each + # only when set. def add_navigation(ctx) ctx['valid_contexts'] = @valid_contexts if @valid_contexts ctx['valid_steps'] = @valid_steps if @valid_steps @@ -735,6 +902,8 @@ def add_navigation(ctx) ctx['system_prompt'] = sys if sys end + # @api private — add the entry/reset fields (`consolidate`, `full_reset`, + # `user_prompt`, `isolated`) to the context hash, each only when set. def add_reset_flags(ctx) ctx['consolidate'] = @consolidate if @consolidate ctx['full_reset'] = @full_reset if @full_reset @@ -742,6 +911,9 @@ def add_reset_flags(ctx) ctx['isolated'] = @isolated if @isolated end + # @api private — add the context prompt: POM sections under `pom` when any + # were added, else the literal text under `prompt`. Neither key is emitted + # when the context has no prompt of its own. def add_prompt(ctx) if @prompt_sections.any? ctx['pom'] = @prompt_sections @@ -878,6 +1050,10 @@ def validate_single_context_name raise ArgumentError, "When using a single context, it must be named 'default'" end + # Every context must declare at least one step — a context with none would + # render an empty flow the runtime cannot enter. + # + # @raise [ArgumentError] naming the offending context def validate_steps_present @contexts.each do |ctx_name, ctx| raise ArgumentError, "Context '#{ctx_name}' must have at least one step" if ctx._steps.empty? @@ -897,6 +1073,11 @@ def validate_initial_steps end end + # Every name in a step's `valid_steps` must resolve to a real step in the + # same context (or the literal `"next"`), so the injected `next_step` enum + # never offers a destination that does not exist. + # + # @raise [ArgumentError] naming the step and the unresolved reference def validate_valid_steps_refs @contexts.each do |ctx_name, ctx| ctx._steps.each do |step_name, step| @@ -908,6 +1089,10 @@ def validate_valid_steps_refs end end + # @api private — one `valid_steps` entry. `"next"` is the literal + # advance-to-the-following-step token and always resolves. + # + # @raise [ArgumentError] if +ref+ is neither "next" nor a step in +ctx+ def check_step_ref(ctx, ctx_name, step_name, ref) return if ref == 'next' || ctx._steps.key?(ref) @@ -937,6 +1122,11 @@ def validate_step_function_refs end end + # @api private — one `set_functions` whitelist entry, checked against the + # known tool universe. + # + # @param known [Set] registered SWAIG tool names plus the reserved native ones + # @raise [ArgumentError] if +func+ is not in +known+, listing the available names def check_step_function_ref(known, ctx_name, step_name, func) return if known.include?(func) @@ -948,6 +1138,11 @@ def check_step_function_ref(known, ctx_name, step_name, func) "skill) or remove it from the step. Available: #{known.to_a.sort.inspect}" end + # Every name in a context's `valid_contexts` must resolve to a context the + # builder owns, so the injected `change_context` enum never offers a + # destination that does not exist. + # + # @raise [ArgumentError] naming the context and the unresolved reference def validate_context_level_refs @contexts.each do |ctx_name, ctx| valid = ctx.to_h['valid_contexts'] @@ -961,6 +1156,11 @@ def validate_context_level_refs end end + # Every name in a step's `valid_contexts` must resolve to a context the + # builder owns — the step-level override is checked the same way as the + # context-level list. + # + # @raise [ArgumentError] naming the step and the unresolved reference def validate_step_level_context_refs @contexts.each do |ctx_name, ctx| ctx._steps.each do |step_name, step| @@ -972,6 +1172,10 @@ def validate_step_level_context_refs end end + # @api private — one `valid_contexts` entry, from either the context or the + # step level. + # + # @raise [ArgumentError] if +ref+ is not a context the builder owns def check_context_ref(ctx_name, step_name, ref) return if @contexts.key?(ref) @@ -985,6 +1189,10 @@ def check_context_ref(ctx_name, step_name, ref) module GatherInfoValidation private + # Check every step's gather_info: its questions are well-formed and its + # completion action resolves. Steps without a gather are skipped. + # + # @raise [ArgumentError] on the first problem found def validate_gather_infos @contexts.each do |ctx_name, ctx| ctx._steps.each do |step_name, step| @@ -997,6 +1205,11 @@ def validate_gather_infos end end + # @api private — a gather must ask at least one question, and its keys must + # be unique (a duplicate key would silently overwrite the earlier answer in + # the output object). + # + # @raise [ArgumentError] naming the step and context def validate_gather_questions(gather, ctx_name, step_name) questions = gather['questions'] || [] if questions.empty? @@ -1007,6 +1220,10 @@ def validate_gather_questions(gather, ctx_name, step_name) check_duplicate_keys(questions, ctx_name, step_name) end + # @api private — reject a repeated `key` across a gather's questions; the + # answers are collected into one object, so a duplicate key loses data. + # + # @raise [ArgumentError] naming the duplicated key def check_duplicate_keys(questions, ctx_name, step_name) keys_seen = Set.new questions.each do |q| @@ -1019,6 +1236,11 @@ def check_duplicate_keys(questions, ctx_name, step_name) end end + # @api private — a gather's `completion_action` must be either the literal + # `"next_step"` or the name of a step in the same context. nil (stay put) is + # the default and needs no check. + # + # @raise [ArgumentError] via {#validate_next_step_action} or {#raise_unknown_completion_action} def validate_gather_completion(gather, ctx, ctx_name, step_name) action = gather['completion_action'] return unless action @@ -1030,6 +1252,10 @@ def validate_gather_completion(gather, ctx, ctx_name, step_name) end end + # @api private — `completion_action="next_step"` needs a following step to + # advance to, so it is invalid on the last step of a context. + # + # @raise [ArgumentError] spelling out the three ways to fix it def validate_next_step_action(ctx, ctx_name, step_name) idx = ctx._step_order.index(step_name) return if idx < ctx._step_order.size - 1 @@ -1043,6 +1269,10 @@ def validate_next_step_action(ctx, ctx_name, step_name) "(default) to stay in '#{step_name}' after gathering completes." end + # @api private — raise for a `completion_action` that names neither + # `"next_step"` nor an existing step, listing the valid options. + # + # @raise [ArgumentError] always def raise_unknown_completion_action(ctx, ctx_name, step_name, action) available = ctx._steps.keys.sort raise ArgumentError, diff --git a/lib/signalwire/relay/relay_event.rb b/lib/signalwire/relay/relay_event.rb index 7b5108ae..fbe5e6f1 100644 --- a/lib/signalwire/relay/relay_event.rb +++ b/lib/signalwire/relay/relay_event.rb @@ -3,7 +3,9 @@ require 'json' require_relative 'constants' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # Base event wrapper for raw signalwire.event payloads. # Subclasses provide typed accessors for specific event types. @@ -30,6 +32,13 @@ module Relay class RelayEvent attr_reader :event_type, :params, :call_id, :timestamp + # Build an event from already-decoded envelope fields. Subclasses forward + # these through +**base+ after decoding their own typed fields. + # + # @param event_type [String] the RELAY `event_type` string, e.g. `"calling.call.state"` + # @param params [Hash] the raw `params` map from the wire frame, kept verbatim + # @param call_id [String] the call this event belongs to (`params['call_id']`), '' when absent + # @param timestamp [Float] the server-side event time (`params['timestamp']`), 0.0 when absent def initialize(event_type:, params: {}, call_id: '', timestamp: 0.0) @event_type = event_type @params = params @@ -37,6 +46,12 @@ def initialize(event_type:, params: {}, call_id: '', timestamp: 0.0) @timestamp = timestamp end + # Decode a raw `signalwire.event` payload into a bare {RelayEvent}, reading + # `event_type` from the frame and `call_id`/`timestamp` out of its `params`. + # Absent fields fall back to the empty/zero default rather than nil. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [RelayEvent] def self.from_payload(payload) et = payload['event_type'] || '' p = payload['params'] || {} @@ -153,6 +168,12 @@ def event_fields class CallStateEvent < RelayEvent attr_reader :call_state, :end_reason, :direction, :device + # Decode a `calling.call.state` frame into a {CallStateEvent}, reading the call state, end reason, direction and + # device + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [CallStateEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -165,6 +186,11 @@ def self.from_payload(payload) ) end + # @param call_state [String] the new call state (see {CallState}); '' when absent + # @param end_reason [String] why the call ended, set on the terminal transition; '' otherwise + # @param direction [String] `"inbound"` or `"outbound"` as reported by the server + # @param device [Hash] the raw device descriptor (`type` plus its per-type params) + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(call_state: '', end_reason: '', direction: '', device: {}, **base) super(**base) @call_state = call_state @@ -184,6 +210,9 @@ def terminal? private + # The `calling.call.state` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { call_state: @call_state, end_reason: @end_reason, direction: @direction, device: @device } @@ -200,6 +229,12 @@ class CallReceiveEvent < RelayEvent project_id: '', segment_id: '', tag: '' }.freeze + # Decode a `calling.call.receive` frame into a {CallReceiveEvent}, reading the call state, direction, device and + # routing identifiers + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [CallReceiveEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -207,6 +242,16 @@ def self.from_payload(payload) context: _fetch(p, 'context', _fetch(p, 'protocol', ''))) end + # @param call_state [String] the state the inbound call arrived in (see {CallState}) + # @param direction [String] `"inbound"` or `"outbound"` + # @param device [Hash] the raw device descriptor for the leg + # @param node_id [String] the RELAY node that owns this call; needed to address it + # @param project_id [String] the SignalWire project the call belongs to + # @param context [String] the context the call was received on — decoded from + # `params['context']`, falling back to the legacy `params['protocol']` key + # @param segment_id [String] the call-segment identifier + # @param tag [String] the caller-supplied correlation tag, when one was set + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(call_state: '', direction: '', device: {}, node_id: '', project_id: '', context: '', segment_id: '', tag: '', **base) super(**base) @@ -222,6 +267,9 @@ def initialize(call_state: '', direction: '', device: {}, node_id: '', private + # The `calling.call.receive` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { call_state: @call_state, direction: @direction, device: @device, node_id: @node_id, project_id: @project_id, context: @context, @@ -233,6 +281,11 @@ def event_fields class PlayEvent < RelayEvent attr_reader :control_id, :state + # Decode a `calling.call.play` frame into a {PlayEvent}, reading the playback control id and state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [PlayEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -243,6 +296,9 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the playback this event reports on + # @param state [String] the playback state, e.g. `"playing"` / `"finished"` + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', **base) super(**base) @control_id = control_id @@ -251,6 +307,9 @@ def initialize(control_id: '', state: '', **base) private + # The `calling.call.play` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state } end @@ -260,6 +319,13 @@ def event_fields class RecordEvent < RelayEvent attr_reader :control_id, :state, :url, :duration, :size, :record + # Decode a `calling.call.record` frame into a {RecordEvent}. The recording's + # `url`, `duration` and `size` are read from the nested `params['record']` + # object when present, falling back to the same keys at the top level (the + # server has emitted both shapes). + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [RecordEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -273,6 +339,13 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the recording this event reports on + # @param state [String] the recording state, e.g. `"recording"` / `"finished"` + # @param url [String] where the finished recording can be fetched + # @param duration [Float] recording length in seconds + # @param size [Integer] recording size in bytes + # @param record [Hash] the raw nested `record` object, kept verbatim + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', url: '', duration: 0.0, size: 0, record: {}, **base) super(**base) @control_id = control_id @@ -285,6 +358,9 @@ def initialize(control_id: '', state: '', url: '', duration: 0.0, size: 0, recor private + # The `calling.call.record` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state, url: @url, duration: @duration, size: @size, record: @record } @@ -296,6 +372,11 @@ class CollectEvent < RelayEvent # The decoded field is +result+ (formerly +result_data+). attr_reader :control_id, :state, :result, :final + # Decode a `calling.call.collect` frame into a {CollectEvent}, reading the collect control id, state and result + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [CollectEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -308,6 +389,12 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the collect this event reports on + # @param state [String] the collect state, e.g. `"collecting"` / `"finished"` + # @param result [Hash] the collected result object (type plus its digits/speech payload) + # @param final [Boolean, nil] whether this is the last result for the collect; + # nil when the server did not send the field + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', result: {}, final: nil, **base) super(**base) @control_id = control_id @@ -318,6 +405,9 @@ def initialize(control_id: '', state: '', result: {}, final: nil, **base) private + # The `calling.call.collect` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state, result: @result, final: @final } @@ -328,6 +418,11 @@ def event_fields class ConnectEvent < RelayEvent attr_reader :connect_state, :peer + # Decode a `calling.call.connect` frame into a {ConnectEvent}, reading the connect state and peer descriptor + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [ConnectEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -338,6 +433,9 @@ def self.from_payload(payload) ) end + # @param connect_state [String] the connect state, e.g. `"connecting"` / `"connected"` / `"failed"` + # @param peer [Hash] the raw peer descriptor (the far leg's call/node identifiers) + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(connect_state: '', peer: {}, **base) super(**base) @connect_state = connect_state @@ -346,6 +444,9 @@ def initialize(connect_state: '', peer: {}, **base) private + # The `calling.call.connect` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { connect_state: @connect_state, peer: @peer } end @@ -355,6 +456,11 @@ def event_fields class DetectEvent < RelayEvent attr_reader :control_id, :detect + # Decode a `calling.call.detect` frame into a {DetectEvent}, reading the detect control id and detector result + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [DetectEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -365,6 +471,9 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the detect this event reports on + # @param detect [Hash] the raw detector result (`type` plus its per-detector params) + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', detect: {}, **base) super(**base) @control_id = control_id @@ -373,6 +482,9 @@ def initialize(control_id: '', detect: {}, **base) private + # The `calling.call.detect` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, detect: @detect } end @@ -382,6 +494,11 @@ def event_fields class FaxEvent < RelayEvent attr_reader :control_id, :fax + # Decode a `calling.call.fax` frame into a {FaxEvent}, reading the fax control id and fax result + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [FaxEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -392,6 +509,9 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the fax this event reports on + # @param fax [Hash] the raw fax result object (direction, pages, identity, document) + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', fax: {}, **base) super(**base) @control_id = control_id @@ -400,6 +520,9 @@ def initialize(control_id: '', fax: {}, **base) private + # The `calling.call.fax` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, fax: @fax } end @@ -409,6 +532,12 @@ def event_fields class TapEvent < RelayEvent attr_reader :control_id, :state, :tap, :device + # Decode a `calling.call.tap` frame into a {TapEvent}, reading the tap control id, state, tap and device + # descriptors + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [TapEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -421,6 +550,11 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the tap this event reports on + # @param state [String] the tap state, e.g. `"tapping"` / `"finished"` + # @param tap [Hash] the raw tap descriptor (what media is being tapped and how) + # @param device [Hash] the raw destination device the tapped media is sent to + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', tap: {}, device: {}, **base) super(**base) @control_id = control_id @@ -431,6 +565,9 @@ def initialize(control_id: '', state: '', tap: {}, device: {}, **base) private + # The `calling.call.tap` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state, tap: @tap, device: @device } end @@ -440,6 +577,11 @@ def event_fields class StreamEvent < RelayEvent attr_reader :control_id, :state, :url, :name + # Decode a `calling.call.stream` frame into a {StreamEvent}, reading the stream control id, state, url and name + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [StreamEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -452,6 +594,11 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the stream this event reports on + # @param state [String] the stream state, e.g. `"streaming"` / `"finished"` + # @param url [String] the stream destination URL + # @param name [String] the caller-supplied stream name, when one was set + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', url: '', name: '', **base) super(**base) @control_id = control_id @@ -462,6 +609,9 @@ def initialize(control_id: '', state: '', url: '', name: '', **base) private + # The `calling.call.stream` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state, url: @url, name: @name } end @@ -471,6 +621,11 @@ def event_fields class SendDigitsEvent < RelayEvent attr_reader :control_id, :state + # Decode a `calling.call.send_digits` frame into a {SendDigitsEvent}, reading the send-digits control id and state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [SendDigitsEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -481,6 +636,9 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the send-digits operation this event reports on + # @param state [String] the send-digits state, e.g. `"finished"` + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', **base) super(**base) @control_id = control_id @@ -489,6 +647,9 @@ def initialize(control_id: '', state: '', **base) private + # The `calling.call.send_digits` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state } end @@ -498,6 +659,12 @@ def event_fields class DialEvent < RelayEvent attr_reader :tag, :dial_state, :call_data + # Decode a `calling.call.dial` frame into a {DialEvent}. The dialed call's + # descriptor arrives under the wire key `call` and is exposed as {#call_data} + # (`call` would shadow nothing useful and reads ambiguously in Ruby). + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [DialEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -509,6 +676,11 @@ def self.from_payload(payload) ) end + # @param tag [String] the correlation tag the dial was issued with + # @param dial_state [String] the dial state (see {DialState}) + # @param call_data [Hash] the resulting call descriptor from the wire key `call`; + # empty until the dial resolves + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(tag: '', dial_state: '', call_data: {}, **base) super(**base) @tag = tag @@ -537,6 +709,9 @@ def failed? private + # The `calling.call.dial` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { tag: @tag, dial_state: @dial_state, call_data: @call_data } end @@ -547,6 +722,12 @@ class ReferEvent < RelayEvent attr_reader :state, :sip_refer_to, :sip_refer_response_code, :sip_notify_response_code + # Decode a `calling.call.refer` frame into a {ReferEvent}, reading the refer state and the SIP REFER/NOTIFY + # response codes + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [ReferEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -559,6 +740,12 @@ def self.from_payload(payload) ) end + # @param state [String] the refer state, e.g. `"referring"` / `"completed"` / `"failed"` + # @param sip_refer_to [String] the SIP URI the call was referred to + # @param sip_refer_response_code [String] the response code the far end returned to the REFER + # @param sip_notify_response_code [String] the response code carried by the follow-up NOTIFY, + # which is what reports whether the transfer actually succeeded + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(state: '', sip_refer_to: '', sip_refer_response_code: '', sip_notify_response_code: '', **base) super(**base) @@ -570,6 +757,9 @@ def initialize(state: '', sip_refer_to: '', sip_refer_response_code: '', private + # The `calling.call.refer` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { state: @state, sip_refer_to: @sip_refer_to, sip_refer_response_code: @sip_refer_response_code, @@ -581,6 +771,11 @@ def event_fields class DenoiseEvent < RelayEvent attr_reader :denoised + # Decode a `calling.call.denoise` frame into a {DenoiseEvent}, reading the denoise flag + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [DenoiseEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -590,6 +785,8 @@ def self.from_payload(payload) ) end + # @param denoised [Boolean] whether denoising is currently active on the call + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(denoised: false, **base) super(**base) @denoised = denoised @@ -597,6 +794,9 @@ def initialize(denoised: false, **base) private + # The `calling.call.denoise` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { denoised: @denoised } end @@ -606,6 +806,11 @@ def event_fields class PayEvent < RelayEvent attr_reader :control_id, :state + # Decode a `calling.call.pay` frame into a {PayEvent}, reading the pay control id and state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [PayEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -616,6 +821,9 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the pay session this event reports on + # @param state [String] the pay state reported by the server + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', **base) super(**base) @control_id = control_id @@ -624,6 +832,9 @@ def initialize(control_id: '', state: '', **base) private + # The `calling.call.pay` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state } end @@ -633,6 +844,12 @@ def event_fields class QueueEvent < RelayEvent attr_reader :control_id, :status, :queue_id, :queue_name, :position, :size + # Decode a `calling.call.queue` frame into a {QueueEvent}. The queue's + # identifier and name arrive under the generic wire keys `id` and `name` + # and are exposed as {#queue_id} / {#queue_name}. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [QueueEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -644,6 +861,13 @@ def self.from_payload(payload) ) end + # @param control_id [String] identifies the queue operation this event reports on + # @param status [String] the queue status reported by the server + # @param queue_id [String] the queue's identifier, from the wire key `id` + # @param queue_name [String] the queue's name, from the wire key `name` + # @param position [Integer] this call's position in the queue + # @param size [Integer] how many calls are currently in the queue + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', status: '', queue_id: '', queue_name: '', position: 0, size: 0, **base) super(**base) @@ -657,6 +881,9 @@ def initialize(control_id: '', status: '', queue_id: '', queue_name: '', private + # The `calling.call.queue` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, status: @status, queue_id: @queue_id, queue_name: @queue_name, position: @position, size: @size } @@ -667,6 +894,11 @@ def event_fields class EchoEvent < RelayEvent attr_reader :state + # Decode a `calling.call.echo` frame into a {EchoEvent}, reading the echo state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [EchoEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -676,6 +908,8 @@ def self.from_payload(payload) ) end + # @param state [String] the echo state reported by the server + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(state: '', **base) super(**base) @state = state @@ -683,6 +917,9 @@ def initialize(state: '', **base) private + # The `calling.call.echo` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { state: @state } end @@ -696,11 +933,24 @@ class TranscribeEvent < RelayEvent control_id: '', state: '', url: '', recording_id: '', duration: 0.0, size: 0 }.freeze + # Decode a `calling.call.transcribe` frame into a {TranscribeEvent}, reading the transcribe control id, state and + # recording metadata + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [TranscribeEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) new(**_base_kwargs(base), **_typed_from(base.params, TYPED_FIELDS)) end + # @param control_id [String] identifies the transcription this event reports on + # @param state [String] the transcribe state reported by the server + # @param url [String] where the transcription artifact can be fetched + # @param recording_id [String] the recording the transcription was produced from + # @param duration [Float] transcribed length in seconds + # @param size [Integer] artifact size in bytes + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(control_id: '', state: '', url: '', recording_id: '', duration: 0.0, size: 0, **base) super(**base) @@ -714,6 +964,9 @@ def initialize(control_id: '', state: '', url: '', recording_id: '', private + # The `calling.call.transcribe` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { control_id: @control_id, state: @state, url: @url, recording_id: @recording_id, duration: @duration, size: @size } @@ -724,6 +977,11 @@ def event_fields class HoldEvent < RelayEvent attr_reader :state + # Decode a `calling.call.hold` frame into a {HoldEvent}, reading the hold state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [HoldEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -733,6 +991,8 @@ def self.from_payload(payload) ) end + # @param state [String] the hold state reported by the server + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(state: '', **base) super(**base) @state = state @@ -740,6 +1000,9 @@ def initialize(state: '', **base) private + # The `calling.call.hold` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { state: @state } end @@ -749,6 +1012,11 @@ def event_fields class ConferenceEvent < RelayEvent attr_reader :conference_id, :name, :status + # Decode a `calling.conference` frame into a {ConferenceEvent}, reading the conference id, name and status + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [ConferenceEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -760,6 +1028,10 @@ def self.from_payload(payload) ) end + # @param conference_id [String] the conference this event reports on + # @param name [String] the conference's name + # @param status [String] the conference status reported by the server + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(conference_id: '', name: '', status: '', **base) super(**base) @conference_id = conference_id @@ -769,6 +1041,9 @@ def initialize(conference_id: '', name: '', status: '', **base) private + # The `calling.conference` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { conference_id: @conference_id, name: @name, status: @status } end @@ -778,6 +1053,11 @@ def event_fields class CallingErrorEvent < RelayEvent attr_reader :code, :message + # Decode a `calling.error` frame into a {CallingErrorEvent}, reading the error code and message + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [CallingErrorEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) p = base.params @@ -788,6 +1068,9 @@ def self.from_payload(payload) ) end + # @param code [String] the server-supplied error code + # @param message [String] the human-readable error text + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(code: '', message: '', **base) super(**base) @code = code @@ -796,6 +1079,9 @@ def initialize(code: '', message: '', **base) private + # The `calling.error` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { code: @code, message: @message } end @@ -811,11 +1097,28 @@ class MessageReceiveEvent < RelayEvent body: '', media: [], segments: 0, message_state: '', tags: [] }.freeze + # Decode a `messaging.receive` frame into a {MessageReceiveEvent}, reading the message identity, addressing and + # body + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [MessageReceiveEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) new(**_base_kwargs(base), **_typed_from(base.params, TYPED_FIELDS)) end + # @param message_id [String] the inbound message's identifier + # @param context [String] the messaging context the message arrived on + # @param direction [String] `"inbound"` or `"outbound"` + # @param from_number [String] the sender in E.164 + # @param to_number [String] the recipient in E.164 + # @param body [String] the message text + # @param media [Array] MMS media URLs attached to the message + # @param segments [Integer] how many SMS segments the message was split into + # @param message_state [String] the delivery state (see {MessageState}) + # @param tags [Array] caller-supplied correlation tags + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(message_id: '', context: '', direction: '', from_number: '', to_number: '', body: '', media: [], segments: 0, message_state: '', tags: [], **base) @@ -827,6 +1130,9 @@ def initialize(message_id: '', context: '', direction: '', from_number: '', private + # The `messaging.receive` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { message_id: @message_id, context: @context, direction: @direction, from_number: @from_number, to_number: @to_number, body: @body, @@ -845,11 +1151,29 @@ class MessageStateEvent < RelayEvent body: '', media: [], segments: 0, message_state: '', reason: '', tags: [] }.freeze + # Decode a `messaging.state` frame into a {MessageStateEvent}, reading the message identity, addressing, body and + # delivery state + # out of the event's `params`. + # + # @param payload [Hash] the wire frame's decoded `params` object + # @return [MessageStateEvent] def self.from_payload(payload) base = RelayEvent.from_payload(payload) new(**_base_kwargs(base), **_typed_from(base.params, TYPED_FIELDS)) end + # @param message_id [String] the message whose delivery state changed + # @param context [String] the messaging context the message belongs to + # @param direction [String] `"inbound"` or `"outbound"` + # @param from_number [String] the sender in E.164 + # @param to_number [String] the recipient in E.164 + # @param body [String] the message text + # @param media [Array] MMS media URLs attached to the message + # @param segments [Integer] how many SMS segments the message was split into + # @param message_state [String] the new delivery state (see {MessageState}) + # @param reason [String] why delivery failed, set on the failure transition; '' otherwise + # @param tags [Array] caller-supplied correlation tags + # @param base [Hash] the shared envelope kwargs forwarded to {RelayEvent#initialize} def initialize(message_id: '', context: '', direction: '', from_number: '', to_number: '', body: '', media: [], segments: 0, message_state: '', reason: '', tags: [], **base) @@ -871,6 +1195,9 @@ def terminal? private + # The `messaging.state` typed fields contributed to {#to_h} and pattern matching. + # + # @return [Hash{Symbol => Object}] def event_fields { message_id: @message_id, context: @context, direction: @direction, from_number: @from_number, to_number: @to_number, body: @body, From 21f9053f690d63b30e98932193f917851d0e3115 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:46:28 -0400 Subject: [PATCH 30/90] docs(agent): document agent_base.rb (109 decls) The construction/init helpers, the bare-noun and `x=` accessor pairs, the AI-config setters, the verb queue, the skill/MCP/SIP integration helpers, the SWML render decomposition, and the three Rack middlewares. States what each field means on the rendered AI verb (the `multilingual`/`languages` exclusivity, the secure-tool `__token` on SWAIG webhooks, the redacted password at startup, the 413/401 middleware behaviour). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/agent/agent_base.rb | 387 +++++++++++++++++++++++++++++ 1 file changed, 387 insertions(+) diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index e5b6f199..a3ca901c 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -25,6 +25,7 @@ require_relative '../skills/skill_manager' require_relative '../skills/skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire # Central agent class that composes SWML rendering, tool dispatch, # prompt management, AI config, and HTTP serving. @@ -138,6 +139,9 @@ def warn_autogenerated_password ) end + # @api private — build the agent's structured logger and, when the + # constructor had to invent a basic-auth password, warn that external callers + # will get 401 unless they read it out of this process. def init_logger(name, suppress_logs, password_auto_generated) @logger = Logging.logger("AgentBase[#{name}]") @suppress_logs = suppress_logs @@ -156,6 +160,8 @@ def configure_agent(**opts) @logger.info "Agent '#{name}' initialised (route=#{route}, port=#{port})" end + # @api private — store the four call-handling constructor options that drive + # the SWML `answer` / `record_call` verbs emitted ahead of the AI verb. def init_call_settings(auto_answer:, record_call:, record_format:, record_stereo:) @auto_answer = auto_answer @record_call = record_call @@ -187,6 +193,9 @@ def init_signing_key(signing_key, trust_proxy_for_signature) log_signing_key_status unless suppress_logs end + # @api private — log whether inbound webhook signature validation is armed. A + # missing signing key is a WARN, not an error: the agent still serves, but it + # accepts unsigned traffic. def log_signing_key_status if @signing_key && !@signing_key.empty? @logger.info('webhook_signature_validation_enabled') @@ -207,6 +216,8 @@ def init_default_state init_web_and_integration_state end + # @api private — reset the prompt state (raw text, direct POM, POM sections, + # post-prompt text) and the AI-config state. def init_prompt_and_ai_state @prompt_text = nil # raw text mode @prompt_pom = nil # direct POM array @@ -215,6 +226,9 @@ def init_prompt_and_ai_state init_ai_config_state end + # @api private — reset the AI-verb collections (hints, languages, pronounce, + # params, global_data, function includes, internal fillers and the two LLM + # param maps) to their empty defaults. def init_ai_config_state @hints = [] @languages = [] @@ -228,6 +242,9 @@ def init_ai_config_state @post_prompt_llm_params = {} end + # @api private — reset the verb lists (pre-answer / answer / post-answer / + # post-AI), the debug-event flags, the context builder, and the skill manager + # and its loaded-skill map. def init_verb_and_context_state @debug_events_enabled = false @debug_events_level = 1 @@ -246,6 +263,9 @@ def init_verb_and_context_state @loaded_skills = {} # skill_name => SkillBase end + # @api private — reset the web/serving state: the dynamic-config callback, the + # proxy URL base (seeded from SWML_PROXY_URL_BASE), the webhook URL overrides, + # the SWAIG query params, and the debug-route/summary hooks. def init_web_and_integration_state @dynamic_config_callback = nil @proxy_url_base = ENV.fetch('SWML_PROXY_URL_BASE', nil) @@ -258,6 +278,8 @@ def init_web_and_integration_state init_sip_and_mcp_state end + # @api private — reset SIP routing (disabled, `/sip`, no registered usernames) + # and MCP state (no external servers, `/mcp` endpoint not exposed). def init_sip_and_mcp_state @sip_routing_enabled = false @sip_auto_map = false @@ -342,6 +364,10 @@ def prompt_add_section(title, body = '', bullets: nil, self end + # @api private — build one POM section hash from the {#prompt_add_section} + # arguments. `body` is omitted when nil or empty (Ruby's `''` is truthy where + # the reference's is falsy, so a bare truth test would emit `"body": ""`); + # the flags are emitted only when true. def build_section(title, body, **opts) section = { 'title' => title } # See prompt_add_subsection: `''` is truthy in Ruby, falsy in python. @@ -354,6 +380,8 @@ def build_section(title, body, **opts) section end + # @api private — normalise a list of subsection hashes to the wire shape, or + # nil when the caller passed no subsections. def build_subsections(subsections) return nil unless subsections.is_a?(Array) && !subsections.empty? @@ -392,6 +420,8 @@ def prompt_add_to_section(title, body_arg = nil, body: nil, bullet: nil, bullets self end + # @api private — the existing POM section with this title, or a freshly + # appended one. Never returns nil, so callers can append unconditionally. def find_or_create_section(title) sec = @pom_sections.find { |s| s['title'] == title } return sec if sec @@ -401,6 +431,9 @@ def find_or_create_section(title) sec end + # @api private — append a single `bullet` and/or a `bullets` array to a + # section, creating its `bullets` key on first use. A nil/non-Array pair is a + # no-op, leaving the section untouched. def append_section_bullets(sec, bullet, bullets) to_add = [] to_add << bullet if bullet @@ -470,6 +503,9 @@ def add_pom_section(pom, sec) end end + # @api private — the {SignalWire::POM::PromptObjectModel} keyword args for one + # section hash, defaulting each key and accepting both the `numbered_bullets` + # and legacy `numberedBullets` spellings. def section_pom_kwargs(sec) { body: sec.fetch('body', ''), @@ -524,6 +560,10 @@ def prompt_text=(text) # Post-prompt text. Clean symmetric reader/writer pair — the showcase case. alias post_prompt get_post_prompt + # Set the post-prompt text — the instruction run after the conversation ends. + # Writer half of the {#post_prompt} pair; returns the assigned value, not self. + # + # @param text [String] def post_prompt=(text) set_post_prompt(text) end @@ -541,38 +581,74 @@ def function_includes=(includes) set_function_includes(includes) end + # Merge a Hash into the agent's `global_data`, the variable bag every prompt + # and DataMap expression can reference. Writer form of {#set_global_data}. + # + # @param data [Hash] def global_data=(data) set_global_data(data) end + # Merge internal-function filler phrases. Writer form of + # {#set_internal_fillers} — see it for the supported function names. + # + # @param fillers [Hash{String => Hash{String => Array}}] def internal_fillers=(fillers) set_internal_fillers(fillers) end + # Replace the language list wholesale. Writer form of {#set_languages}. + # + # @param languages [Array] language config hashes as built by {#add_language} def languages=(languages) set_languages(languages) end + # Replace the list of native SWAIG function names advertised on the AI verb. + # Writer form of {#set_native_functions}. + # + # @param names [Array] def native_functions=(names) set_native_functions(names) end + # Merge AI-verb params (keys stringified). Writer form of {#set_params}. + # + # @param params [Hash] def params=(params) set_params(params) end + # Override the URL the platform POSTs the post-prompt summary to, instead of + # the URL derived from the agent's base URL and route. Writer form of + # {#set_post_prompt_url}. + # + # @param url [String] def post_prompt_url=(url) set_post_prompt_url(url) end + # Set the prompt directly as a POM array, clearing raw-text mode and any + # sections built with {#prompt_add_section}. Writer form of {#set_prompt_pom}. + # + # @param pom [Array] def prompt_pom=(pom) set_prompt_pom(pom) end + # Replace the pronunciation rule list wholesale. Writer form of + # {#set_pronunciations}. + # + # @param pronunciations [Array] rules as built by {#add_pronunciation} def pronunciations=(pronunciations) set_pronunciations(pronunciations) end + # Override the URL the platform POSTs SWAIG function calls to, instead of the + # URL derived from the agent's base URL and route. Writer form of + # {#set_web_hook_url}. + # + # @param url [String] def web_hook_url=(url) set_web_hook_url(url) end @@ -606,6 +682,12 @@ def full_url(include_auth: false) get_full_url(include_auth: include_auth) end + # The agent's basic-auth credentials. Bare-noun form of + # {#get_basic_auth_credentials}. + # + # @param include_source [Boolean] also return where the credentials came from + # @return [Array(String, String), Array(String, String, String)] `[user, pass]`, + # or `[user, pass, source]` when +include_source+ is true def basic_auth_credentials(include_source: false) get_basic_auth_credentials(include_source: include_source) end @@ -746,6 +828,10 @@ def build_tool_param_schema(parameters, required) param_schema end + # @api private — assemble the SWAIG function definition: the required + # `function` / `description` / `parameters` triple, then the optional fields + # that were supplied, then any caller-supplied `swaig_fields` merged over the + # top (keys stringified). def build_tool_definition(name, description, param_schema, **opts) tool_def = { 'function' => name, 'description' => description, 'parameters' => param_schema } optional_tool_fields(opts).each { |k, v| tool_def[k] = v if v } @@ -754,6 +840,9 @@ def build_tool_definition(name, description, param_schema, **opts) tool_def end + # @api private — the optional SWAIG function-definition fields, keyed by their + # wire names. A nil (or empty `fillers`) value means the caller did not set it + # and the key is dropped by {#build_tool_definition}. def optional_tool_fields(opts) { 'fillers' => (opts[:fillers] unless opts[:fillers].nil? || opts[:fillers].empty?), @@ -835,6 +924,9 @@ def coerce_function_result(name, result) { 'response' => result.to_s } end + # @api private — warn that a SWAIG handler returned neither a Hash nor a + # FunctionResult. The stringified value is still sent to the model as the + # tool response, so this is a silent-degradation warning, not a failure. def warn_unexpected_function_result(name, result) @logger.warn( "unexpected_function_result_type: function=#{name.inspect} " \ @@ -857,6 +949,11 @@ def add_hint(hint) self end + # Add several speech-recognition hints at once. A non-Array is ignored; each + # element goes through {#add_hint}, which drops non-String and empty entries. + # + # @param hints [Array] + # @return [self] for chaining def add_hints(hints) hints.each { |h| add_hint(h) } if hints.is_a?(Array) self @@ -936,6 +1033,8 @@ def apply_language_voice(lang, voice, engine, model) end end + # @api private — true when +voice+ is the combined `"engine.voice:model"` + # form, which {#apply_compound_voice} splits into three keys. def compound_voice?(voice) voice.is_a?(String) && voice.include?('.') && voice.include?(':') end @@ -949,6 +1048,9 @@ def apply_compound_voice(lang, voice) lang['model'] = model_part end + # @api private — attach filler phrases to a language entry. Both kinds present + # emit the distinct `speech_fillers` / `function_fillers` keys; exactly one + # present emits the combined `fillers` key the runtime also accepts. def apply_language_fillers(lang, speech_fillers, function_fillers) if speech_fillers && function_fillers lang['speech_fillers'] = speech_fillers @@ -995,6 +1097,11 @@ def get_language_params(code) nil end + # Replace the language list wholesale, discarding anything added via + # {#add_language}. A non-Array is ignored. + # + # @param languages [Array] language config hashes + # @return [self] for chaining def set_languages(languages) @languages = languages.dup if languages.is_a?(Array) self @@ -1014,30 +1121,62 @@ def add_pronunciation(replace, with_text, ignore_case: false, language_code: 'en self end + # Replace the pronunciation rule list wholesale, discarding anything added via + # {#add_pronunciation}. A non-Array is ignored. + # + # @param pronunciations [Array] `{'replace', 'with', 'ignore_case'?}` rules + # @return [self] for chaining def set_pronunciations(pronunciations) @pronounce = pronunciations.dup if pronunciations.is_a?(Array) self end + # Set one AI-verb param. The key is stringified, so a Symbol and its String + # spelling address the same param. + # + # @param key [String, Symbol] + # @param value [Object] + # @return [self] for chaining def set_param(key, value) @params[key.to_s] = value self end + # Merge several AI-verb params at once (keys stringified). Merges rather than + # replaces, so earlier params survive. A non-Hash is ignored. + # + # @param params [Hash] + # @return [self] for chaining def set_params(params) params.each { |k, v| @params[k.to_s] = v } if params.is_a?(Hash) self end + # Merge a Hash into `global_data`, the variable bag prompts and DataMap + # expressions reference as `${global_data.*}`. Merges rather than replaces. A + # non-Hash is ignored. + # + # @param data [Hash] + # @return [self] for chaining def set_global_data(data) @global_data.merge!(data) if data.is_a?(Hash) self end + # Alias for {#set_global_data} — merges into `global_data` rather than + # replacing it, matching the name's "update" reading. + # + # @param data [Hash] + # @return [self] for chaining def update_global_data(data) set_global_data(data) end + # Replace the list of native SWAIG function names advertised to the runtime on + # the AI verb's `SWAIG.native_functions`. A non-Array is ignored. + # + # @param names [Array] + # @return [self] for chaining def set_native_functions(names) @native_functions = names.dup if names.is_a?(Array) self @@ -1093,6 +1232,9 @@ def set_internal_fillers(fillers) self end + # @api private — warn that {#set_internal_fillers} was given names outside + # SUPPORTED_INTERNAL_FILLER_NAMES. They are stored but the runtime will ignore + # them, so the warning is the only signal of the typo. def warn_unknown_filler_names(unknown) @logger.warn( "unknown_internal_filler_names: #{unknown.inspect}. " \ @@ -1117,6 +1259,8 @@ def add_internal_filler(func_name, lang_code, fillers) self end + # @api private — the single-name counterpart of {#warn_unknown_filler_names}, + # emitted by {#add_internal_filler}. def warn_unknown_filler_name(func_name) @logger.warn( "unknown_internal_filler_name: #{func_name.inspect}. " \ @@ -1127,12 +1271,25 @@ def warn_unknown_filler_name(func_name) ) end + # Enable debug events: the AI verb gains a `debug_webhook_url` pointing at + # this agent's `/debug_events` route plus a `debug_webhook_level`, and the + # runtime POSTs debug events there. Register a handler with {#on_debug_event}. + # + # @param level [Integer] verbosity, emitted as `params.debug_webhook_level` + # @return [self] for chaining def enable_debug_events(level = 1) @debug_events_enabled = true @debug_events_level = level self end + # Include SWAIG functions hosted at another URL, so the model can call tools + # this agent does not implement. Emitted in the AI verb's `SWAIG.includes`. + # + # @param url [String] the remote SWAIG endpoint + # @param functions [Array] the function names to import from it + # @param meta_data [Hash, nil] optional metadata passed through to the remote endpoint + # @return [self] for chaining def add_function_include(url, functions, meta_data: nil) include = { 'url' => url, 'functions' => functions } include['meta_data'] = meta_data if meta_data.is_a?(Hash) @@ -1140,6 +1297,12 @@ def add_function_include(url, functions, meta_data: nil) self end + # Replace the whole function-include list. Entries that are not a Hash with a + # truthy `url` and a `functions` Array are DROPPED with a warning rather than + # emitted — a malformed include would be silently ignored by the runtime. + # + # @param includes [Array] `{'url', 'functions', 'meta_data'?}` entries + # @return [self] for chaining def set_function_includes(includes) return self unless includes.is_a?(Array) @@ -1155,6 +1318,8 @@ def valid_function_include?(inc) inc.is_a?(Hash) && inc['url'] && inc['functions'].is_a?(Array) end + # @api private — warn that {#set_function_includes} dropped an entry that was + # not a Hash with a `url` and a `functions` array. def warn_dropped_function_include(inc) @logger.warn( "invalid_function_include_dropped: #{inc.inspect}. " \ @@ -1163,11 +1328,21 @@ def warn_dropped_function_include(inc) ) end + # Merge LLM tuning params (temperature, top_p, …) into the AI verb's `prompt` + # object alongside the prompt text/POM. Keys are stringified. + # + # @param params [Hash] LLM parameters merged into the rendered `prompt` object + # @return [self] for chaining def set_prompt_llm_params(**params) @prompt_llm_params.merge!(params.transform_keys(&:to_s)) self end + # Merge LLM tuning params into the AI verb's `post_prompt` object, letting the + # summarization pass use different settings from the conversation itself. + # + # @param params [Hash] LLM parameters merged into the rendered `post_prompt` object + # @return [self] for chaining def set_post_prompt_llm_params(**params) @post_prompt_llm_params.merge!(params.transform_keys(&:to_s)) self @@ -1182,31 +1357,57 @@ def add_pre_answer_verb(verb_name, config) self end + # Drop every verb queued ahead of the `answer` verb. + # + # @return [self] for chaining def clear_pre_answer_verbs @pre_answer_verbs = [] self end + # Configure the SWML `answer` verb emitted when `auto_answer` is on. A nil or + # empty config renders as a bare `{"answer": {}}`. + # + # @param config [Hash, nil] the answer verb's config object + # @return [self] for chaining def add_answer_verb(config = nil) @answer_config = config self end + # Queue a SWML verb to run after `answer` (and `record_call`) but before the + # AI verb, in call order. + # + # @param verb_name [String, Symbol] the SWML verb name, stringified + # @param config [Object] the verb's config value + # @return [self] for chaining def add_post_answer_verb(verb_name, config) @post_answer_verbs << [verb_name.to_s, config] self end + # Drop every verb queued between `answer` and the AI verb. + # + # @return [self] for chaining def clear_post_answer_verbs @post_answer_verbs = [] self end + # Queue a SWML verb to run after the AI verb returns — what the call does once + # the agent is done. + # + # @param verb_name [String, Symbol] the SWML verb name, stringified + # @param config [Object] the verb's config value + # @return [self] for chaining def add_post_ai_verb(verb_name, config) @post_ai_verbs << [verb_name.to_s, config] self end + # Drop every verb queued after the AI verb. + # + # @return [self] for chaining def clear_post_ai_verbs @post_ai_verbs = [] self @@ -1251,6 +1452,9 @@ def define_contexts(contexts = nil) # rubocop:enable Naming/MemoizedInstanceVariableName end + # @api private — give a ContextBuilder a back-pointer to this agent so its + # `validate!` can check step function whitelists and reserved tool names + # against the agent's real tool registry. Returns the builder. def attach_context_builder(builder) builder.attach_agent(self) if builder.respond_to?(:attach_agent) builder @@ -1267,6 +1471,10 @@ def build_context_builder_from_hash(contexts) cb end + # @api private — add one step from a raw contexts Hash to +ctx+, taking the + # name from either the String or Symbol key. + # + # @raise [ArgumentError] if the step hash carries no name def add_context_step(ctx, step_h) step_name = step_h['name'] || step_h[:name] || raise(ArgumentError, 'step missing name') step = ctx.add_step(step_name) @@ -1316,6 +1524,9 @@ def add_skill(skill_name, params = nil) self end + # @api private — register every tool a loaded skill declares via its + # `register_tools`. A skill returning something other than an Array + # contributes no tools. def register_skill_tools(skill) tool_defs = skill.register_tools return unless tool_defs.is_a?(Array) @@ -1323,6 +1534,9 @@ def register_skill_tools(skill) tool_defs.each { |td| define_skill_tool(td) } end + # @api private — register one skill-declared tool. Entries missing a name or a + # handler are skipped; the handler is passed as the block, so `define_tool`'s + # required `handler:` slot is nil. def define_skill_tool(tool_def) td_name = sym_or_str(tool_def, :name) td_handler = sym_or_str(tool_def, :handler) @@ -1339,6 +1553,8 @@ def sym_or_str(hash, key) hash[key] || hash[key.to_s] end + # @api private — fold a loaded skill's hints into the agent's hint list and + # its global data into the agent's `global_data`. def merge_skill_hints_and_data(skill) skill_hints = skill.get_hints @hints.concat(skill_hints) if skill_hints.is_a?(Array) && !skill_hints.empty? @@ -1347,6 +1563,8 @@ def merge_skill_hints_and_data(skill) @global_data.merge!(skill_data) if skill_data.is_a?(Hash) && !skill_data.empty? end + # @api private — append a loaded skill's prompt sections to the agent's POM, + # switching out of raw-text mode so the sections actually render. def merge_skill_prompt_sections(skill) skill_sections = skill.get_prompt_sections return unless skill_sections.is_a?(Array) && !skill_sections.empty? @@ -1356,16 +1574,28 @@ def merge_skill_prompt_sections(skill) skill_sections.each { |sec| @pom_sections << sec } end + # Unload a previously added skill, removing it from the skill manager. Tools + # and prompt sections the skill already contributed stay registered. + # + # @param skill_name [String] the name it was added under + # @return [self] for chaining def remove_skill(skill_name) skill = @loaded_skills.delete(skill_name) @skill_manager.unload(skill.instance_key) if skill self end + # The names of the skills currently loaded on this agent, in load order. + # + # @return [Array] def list_skills @loaded_skills.keys end + # Whether a skill is loaded under this name. + # + # @param skill_name [String] + # @return [Boolean] def has_skill?(skill_name) @loaded_skills.key?(skill_name) end @@ -1385,6 +1615,12 @@ def set_dynamic_config_callback(callable, &block) self end + # Override the base URL used to build webhook URLs, for when the agent is + # reached through a proxy or tunnel at a different address than it binds. Takes + # precedence over the SWML_PROXY_URL_BASE environment variable. + # + # @param url [String] the externally-reachable base URL, e.g. "https://agent.example.com" + # @return [self] for chaining def manual_set_proxy_url(url) @proxy_url_base = url self @@ -1446,26 +1682,50 @@ def set_multilingual(config) self end + # Override the URL the platform POSTs SWAIG function calls to, replacing the + # URL derived from the agent's base URL and route. Rendered as the AI verb's + # `SWAIG.defaults.web_hook_url`. + # + # @param url [String] + # @return [self] for chaining def set_web_hook_url(url) @web_hook_url_override = url self end + # Override the URL the platform POSTs the post-prompt summary to, replacing + # the URL derived from the agent's base URL and route. Rendered as the AI + # verb's `post_prompt_url`. + # + # @param url [String] + # @return [self] for chaining def set_post_prompt_url(url) @post_prompt_url_override = url self end + # Merge query parameters onto every rendered SWAIG webhook URL — how an agent + # carries its own correlation data through the platform's callback. + # + # @param params [Hash] merged into the existing query params; a non-Hash is ignored + # @return [self] for chaining def add_swaig_query_params(params) @swaig_query_params.merge!(params) if params.is_a?(Hash) self end + # Drop every SWAIG webhook query parameter added via {#add_swaig_query_params}. + # + # @return [self] for chaining def clear_swaig_query_params @swaig_query_params = {} self end + # Expose the agent's debug routes. Off by default — these routes reveal + # internal agent state, so they are opt-in. + # + # @return [self] for chaining def enable_debug_routes @debug_routes_enabled = true self @@ -1540,6 +1800,8 @@ def auto_map_sip_usernames self end + # @api private — reduce a name or route to a legal SIP username by + # lower-casing and stripping everything outside `[a-z0-9_]`. def sanitize_sip_username(value) value.to_s.downcase.gsub(/[^a-z0-9_]/, '') end @@ -1627,6 +1889,9 @@ def _build_mcp_tool_list @tools.map { |name, tool| mcp_tool_entry(name, tool) } end + # @api private — one MCP `tools/list` entry for a registered SWAIG tool: its + # name, its description (falling back to the name), and its JSON-Schema + # `inputSchema`. def mcp_tool_entry(name, tool) params = tool[:definition]['parameters'] { @@ -1636,6 +1901,10 @@ def mcp_tool_entry(name, tool) } end + # @api private — normalise a tool's `parameters` into an MCP `inputSchema`. An + # absent/empty schema becomes an empty object schema; a bare property map is + # wrapped as `{type: object, properties: …}`; a schema that already declares + # `type` passes through. def mcp_input_schema(params) return { 'type' => 'object', 'properties' => {} } if params.nil? || params.empty? @@ -1662,20 +1931,27 @@ def _handle_mcp_request(body) end end + # @api private — the response for a JSON-RPC method not handled by name: an + # empty result for the acknowledged no-ops, else JSON-RPC -32601 Method not found. def mcp_default_response(method, req_id) return mcp_result(req_id, {}) if mcp_empty_result_method?(method) mcp_error(req_id, -32_601, "Method not found: #{method}") end + # @api private — true for the MCP methods that are acknowledged with an empty + # result and no work: `notifications/initialized` and `ping`. def mcp_empty_result_method?(method) %w[notifications/initialized ping].include?(method) end + # @api private — wrap +result+ in a JSON-RPC 2.0 success envelope for +req_id+. def mcp_result(req_id, result) { 'jsonrpc' => '2.0', 'id' => req_id, 'result' => result } end + # @api private — the MCP `initialize` reply: protocol version 2025-06-18, the + # `tools` capability, and this agent's name as the server name. def mcp_initialize_response(req_id) { 'jsonrpc' => '2.0', 'id' => req_id, @@ -1687,6 +1963,10 @@ def mcp_initialize_response(req_id) } end + # @api private — execute an MCP `tools/call`. An unregistered tool name is + # JSON-RPC -32602; a raising handler is reported as an MCP tool result with + # `isError` true rather than a JSON-RPC error, which is what the MCP spec asks + # for so the model can see and recover from the failure. def mcp_tools_call(req_id, params) tool_name = params['name'] || '' arguments = params['arguments'] || {} @@ -1701,6 +1981,9 @@ def mcp_tools_call(req_id, params) mcp_tool_result(req_id, "Error: #{e.message}", is_error: true) end + # @api private — extract the text an MCP client should see from a SWAIG + # handler's return: a FunctionResult's or Hash's `response`, a bare String as + # itself, anything else as empty. def mcp_response_text(result) return result.to_h['response'] || '' if result.respond_to?(:to_h) return result['response'] || result.to_s if result.is_a?(Hash) @@ -1709,6 +1992,8 @@ def mcp_response_text(result) '' end + # @api private — wrap +text+ in the MCP `tools/call` result shape: a + # single-element `content` array plus the `isError` flag. def mcp_tool_result(req_id, text, is_error:) { 'jsonrpc' => '2.0', 'id' => req_id, @@ -1934,6 +2219,9 @@ def apply_env_headers(env, headers) 'SERVER_PROTOCOL' => 'HTTP/1.1', 'rack.url_scheme' => 'https' }.freeze + # @api private — build the minimal Rack env for a serverless invocation: + # STATIC_RACK_ENV plus the request's path, method, query string and body. The + # body is wrapped in a StringIO because Rack requires `rack.input` to be readable. def rack_env(path:, method:, query:, body:) STATIC_RACK_ENV.merge( 'PATH_INFO' => path, 'REQUEST_METHOD' => method, 'QUERY_STRING' => query, @@ -1941,6 +2229,8 @@ def rack_env(path:, method:, query:, body:) ) end + # @api private — collapse a Rack body (an Array of strings, or any object + # responding to `join`) into a single String for the serverless response. def join_rack_body(body) body.respond_to?(:join) ? body.join : body.to_s end @@ -1979,12 +2269,18 @@ def serve(host: nil, port: nil) @server.start end + # @api private — log the bind address and the basic-auth USERNAME at startup. + # The password is deliberately printed as `[REDACTED]` — it is often + # auto-generated and the log is not a safe place for it. def log_server_startup(bind_host, bind_port) @logger.info "Starting server on #{bind_host}:#{bind_port} ..." user, _pass = @basic_auth @logger.info "Basic-auth credentials — user: #{user} password: [REDACTED]" end + # @api private — the WEBrick options for {#serve}: bind host/port, a WARN-level + # logger, access logging off, plus TLS when SSL is configured (SWML_SSL_* or + # the config file). A no-op SSL config leaves this plain HTTP. def webrick_opts(bind_host, bind_port) opts = { Host: bind_host, @@ -2084,6 +2380,11 @@ def agent_on_swml_request(body, callback_path, request = nil) nil end + # @api private — run the dynamic-config callback against an ephemeral copy of + # the agent, so per-request mutations never touch the shared agent. The + # callback receives the query params, the parsed body, the request headers and + # the copy. A raising callback is logged and the (partially configured) copy is + # still returned, so one bad callback does not 500 the request. def apply_dynamic_config(request_data, request) agent = create_ephemeral_copy query_params = request ? parse_query_string(request) : {} @@ -2126,10 +2427,14 @@ def verb_entries(verbs) verbs.map { |verb_name, config| { verb_name => config } } end + # @api private — the SWML `answer` verb entry. An unset answer config renders + # as an empty object rather than being omitted. def answer_entry { 'answer' => @answer_config.empty? ? {} : @answer_config } end + # @api private — the SWML `record_call` verb entry, carrying the constructor's + # `record_format` and `record_stereo`. def record_call_entry { 'record_call' => { 'format' => record_format, 'stereo' => record_stereo } } end @@ -2156,6 +2461,9 @@ def basic_auth_source(user, pass) 'provided' end + # @api private — true when the active credentials came from + # SWML_BASIC_AUTH_USER / SWML_BASIC_AUTH_PASSWORD: both env vars must be set, + # non-empty, and equal to what the agent is using. def matches_env_auth?(user, pass, env_user, env_pass) env_user && !env_user.empty? && env_pass && !env_pass.empty? && user == env_user && pass == env_pass end @@ -2180,6 +2488,10 @@ def build_ai_config ai end + # @api private — render the AI verb's `prompt` object. An unset or empty + # prompt falls back to "You are , a helpful AI assistant." rather than + # being omitted. A POM array renders under `pom`, raw text under `text`; the + # prompt LLM params are merged alongside. def add_ai_prompt(config) prompt = get_prompt if prompt.nil? || (prompt.respond_to?(:empty?) && prompt.empty?) @@ -2193,6 +2505,9 @@ def add_ai_prompt(config) config['prompt'] = prompt_obj end + # @api private — render the AI verb's `post_prompt` object and its + # `post_prompt_url`. Emits nothing when no post-prompt text is set — the + # summarization pass is opt-in. def add_ai_post_prompt(config) return unless @post_prompt_text && !@post_prompt_text.empty? @@ -2202,6 +2517,9 @@ def add_ai_post_prompt(config) config['post_prompt_url'] = (@post_prompt_url_override || build_webhook_url('post_prompt')) end + # @api private — render the AI verb's `SWAIG` object: the default webhook URL, + # plus `functions` / `native_functions` / `includes` / `internal_fillers` when + # non-empty. The whole key is dropped when there is nothing but the defaults. def add_ai_swaig(config) functions = build_functions_array swaig = { 'defaults' => { 'web_hook_url' => swaig_default_url } } @@ -2212,11 +2530,18 @@ def add_ai_swaig(config) config['SWAIG'] = swaig unless swaig.keys == ['defaults'] && functions.empty? end + # @api private — the URL for `SWAIG.defaults.web_hook_url`: the + # {#set_web_hook_url} override when set, else this agent's `/swaig` route with + # the configured SWAIG query params attached. def swaig_default_url @web_hook_url_override || build_webhook_url('swaig', @swaig_query_params.empty? ? nil : @swaig_query_params) end + # @api private — render the AI verb's list-valued config (`hints`, + # `languages`, `pronounce`) plus `multilingual`, each only when non-empty. + # `multilingual` and `languages` are mutually exclusive on the wire — the + # server prefers `multilingual` when both are present. def add_ai_collections(config) config['hints'] = @hints.dup unless @hints.empty? config['languages'] = @languages.dup unless @languages.empty? @@ -2227,6 +2552,9 @@ def add_ai_collections(config) config['multilingual'] = @multilingual_config if @multilingual_config && !@multilingual_config.empty? end + # @api private — render the AI verb's `params`, adding the debug webhook URL + # and level when debug events are enabled. Emits nothing when the merged map + # is empty. def add_ai_params(config) merged_params = @params.dup if debug_events_enabled @@ -2236,6 +2564,9 @@ def add_ai_params(config) config['params'] = merged_params unless merged_params.empty? end + # @api private — render the AI verb's `contexts` from the context builder. An + # invalid context configuration is skipped rather than raised, so a broken + # contexts block degrades to a context-free agent instead of failing the render. def add_ai_contexts(config) return unless @context_builder @@ -2251,6 +2582,10 @@ def build_functions_array functions end + # @api private — one SWAIG `functions` entry for a registered tool. When the + # tool is `secure` and a call_id is in scope, a per-tool `__token` (minted via + # the SessionManager) is appended to its webhook URL so the platform can + # validate the callback — the wire manifestation of `secure`. def tool_function_entry(tool) func_entry = tool[:definition].dup # A SECURE tool rendered with an active call_id gets a per-tool ``__token`` @@ -2326,6 +2661,8 @@ def embed_auth(base, user, pass) base end + # @api private — true for nil or an empty String. Used by {#embed_auth} so a + # blank credential is never embedded in a URL. def blank?(str) str.nil? || str.empty? end @@ -2341,6 +2678,8 @@ def normalise_parameters(params) { 'type' => 'object', 'properties' => params.transform_keys(&:to_s) } end + # @api private — true when +params+ is already a JSON Schema object (a Hash + # whose `type` is `"object"`), so {#normalise_parameters} leaves it alone. def object_schema?(params) params.is_a?(Hash) && params['type'] == 'object' end @@ -2444,6 +2783,8 @@ def webhook_middleware_args paths: ['/', '/swaig', '/post_prompt'], methods: ['POST'] } end + # @api private — the unauthenticated `/health` and `/ready` response: 200 with + # a `{"status": …}` JSON body. Deliberately reveals nothing about the agent. def static_status_response(status) [200, { 'content-type' => 'application/json' }, [JSON.generate({ status: status })]] end @@ -2505,6 +2846,9 @@ def parse_request_body(request, env) safe_json_parse(body) end + # @api private — parse a JSON request body, returning nil on any parse + # failure. Callers treat nil as "no usable body" rather than erroring, so a + # malformed POST does not 500. def safe_json_parse(body) JSON.parse(body) rescue StandardError @@ -2519,6 +2863,14 @@ def json_response(status, obj) # Override Service's hook to add agent-specific routes. public + # Dispatch the agent-specific routes mounted under the main route: + # `/post_prompt`, `/debug_events` and `/mcp`. Returns nil for any other path + # so the caller falls through to SWML rendering. + # + # @param sub_path [String] the path below the agent's route + # @param request_data [Hash, nil] the parsed JSON body + # @param env [Hash] the Rack env + # @return [Array, nil] a Rack response triple, or nil when the path is not one of these def handle_additional_route(sub_path, request_data, env) case sub_path when '/post_prompt' then handle_post_prompt(request_data, env) @@ -2541,6 +2893,9 @@ def handle_post_prompt(request_data, _env) json_response(200, { 'status' => 'ok' }) end + # @api private — extract the summary from a post-prompt payload and hand it to + # the registered {#on_summary} callback. A raising callback is logged, not + # propagated: the platform still gets its 200 ack. def invoke_summary_callback(request_data) summary = find_summary_in_post_data(request_data) @summary_callback.call(summary, request_data) @@ -2584,6 +2939,9 @@ def handle_debug_events(request_data, _env) json_response(200, { 'status' => 'ok' }) end + # @api private — hand a debug-event payload to the registered + # {#on_debug_event} callback, keyed by its `event_type` (defaulting to + # "unknown"). A raising callback is logged, not propagated. def invoke_debug_event_callback(request_data) event_type = request_data['event_type'] || 'unknown' @debug_event_callback.call(event_type, request_data) @@ -2611,10 +2969,15 @@ class AgentSecurityHeadersMiddleware 'cache-control' => 'no-store, no-cache, must-revalidate' }.freeze + # @param app [#call] the next Rack app in the stack def initialize(app) @app = app end + # Call the wrapped app and stamp the fixed security headers onto its response. + # + # @param env [Hash] the Rack env + # @return [Array] the Rack response triple, with HEADERS applied def call(env) status, headers, body = app.call(env) HEADERS.each { |k, v| headers[k] = v } @@ -2626,12 +2989,22 @@ def call(env) attr_reader :app end + # Rack middleware rejecting a request whose declared body length exceeds the + # agent's limit, before the body is ever read into memory. class AgentBodyLimitMiddleware + # @param app [#call] the next Rack app in the stack + # @param max_size [Integer] the largest CONTENT_LENGTH accepted, in bytes def initialize(app, max_size) @app = app @max_size = max_size end + # Reject an over-sized request with 413 and a JSON error body; otherwise pass + # it to the wrapped app. Only the declared CONTENT_LENGTH is checked — a + # request that lies about its length is caught downstream by the server. + # + # @param env [Hash] the Rack env + # @return [Array] the Rack response triple def call(env) if env['CONTENT_LENGTH'] && env['CONTENT_LENGTH'].to_i > max_size body = JSON.generate({ 'error' => 'Request body too large' }) @@ -2645,12 +3018,23 @@ def call(env) attr_reader :app, :max_size end + # Rack middleware enforcing the agent's basic auth with a constant-time + # credential comparison, so a wrong password cannot be recovered by timing the + # response. class AgentTimingSafeBasicAuth + # @param app [#call] the next Rack app in the stack + # @param agent [AgentBase] the agent whose credentials are the expected pair def initialize(app, agent) @app = app @agent = agent end + # Require valid basic auth before passing the request on. A missing or + # non-Basic Authorization header, or a credential mismatch, gets the same 401 + # challenge — the response does not distinguish the two. + # + # @param env [Hash] the Rack env + # @return [Array] the Rack response triple def call(env) auth = Rack::Auth::Basic::Request.new(env) return unauthorized unless auth.provided? && auth.basic? @@ -2669,6 +3053,9 @@ def credentials_valid?(input) user_ok && pass_ok end + # @api private — the 401 challenge: a `Basic realm="SignalWire Agent"` + # www-authenticate header and a JSON `{"error":"Unauthorized"}` body (not + # plain text), matching the reference's auth challenges. def unauthorized # Python parity (AuthMixin._send_lambda_auth_challenge / the CGI + server # challenges): a JSON {"error":"Unauthorized"} body with a JSON From cbb9be5de423dcb0b6dfaee3f0f2cfe802d7fb60 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:49:40 -0400 Subject: [PATCH 31/90] docs(relay): document action.rb + client.rb (81 decls) action.rb: every Action subclass's constructor (which RELAY event and terminal states it resolves on), the stop/pause/resume/volume control methods naming the RELAY method each sends, and the three overridden _check_event hooks that explain why detect resolves on first result and why play_and_collect must ignore play events sharing its control_id. client.rb: credential resolution and validation, the four correlation maps, the connect handshake's session-restore and dual-placement credentials, the JSON-RPC dispatch/settle path, and the inbound call/dial/message handlers (including the max_active_calls drop and the on-its-own-thread handler invocation). DOC-SURFACE ruby: 77.1% -> 79.5%. Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/relay/action.rb | 114 +++++++++++++++++++++++++ lib/signalwire/relay/client.rb | 152 +++++++++++++++++++++++++++++++++ 2 files changed, 266 insertions(+) diff --git a/lib/signalwire/relay/action.rb b/lib/signalwire/relay/action.rb index 8b724bd7..5943e1c3 100644 --- a/lib/signalwire/relay/action.rb +++ b/lib/signalwire/relay/action.rb @@ -3,7 +3,9 @@ require 'securerandom' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # Raised when an action times out waiting for completion. class ActionTimeoutError < SignalWire::Error; end @@ -17,6 +19,14 @@ class ActionTimeoutError < SignalWire::Error; end class Action attr_reader :control_id, :call, :result, :completed + # @param call [Call] the call this action runs on; used to send the RELAY + # control methods (stop / pause / resume / volume) + # @param control_id [String] the id the server echoes on every event for this + # operation; how {#_check_event} recognizes its own events + # @param terminal_event [String] the RELAY event type that carries this + # action's state transitions, e.g. `"calling.call.play"` + # @param terminal_states [Array] the states that complete the action; + # seeing any of them resolves the wait and fires the on-completed callback def initialize(call, control_id, terminal_event, terminal_states) @call = call @control_id = control_id @@ -74,6 +84,10 @@ def wait(timeout: nil) end end + # Whether the server has already sent a terminal event for this action. + # Non-blocking, unlike {#wait}. + # + # @return [Boolean] def done? @completed end @@ -107,25 +121,38 @@ def wait_with_timeout(timeout) # Handle for an active play operation. class PlayAction < Action + # @param call [Call] the call the playback runs on + # @param control_id [String] the id the server echoes on `calling.call.play` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_PLAY, [PLAY_STATE_FINISHED, PLAY_STATE_ERROR]) end + # Stop the playback by sending the RELAY `play.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('play.stop', { 'control_id' => @control_id }) end + # Pause the playback via the RELAY `play.pause` method. + # + # @param behavior [String, nil] what to do with the media while paused; + # omitted from the wire params when nil, leaving the server default def pause(behavior: nil) params = { 'control_id' => @control_id } params['behavior'] = behavior if behavior @call._execute('play.pause', params) end + # Resume a paused playback via the RELAY `play.resume` method. def resume @call._execute('play.resume', { 'control_id' => @control_id }) end + # Change the playback volume of the playback via the RELAY `play.volume` method. + # + # @param vol [Numeric] the new volume, sent as the `volume` wire param def volume(vol) @call._execute('play.volume', { 'control_id' => @control_id, 'volume' => vol }) end @@ -133,21 +160,31 @@ def volume(vol) # Handle for an active record operation. class RecordAction < Action + # @param call [Call] the call being recorded + # @param control_id [String] the id the server echoes on `calling.call.record` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_RECORD, [RECORD_STATE_FINISHED, RECORD_STATE_NO_INPUT]) end + # Stop the recording by sending the RELAY `record.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('record.stop', { 'control_id' => @control_id }) end + # Pause the recording via the RELAY `record.pause` method. + # + # @param behavior [String, nil] what to do with the media while paused; + # omitted from the wire params when nil, leaving the server default def pause(behavior: nil) params = { 'control_id' => @control_id } params['behavior'] = behavior if behavior @call._execute('record.pause', params) end + # Resume a paused a recording via the RELAY `record.resume` method. def resume @call._execute('record.resume', { 'control_id' => @control_id }) end @@ -155,12 +192,19 @@ def resume # Handle for an active detect operation. class DetectAction < Action + # @param call [Call] the call being analysed + # @param control_id [String] the id the server echoes on `calling.call.detect` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_DETECT, %w[finished error]) end # Detect delivers results continuously. Resolve on first result or # when finished/error. + # Resolve on the FIRST event carrying a non-empty `detect` result, not only on + # a terminal state — detect streams results continuously, so waiting for + # `finished` would discard the answer the caller asked for. + # + # @param event [RelayEvent] a `calling.call.detect` event for this control_id def _check_event(event) detect = event.params['detect'] || {} state = event.params['state'] || '' @@ -169,6 +213,9 @@ def _check_event(event) _resolve(event) end + # Stop the detector by sending the RELAY `detect.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('detect.stop', { 'control_id' => @control_id }) end @@ -176,6 +223,8 @@ def stop # Handle for play_and_collect or standalone collect. class CollectAction < Action + # @param call [Call] the call the play-and-collect runs on + # @param control_id [String] the id the server echoes on `calling.call.collect` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_COLLECT, %w[finished error no_input no_match]) @@ -183,6 +232,12 @@ def initialize(call, control_id) # play_and_collect shares a control_id across play and collect # phases. Only resolve on collect events, not play events. + # Resolve only on collect events. `play_and_collect` shares one control_id + # across its play and collect phases, so a play event carrying the same id + # must not complete the collect. A non-empty `result` resolves immediately; + # otherwise the base terminal-state check applies. + # + # @param event [RelayEvent] an event carrying this action's control_id def _check_event(event) return unless event.event_type == EVENT_CALL_COLLECT @@ -194,26 +249,41 @@ def _check_event(event) end end + # Stop the play-and-collect by sending the RELAY `play_and_collect.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('play_and_collect.stop', { 'control_id' => @control_id }) end + # Pause the play-and-collect prompt via the RELAY `play_and_collect.pause` method. + # + # @param behavior [String, nil] what to do with the media while paused; + # omitted from the wire params when nil, leaving the server default def pause(behavior: nil) params = { 'control_id' => @control_id } params['behavior'] = behavior if behavior @call._execute('play_and_collect.pause', params) end + # Resume a paused play-and-collect prompt via the RELAY `play_and_collect.resume` method. def resume @call._execute('play_and_collect.resume', { 'control_id' => @control_id }) end + # Change the playback volume of the play-and-collect prompt via the RELAY `play_and_collect.volume` method. + # + # @param vol [Numeric] the new volume, sent as the `volume` wire param def volume(vol) @call._execute('play_and_collect.volume', { 'control_id' => @control_id, 'volume' => vol }) end + # Start the collect's inter-digit and no-input timers via the RELAY + # `collect.start_input_timers` method. Use it when the prompt was played + # outside this collect, so the timers begin when the caller could actually + # have started speaking. def start_input_timers @call._execute('collect.start_input_timers', { 'control_id' => @control_id }) end @@ -221,11 +291,18 @@ def start_input_timers # Handle for standalone calling.collect (without play). class StandaloneCollectAction < Action + # @param call [Call] the call the collect runs on + # @param control_id [String] the id the server echoes on `calling.call.collect` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_COLLECT, %w[finished error no_input no_match]) end + # Resolve on a collect event carrying either a non-empty `result` or a + # terminal state (finished / error / no_input / no_match). Events for other + # event types sharing this control_id are ignored. + # + # @param event [RelayEvent] an event carrying this action's control_id def _check_event(event) return unless event.event_type == EVENT_CALL_COLLECT @@ -236,10 +313,16 @@ def _check_event(event) _resolve(event) end + # Stop the collect by sending the RELAY `collect.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('collect.stop', { 'control_id' => @control_id }) end + # Start the collect's inter-digit and no-input timers via the RELAY + # `collect.start_input_timers` method, for when the prompt was played outside + # this collect. def start_input_timers @call._execute('collect.start_input_timers', { 'control_id' => @control_id }) end @@ -247,11 +330,17 @@ def start_input_timers # Handle for send_fax or receive_fax. class FaxAction < Action + # @param call [Call] the call carrying the fax + # @param control_id [String] the id the server echoes on `calling.call.fax` events + # @param method_prefix [String] `"send_fax"` or `"receive_fax"` — which RELAY + # method family {#stop} addresses, since one class handles both directions def initialize(call, control_id, method_prefix) super(call, control_id, EVENT_CALL_FAX, %w[finished error]) @method_prefix = method_prefix end + # Stop the fax by sending `.stop` — `send_fax.stop` or + # `receive_fax.stop` depending on which direction this action was created for. def stop @call._execute("#{@method_prefix}.stop", { 'control_id' => @control_id }) end @@ -259,10 +348,15 @@ def stop # Handle for an active tap operation. class TapAction < Action + # @param call [Call] the call being tapped + # @param control_id [String] the id the server echoes on `calling.call.tap` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_TAP, %w[finished]) end + # Stop the media tap by sending the RELAY `tap.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('tap.stop', { 'control_id' => @control_id }) end @@ -270,10 +364,15 @@ def stop # Handle for an active stream operation. class StreamAction < Action + # @param call [Call] the call being streamed + # @param control_id [String] the id the server echoes on `calling.call.stream` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_STREAM, %w[finished]) end + # Stop the media stream by sending the RELAY `stream.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('stream.stop', { 'control_id' => @control_id }) end @@ -281,10 +380,15 @@ def stop # Handle for an active pay operation. class PayAction < Action + # @param call [Call] the call the payment session runs on + # @param control_id [String] the id the server echoes on `calling.call.pay` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_PAY, %w[finished error]) end + # Stop the payment session by sending the RELAY `pay.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('pay.stop', { 'control_id' => @control_id }) end @@ -292,10 +396,15 @@ def stop # Handle for an active transcribe operation. class TranscribeAction < Action + # @param call [Call] the call being transcribed + # @param control_id [String] the id the server echoes on `calling.call.transcribe` events def initialize(call, control_id) super(call, control_id, EVENT_CALL_TRANSCRIBE, %w[finished]) end + # Stop the transcription by sending the RELAY `transcribe.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('transcribe.stop', { 'control_id' => @control_id }) end @@ -303,10 +412,15 @@ def stop # Handle for an active AI agent session. class AIAction < Action + # @param call [Call] the call the AI agent is attached to + # @param control_id [String] the id the server echoes on `calling.call.ai` events def initialize(call, control_id) super(call, control_id, 'calling.call.ai', %w[finished error]) end + # Stop the AI agent session by sending the RELAY `ai.stop` method with this + # action's control_id. Does not block — the action resolves when the + # server's terminal event arrives. def stop @call._execute('ai.stop', { 'control_id' => @control_id }) end diff --git a/lib/signalwire/relay/client.rb b/lib/signalwire/relay/client.rb index de0b8013..b04ed5b8 100644 --- a/lib/signalwire/relay/client.rb +++ b/lib/signalwire/relay/client.rb @@ -14,12 +14,17 @@ require_relative 'message' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # Raised for RELAY JSON-RPC errors. class RelayError < SignalWire::Error attr_reader :code, :error_message + # @param code [Integer, String] the JSON-RPC error code the server returned + # @param message [String] the server's error text; also readable via + # {#error_message} separately from the composed exception message def initialize(code, message) @code = code @error_message = message @@ -105,6 +110,9 @@ def initialize(project: nil, token: nil, jwt_token: nil, host: nil, # Back-compat-only connection config, set once during initialize. attr_reader :space + # @api private — resolve project / token / host from the explicit kwargs, + # falling back to SIGNALWIRE_PROJECT_ID / SIGNALWIRE_API_TOKEN / + # SIGNALWIRE_SPACE. `host:` and the legacy `space:` feed the same slot. def resolve_credentials(project, token, host, space) @project_id = value_or_env(project, 'SIGNALWIRE_PROJECT_ID') @token = value_or_env(token, 'SIGNALWIRE_API_TOKEN') @@ -112,6 +120,11 @@ def resolve_credentials(project, token, host, space) @space = value_or_env(host || space, 'SIGNALWIRE_SPACE') end + # @api private — the explicit value, else the named environment variable, else + # the empty string. Never nil, so callers can test emptiness rather than + # nil-ness (which is what the reference's truthiness checks amount to). + # + # @return [String] def value_or_env(explicit, env_key) explicit || ENV[env_key] || '' end @@ -127,6 +140,12 @@ def resolve_max_active_calls(max_active_calls) end end + # @api private — fail before connecting when a required credential is missing, + # naming both the credential and its environment variable so the error is + # self-diagnosing. A non-empty jwt_token is self-contained (the project id is + # inside the token), so it only requires the host. + # + # @raise [ArgumentError] naming the first missing credential def validate_credentials # JWT auth (env: SIGNALWIRE_JWT_TOKEN or the jwt_token: kwarg) is a # self-contained alternative to project/token — the project id lives @@ -145,6 +164,9 @@ def validate_credentials raise ArgumentError, 'host is required (set SIGNALWIRE_SPACE)' if space.empty? end + # @api private — initialise the four correlation maps and their mutexes: + # JSON-RPC id to pending request, call_id to {Call}, dial tag to pending dial, + # and message_id to {Message}. def init_correlation_state # Correlation mechanisms @pending = {} # id -> { mutex:, cv:, result:, error: } @@ -157,6 +179,9 @@ def init_correlation_state @messages_mutex = Mutex.new end + # @api private — initialise the session/transport state: the negotiated + # protocol, the re-auth blob, the server's session id, the socket and its + # connected/running flags, and the reconnect backoff. def init_session_state # Session state @protocol = nil @@ -181,6 +206,8 @@ def init_session_state init_handlers end + # @api private — clear the three user-supplied handler slots (on_call, + # on_message, on_event). def init_handlers @on_call_handler = nil @on_message_handler = nil @@ -370,6 +397,11 @@ def receive(contexts) execute('signalwire.receive', { 'contexts' => contexts }) end + # Unsubscribe from RELAY contexts on the live connection, so this client stops + # receiving inbound calls and messages for them. Sends `signalwire.unreceive`. + # + # @param contexts [Array] the context names to drop + # @return [Hash] the server's result def unreceive(contexts) execute('signalwire.unreceive', { 'contexts' => contexts }) end @@ -412,6 +444,9 @@ def require_handler(handler, block, method_name) callback end + # @api private — run one connect-and-serve cycle, logging any raised error + # instead of propagating it. Swallowing here is what lets the reconnect loop + # keep retrying rather than dying on the first transport failure. def connect_and_run_guarded connect_and_run rescue StandardError => e @@ -446,12 +481,23 @@ def wait_on_entry(entry, timeout, pending) end end + # @api private — a message must carry a body, media, or both; an empty message + # would be rejected by the server after a round trip. + # + # @raise [ArgumentError] when both body and media are absent or empty def validate_message_payload(body, media) return unless (body.nil? || body.empty?) && (media.nil? || media.empty?) raise ArgumentError, 'body or media is required' end + # @api private — send the `calling.dial` request. On any failure the pending- + # dial entry is removed before re-raising, so a failed dial never leaves a tag + # waiting forever for an event that will not arrive. + # + # @param dial_tag [String] the correlation tag the dial events carry back + # @param devices [Array] the serialized device list to try + # @param max_duration [Integer, nil] seconds cap; omitted from the wire when nil def send_dial_rpc(dial_tag, devices, max_duration) params = { 'tag' => dial_tag, 'devices' => devices } params['max_duration'] = max_duration if max_duration @@ -461,6 +507,10 @@ def send_dial_rpc(dial_tag, devices, max_duration) raise end + # @api private — build the `messaging.send` wire params. `context`, `to_number` + # and `from_number` are always present; the rest are emitted only when supplied. + # + # @return [Hash{String => Object}] def build_message_params(msg_context, to_number, from_number, body:, media:, tags:, region:) params = { 'context' => msg_context, 'to_number' => to_number, 'from_number' => from_number } params['body'] = body if body @@ -470,6 +520,11 @@ def build_message_params(msg_context, to_number, from_number, body:, media:, tag params end + # @api private — the local {Message} handle for a just-sent message, seeded + # with `direction: "outbound"` and `state: "queued"`. The real state arrives + # later on `messaging.state` events, which update this object. + # + # @return [Message] def build_outbound_message(message_id, msg_context, to_number, from_number, body:, media:, tags:) Message.new( message_id: message_id, context: msg_context, direction: 'outbound', @@ -486,6 +541,10 @@ def await_response(id, entry, method) end end + # @api private — raise when a RELAY result carries a non-2xx `code`. The + # `signalwire.connect` handshake is exempt: its result has no code field. + # + # @raise [RelayError] carrying the server's code and message def check_result_code(method, result) return if method == METHOD_SIGNALWIRE_CONNECT @@ -567,6 +626,11 @@ def relay_scheme scheme.nil? || scheme.empty? ? 'wss' : scheme end + # @api private — the host to open the WebSocket against: SIGNALWIRE_RELAY_HOST + # when set (how the audit harness redirects the client to a loopback fixture), + # else the credential-resolved production host. + # + # @return [String] def relay_endpoint_host host_override = ENV.fetch('SIGNALWIRE_RELAY_HOST', nil) host_override.nil? || host_override.empty? ? host : host_override @@ -585,11 +649,16 @@ def wire_ws_callbacks(socket, ready) end end + # @api private — run a WebSocket lifecycle hook (`on_ws_open` / `on_ws_close`) + # and then release whoever is blocked in {#open_websocket}, so a connection + # that opens OR closes both unblock the connect. def on_ws_lifecycle(hook, ready) send(hook) signal_ready(ready) end + # @api private — set the shared ready flag and signal its condition variable, + # waking {#open_websocket} out of its 15-second wait. def signal_ready(ready) ready[:mutex].synchronize do ready[:flag] = true @@ -622,10 +691,19 @@ def wss_tls_options(scheme) { verify_mode: OpenSSL::SSL::VERIFY_PEER, cert_store: store } end + # @api private — WebSocket open callback. The connected flag is set by + # {#connect_and_run} once {#open_websocket} returns, so there is nothing to do + # here; the hook exists so the open event still signals readiness via + # {#on_ws_lifecycle}. def on_ws_open # Connection opened end + # @api private — WebSocket message callback. Empty frames are ignored and a + # frame that is not valid JSON is warned about and dropped rather than raised, + # so one malformed frame cannot kill the read thread. + # + # @param data [String] the raw frame payload def on_ws_message(data) return if data.nil? || data.empty? @@ -639,6 +717,8 @@ def on_ws_message(data) handle_message(msg) end + # @api private — WebSocket close callback: clear the connected flag so the + # connect loop in {#connect_and_run} falls through to reconnect. def on_ws_close @ws_mutex.synchronize { @connected = false } end @@ -671,6 +751,10 @@ def authenticate @session_id = result['sessionid'] if result['sessionid'] end + # @api private — add the session-restore fields (`protocol`, + # `authorization_state`) to the connect params, so a reconnect resumes the + # existing session. Skipped when the server asked for a restart, which is + # explicitly a request for a FRESH session. def apply_session_restore(params) return if @should_restart @@ -678,6 +762,10 @@ def apply_session_restore(params) params['authorization_state'] = @authorization_state if @authorization_state end + # @api private — add the credentials to the connect params. A non-empty + # jwt_token wins; otherwise project/token go under `authentication` AND are + # repeated at the top level, because the reference emits them nested while the + # audit harness watches the top level. def apply_auth_credentials(params) # An unset jwt_token is the empty string (env fallback), not nil — and # in Ruby '' is truthy, so guard on emptiness to match Python's @@ -695,6 +783,8 @@ def apply_auth_credentials(params) params['token'] = token end + # @api private — drop the negotiated protocol, the re-auth blob and the restart + # flag, so the next connect handshake is a fresh session rather than a restore. def clear_restart_state @protocol = nil @authorization_state = nil @@ -712,6 +802,10 @@ def handle_message(msg) dispatch_method(msg) end + # @api private — route an inbound JSON-RPC REQUEST by method: + # `signalwire.event` to the event pipeline, `signalwire.ping` to an empty-result + # ack, `signalwire.disconnect` to the teardown. Any other method with an id + # also gets an empty-result ack so the server is never left waiting. def dispatch_method(msg) id = msg['id'] case msg['method'] @@ -724,6 +818,9 @@ def dispatch_method(msg) end end + # @api private — settle the pending request this RESPONSE frame belongs to, + # carrying either a {RelayError} built from the JSON-RPC `error` object or the + # `result`. A response for an unknown id is dropped. def handle_response(msg) id = msg['id'] return unless id @@ -739,6 +836,9 @@ def handle_response(msg) end end + # @api private — store the outcome on a pending entry and wake its waiter. Each + # field is written only when supplied, so one call can settle a result, an + # error, or (for a dial) the resolved {Call}. def settle_pending(entry, result: nil, error: nil, call: nil) entry[:mutex].synchronize do entry[:result] = result unless result.nil? @@ -790,6 +890,10 @@ def dispatch_typed_event(event_type, event_params, outer_params, call_id) end end + # @api private — dispatch the events whose handler takes the OUTER params hash + # (inbound call, dial, inbound message, message state). + # + # @return [Boolean] true when a handler ran and dispatch is complete def dispatch_outer_param_event(event_type, outer_params) handler = OUTER_PARAM_EVENT_HANDLERS[event_type] return false unless handler @@ -798,6 +902,9 @@ def dispatch_outer_param_event(event_type, outer_params) true end + # @api private — on a `calling.call.state` event carrying a tag we are dialing, + # pre-register the outbound leg as a {Call} so events for it route correctly + # even before the dial resolves. Skipped when the call is already known. def maybe_register_dial_leg(event_params, call_id) tag = event_params['tag'] || '' return if tag.empty? @@ -820,6 +927,9 @@ def route_event_to_call(call_id, outer_params) @calls_mutex.synchronize { @calls.delete(call_id) } end + # @api private — handle `signalwire.disconnect`: ack it, record whether the + # server asked for a restart (which makes the next connect skip session + # restore), and clear the connected flag so the reconnect loop takes over. def handle_disconnect(msg) id = msg['id'] params = msg['params'] || {} @@ -834,6 +944,11 @@ def handle_disconnect(msg) @ws_mutex.synchronize { @connected = false } end + # @api private — handle a `calling.call.receive` event: build the {Call}, + # register it by call_id, and invoke the user's on_call handler on its own + # thread so a slow handler cannot stall the read loop. The call is DROPPED when + # the max_active_calls cap is reached. A raising handler is warned about, not + # propagated. def handle_inbound_call(payload) event_params = payload['params'] || {} return if max_active_calls_reached? @@ -862,6 +977,11 @@ def max_active_calls_reached? reached end + # @api private — build the inbound {Call} from a `calling.call.receive` event's + # params. `context` is read from `context`, falling back to the legacy + # `protocol` key. + # + # @return [Call] def build_inbound_call(event_params) kwargs = extract_fields(event_params, INBOUND_CALL_FIELDS) kwargs[:context] = event_params['context'] || event_params['protocol'] || '' @@ -874,6 +994,9 @@ def extract_fields(params, field_map) field_map.transform_values { |key, default| params[key] || default } end + # @api private — handle a `calling.call.dial` event: settle the pending dial + # for its tag with the answered {Call}, or with a failure. Other dial states are + # intermediate and leave the dial waiting. def handle_dial_event(payload) event_params = payload['params'] || {} tag = event_params['tag'] || '' @@ -886,6 +1009,9 @@ def handle_dial_event(payload) end end + # @api private — resolve a pending dial that answered: reuse the already- + # registered {Call} for this call_id or build one, mark it answered, and hand + # it to the waiter. def dial_answered(entry, tag, call_info) call_id = call_info['call_id'] || '' call = @calls_mutex.synchronize { @calls[call_id] } @@ -897,6 +1023,11 @@ def dial_answered(entry, tag, call_info) settle_pending(entry, call: call) end + # @api private — build the {Call} for an answered outbound dial from the event's + # `call` object, falling back to the dial's own tag when the server did not + # echo one. + # + # @return [Call] def build_dialed_call(call_id, tag, call_info) Call.new( self, @@ -910,6 +1041,9 @@ def build_dialed_call(call_id, tag, call_info) ) end + # @api private — register an outbound leg discovered from a `calling.call.state` + # event, so subsequent events route to a real {Call}. A state event with no + # call_id is ignored. def register_dial_leg(tag, event_params) call_id = event_params['call_id'] || '' return if call_id.empty? @@ -922,6 +1056,9 @@ def register_dial_leg(tag, event_params) @calls_mutex.synchronize { @calls[call_id] = call } end + # @api private — handle a `messaging.receive` event: build the {Message} and + # invoke the user's on_message handler on its own thread. A raising handler is + # warned about, not propagated. def handle_inbound_message(payload) msg = build_inbound_message(payload['params'] || {}) @@ -934,10 +1071,18 @@ def handle_inbound_message(payload) end end + # @api private — build the inbound {Message} from a `messaging.receive` event's + # params, forcing `direction: "inbound"`. + # + # @return [Message] def build_inbound_message(event_params) Message.new(direction: 'inbound', **extract_fields(event_params, INBOUND_MESSAGE_FIELDS)) end + # @api private — route a `messaging.state` event to the {Message} it belongs to + # so its state updates, then drop the message from the tracking map once it + # reaches a terminal delivery state. An event for an unknown message_id is + # ignored. def handle_message_state(payload) event_params = payload['params'] || {} message_id = event_params['message_id'] || '' @@ -953,6 +1098,11 @@ def handle_message_state(payload) @messages_mutex.synchronize { @messages.delete(message_id) } end + # @api private — fail every in-flight request and dial with +reason+ and clear + # both maps. Called on teardown so a lost connection surfaces as an error on + # each waiter rather than an indefinite hang. + # + # @param reason [String] the failure text carried to every waiter def reject_all_pending(reason) @pending_mutex.synchronize do @pending.each_value { |entry| reject_entry(entry, RelayError.new(-1, reason)) } @@ -965,6 +1115,8 @@ def reject_all_pending(reason) end end + # @api private — record an error on a pending entry (first error wins) and wake + # its waiter. def reject_entry(entry, error) entry[:mutex].synchronize do entry[:error] ||= error From 5988717794e13cdc8a2cc1d8143c370e5d751b7f Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:51:23 -0400 Subject: [PATCH 32/90] docs(lib): document the namespace modules + the SkillBase contract overrides MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 229 declarations across the tree: every undocumented namespace `module` line (what lives under it), and the SkillBase overrides whose meaning is fixed by the base class — setup / register_tools / get_prompt_sections / get_hints / get_global_data / get_parameter_schema / supports_multiple_instances? / version — stating the contract each one satisfies and what the agent does with its return value. DOC-SURFACE ruby: 79.4% -> 86.2% (2903/3366). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/agents/bedrock.rb | 2 ++ lib/signalwire/ai_chat/client.rb | 1 + lib/signalwire/core/agent/prompt/manager.rb | 4 +++ lib/signalwire/core/agent/tools/registry.rb | 3 ++ .../core/agent/tools/type_inference.rb | 3 ++ lib/signalwire/core/auth_handler.rb | 2 ++ lib/signalwire/core/config_loader.rb | 2 ++ lib/signalwire/core/logging_config.rb | 1 + lib/signalwire/core/pom_builder.rb | 2 ++ lib/signalwire/core/security_config.rb | 2 ++ lib/signalwire/datamap/data_map.rb | 1 + lib/signalwire/pom/prompt_object_model.rb | 2 ++ lib/signalwire/pom/section.rb | 1 + lib/signalwire/prefabs/concierge.rb | 2 ++ lib/signalwire/prefabs/faq_bot.rb | 2 ++ lib/signalwire/prefabs/info_gatherer.rb | 2 ++ lib/signalwire/prefabs/receptionist.rb | 2 ++ lib/signalwire/prefabs/survey.rb | 2 ++ lib/signalwire/relay/call.rb | 2 ++ lib/signalwire/relay/collect_config.rb | 2 ++ lib/signalwire/relay/constants.rb | 1 + lib/signalwire/relay/device.rb | 2 ++ lib/signalwire/relay/message.rb | 2 ++ lib/signalwire/rest/http_client.rb | 2 ++ lib/signalwire/rest/pagination.rb | 1 + lib/signalwire/rest/phone_call_handler.rb | 1 + lib/signalwire/rest/request_options.rb | 1 + lib/signalwire/rest/rest_client.rb | 2 ++ lib/signalwire/security/security_utils.rb | 1 + lib/signalwire/security/session_manager.rb | 2 ++ lib/signalwire/security/webhook_middleware.rb | 2 ++ lib/signalwire/security/webhook_validator.rb | 2 ++ lib/signalwire/server/agent_server.rb | 1 + lib/signalwire/serverless/lambda_handler.rb | 2 ++ .../skills/builtin/api_ninjas_trivia.rb | 22 ++++++++++++ .../skills/builtin/claude_skills.rb | 31 +++++++++++++++++ .../skills/builtin/custom_skills.rb | 22 ++++++++++++ lib/signalwire/skills/builtin/datasphere.rb | 31 +++++++++++++++++ .../skills/builtin/datasphere_serverless.rb | 31 +++++++++++++++++ lib/signalwire/skills/builtin/datetime.rb | 14 ++++++++ lib/signalwire/skills/builtin/google_maps.rb | 26 ++++++++++++++ .../skills/builtin/info_gatherer.rb | 31 +++++++++++++++++ lib/signalwire/skills/builtin/joke.rb | 26 ++++++++++++++ lib/signalwire/skills/builtin/math.rb | 14 ++++++++ lib/signalwire/skills/builtin/mcp_gateway.rb | 6 ++++ .../skills/builtin/native_vector_search.rb | 26 ++++++++++++++ .../skills/builtin/play_background_file.rb | 22 ++++++++++++ lib/signalwire/skills/builtin/spider.rb | 26 ++++++++++++++ .../skills/builtin/swml_transfer.rb | 31 +++++++++++++++++ lib/signalwire/skills/builtin/weather_api.rb | 17 ++++++++++ lib/signalwire/skills/builtin/web_search.rb | 34 +++++++++++++++++++ .../skills/builtin/wikipedia_search.rb | 22 ++++++++++++ lib/signalwire/skills/skill_base.rb | 8 +++++ lib/signalwire/skills/skill_manager.rb | 2 ++ lib/signalwire/skills/skill_name.rb | 1 + lib/signalwire/skills/skill_registry.rb | 2 ++ lib/signalwire/swaig/function_result.rb | 2 ++ lib/signalwire/swaig/parameter_schema.rb | 2 ++ lib/signalwire/swaig/swaig_function.rb | 2 ++ lib/signalwire/swml/document.rb | 2 ++ lib/signalwire/swml/schema.rb | 2 ++ lib/signalwire/swml/service.rb | 2 ++ lib/signalwire/swml/swml_builder.rb | 1 + lib/signalwire/swml/swml_handler.rb | 1 + lib/signalwire/swml/swml_renderer.rb | 2 ++ lib/signalwire/utils/schema_utils.rb | 2 ++ lib/signalwire/utils/serverless.rb | 1 + lib/signalwire/utils/url_validator.rb | 2 ++ lib/signalwire/web/web_service.rb | 2 ++ 69 files changed, 530 insertions(+) diff --git a/lib/signalwire/agents/bedrock.rb b/lib/signalwire/agents/bedrock.rb index 9cbcbbce..8f1db80f 100644 --- a/lib/signalwire/agents/bedrock.rb +++ b/lib/signalwire/agents/bedrock.rb @@ -15,7 +15,9 @@ require_relative '../agent/agent_base' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Agents — agent variants built on top of AgentBase. module Agents # Agent implementation for the Amazon Bedrock voice-to-voice model. # diff --git a/lib/signalwire/ai_chat/client.rb b/lib/signalwire/ai_chat/client.rb index 187351a7..51067fec 100644 --- a/lib/signalwire/ai_chat/client.rb +++ b/lib/signalwire/ai_chat/client.rb @@ -14,6 +14,7 @@ require_relative '../version' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire # Namespace holding the AI Chat client's error family and response models. # diff --git a/lib/signalwire/core/agent/prompt/manager.rb b/lib/signalwire/core/agent/prompt/manager.rb index 4c9b5094..7d3111b0 100644 --- a/lib/signalwire/core/agent/prompt/manager.rb +++ b/lib/signalwire/core/agent/prompt/manager.rb @@ -10,9 +10,13 @@ require_relative '../../../pom/prompt_object_model' require_relative '../../../contexts/context_builder' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core + # Agent — the agent internals: prompt management and tool registration. module Agent + # Prompt — prompt construction and management. module Prompt # Manages prompt building and configuration for an agent. # diff --git a/lib/signalwire/core/agent/tools/registry.rb b/lib/signalwire/core/agent/tools/registry.rb index 4a135b91..753bd203 100644 --- a/lib/signalwire/core/agent/tools/registry.rb +++ b/lib/signalwire/core/agent/tools/registry.rb @@ -8,8 +8,11 @@ # Tool registration and management. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core + # Agent — the agent internals: prompt management and tool registration. module Agent + # Tools — SWAIG tool registration and parameter type inference. module Tools # Manages SWAIG function registration. # diff --git a/lib/signalwire/core/agent/tools/type_inference.rb b/lib/signalwire/core/agent/tools/type_inference.rb index 22d6a0dc..46202bc3 100644 --- a/lib/signalwire/core/agent/tools/type_inference.rb +++ b/lib/signalwire/core/agent/tools/type_inference.rb @@ -8,8 +8,11 @@ # Reflection-based schema inference for SWAIG tool functions. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core + # Agent — the agent internals: prompt management and tool registration. module Agent + # Tools — SWAIG tool registration and parameter type inference. module Tools # Infer a JSON Schema for a SWAIG tool's parameters from a Ruby # callable's signature, and wrap a typed handler so it can be diff --git a/lib/signalwire/core/auth_handler.rb b/lib/signalwire/core/auth_handler.rb index 9076cf98..d8fd5d85 100644 --- a/lib/signalwire/core/auth_handler.rb +++ b/lib/signalwire/core/auth_handler.rb @@ -13,7 +13,9 @@ require_relative '../logging' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core # Unified authentication handler supporting multiple auth methods. # diff --git a/lib/signalwire/core/config_loader.rb b/lib/signalwire/core/config_loader.rb index 33e2b657..4364f3f4 100644 --- a/lib/signalwire/core/config_loader.rb +++ b/lib/signalwire/core/config_loader.rb @@ -10,7 +10,9 @@ require 'json' require 'yaml' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core # Configuration loader with environment variable substitution. # diff --git a/lib/signalwire/core/logging_config.rb b/lib/signalwire/core/logging_config.rb index 7a4555d1..6ecfd3e6 100644 --- a/lib/signalwire/core/logging_config.rb +++ b/lib/signalwire/core/logging_config.rb @@ -16,6 +16,7 @@ # lib/signalwire/utils/serverless.rb. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core module LoggingConfig module_function diff --git a/lib/signalwire/core/pom_builder.rb b/lib/signalwire/core/pom_builder.rb index 363426a7..a4067d19 100644 --- a/lib/signalwire/core/pom_builder.rb +++ b/lib/signalwire/core/pom_builder.rb @@ -11,7 +11,9 @@ require_relative '../pom/prompt_object_model' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core # Builder class for creating structured prompts using the Prompt Object # Model. diff --git a/lib/signalwire/core/security_config.rb b/lib/signalwire/core/security_config.rb index 07bf5722..05cb1e83 100644 --- a/lib/signalwire/core/security_config.rb +++ b/lib/signalwire/core/security_config.rb @@ -13,7 +13,9 @@ require_relative 'config_loader' require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core # Unified security configuration for SignalWire services. # diff --git a/lib/signalwire/datamap/data_map.rb b/lib/signalwire/datamap/data_map.rb index e6f979a8..e35a5b98 100644 --- a/lib/signalwire/datamap/data_map.rb +++ b/lib/signalwire/datamap/data_map.rb @@ -7,6 +7,7 @@ require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire # Fluent builder for server-side DataMap tools. # diff --git a/lib/signalwire/pom/prompt_object_model.rb b/lib/signalwire/pom/prompt_object_model.rb index 43693f4d..98c94e43 100644 --- a/lib/signalwire/pom/prompt_object_model.rb +++ b/lib/signalwire/pom/prompt_object_model.rb @@ -5,7 +5,9 @@ require_relative 'section' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # POM — the Prompt Object Model: structured prompt sections rendered to markdown. module POM # A structured data format for composing, organising, and rendering # prompt instructions for large language models. diff --git a/lib/signalwire/pom/section.rb b/lib/signalwire/pom/section.rb index 92c9204b..32d4cf30 100644 --- a/lib/signalwire/pom/section.rb +++ b/lib/signalwire/pom/section.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # POM — the Prompt Object Model: structured prompt sections rendered to markdown. module POM # Represents a section in the Prompt Object Model. # diff --git a/lib/signalwire/prefabs/concierge.rb b/lib/signalwire/prefabs/concierge.rb index 62322977..46808b26 100644 --- a/lib/signalwire/prefabs/concierge.rb +++ b/lib/signalwire/prefabs/concierge.rb @@ -9,7 +9,9 @@ require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Prefabs — ready-made agents assembled from the SDK's own building blocks. module Prefabs # Prefab agent for providing virtual concierge services. # diff --git a/lib/signalwire/prefabs/faq_bot.rb b/lib/signalwire/prefabs/faq_bot.rb index 9f8ca9ac..fbe80a00 100644 --- a/lib/signalwire/prefabs/faq_bot.rb +++ b/lib/signalwire/prefabs/faq_bot.rb @@ -9,7 +9,9 @@ require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Prefabs — ready-made agents assembled from the SDK's own building blocks. module Prefabs # Prefab agent for answering frequently asked questions. # diff --git a/lib/signalwire/prefabs/info_gatherer.rb b/lib/signalwire/prefabs/info_gatherer.rb index 26de6024..f09122ea 100644 --- a/lib/signalwire/prefabs/info_gatherer.rb +++ b/lib/signalwire/prefabs/info_gatherer.rb @@ -8,7 +8,9 @@ require_relative '../agent/agent_base' require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Prefabs — ready-made agents assembled from the SDK's own building blocks. module Prefabs # Prefab agent for collecting answers to a series of questions. # diff --git a/lib/signalwire/prefabs/receptionist.rb b/lib/signalwire/prefabs/receptionist.rb index 6d9410a1..a94b2dff 100644 --- a/lib/signalwire/prefabs/receptionist.rb +++ b/lib/signalwire/prefabs/receptionist.rb @@ -7,7 +7,9 @@ require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Prefabs — ready-made agents assembled from the SDK's own building blocks. module Prefabs # Prefab agent for greeting callers and transferring them to departments. # diff --git a/lib/signalwire/prefabs/survey.rb b/lib/signalwire/prefabs/survey.rb index b875e0d8..32f57d0e 100644 --- a/lib/signalwire/prefabs/survey.rb +++ b/lib/signalwire/prefabs/survey.rb @@ -9,7 +9,9 @@ require_relative '../swaig/function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Prefabs — ready-made agents assembled from the SDK's own building blocks. module Prefabs # @api private — per-question-type answer validation for Survey. Split out # of Survey so the class keeps only its public API + survey state; these diff --git a/lib/signalwire/relay/call.rb b/lib/signalwire/relay/call.rb index 471c0e5e..4d294175 100644 --- a/lib/signalwire/relay/call.rb +++ b/lib/signalwire/relay/call.rb @@ -6,7 +6,9 @@ require_relative 'device' require_relative 'collect_config' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # Represents a live RELAY call. # diff --git a/lib/signalwire/relay/collect_config.rb b/lib/signalwire/relay/collect_config.rb index b98c4646..277addd5 100644 --- a/lib/signalwire/relay/collect_config.rb +++ b/lib/signalwire/relay/collect_config.rb @@ -2,7 +2,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # A typed RELAY +collect+ configuration: the known-shape options object the # input-collection wrappers ({Call#collect}, {Call#play_and_collect}, diff --git a/lib/signalwire/relay/constants.rb b/lib/signalwire/relay/constants.rb index 47968904..466388ec 100644 --- a/lib/signalwire/relay/constants.rb +++ b/lib/signalwire/relay/constants.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # Protocol version sent during signalwire.connect PROTOCOL_VERSION = { 'major' => 2, 'minor' => 0, 'revision' => 0 }.freeze diff --git a/lib/signalwire/relay/device.rb b/lib/signalwire/relay/device.rb index dd7b1707..ef6f807b 100644 --- a/lib/signalwire/relay/device.rb +++ b/lib/signalwire/relay/device.rb @@ -2,7 +2,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # A typed RELAY +device+ descriptor: the +{ "type" => ..., "params" => {...} }+ # object handed to {Call#connect}, {Call#refer}, {Call#tap_audio}, and diff --git a/lib/signalwire/relay/message.rb b/lib/signalwire/relay/message.rb index d4e1f977..d65f64a2 100644 --- a/lib/signalwire/relay/message.rb +++ b/lib/signalwire/relay/message.rb @@ -3,7 +3,9 @@ require 'json' require_relative 'constants' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Relay — the RELAY realtime (WebSocket / JSON-RPC 2.0) client surface. module Relay # JSON serialization, Ruby pattern-matching, and value-equality for # {Message}. Extracted into a mixin so {Message} itself stays focused on diff --git a/lib/signalwire/rest/http_client.rb b/lib/signalwire/rest/http_client.rb index cc0f1565..655cd7cf 100644 --- a/lib/signalwire/rest/http_client.rb +++ b/lib/signalwire/rest/http_client.rb @@ -9,7 +9,9 @@ require_relative '../version' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # REST — the synchronous REST client and its per-namespace resources. module REST # Raised when the SignalWire REST API returns a non-2xx response. # diff --git a/lib/signalwire/rest/pagination.rb b/lib/signalwire/rest/pagination.rb index 23dbec90..8dd9b785 100644 --- a/lib/signalwire/rest/pagination.rb +++ b/lib/signalwire/rest/pagination.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # REST — the synchronous REST client and its per-namespace resources. module REST # Iterates items across paginated API responses. # diff --git a/lib/signalwire/rest/phone_call_handler.rb b/lib/signalwire/rest/phone_call_handler.rb index c055bc22..eb3cd009 100644 --- a/lib/signalwire/rest/phone_call_handler.rb +++ b/lib/signalwire/rest/phone_call_handler.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # REST — the synchronous REST client and its per-namespace resources. module REST # PhoneCallHandler -- enum-like constants of the +call_handler+ values # accepted by +phone_numbers.update+. diff --git a/lib/signalwire/rest/request_options.rb b/lib/signalwire/rest/request_options.rb index ac24c114..b07d9310 100644 --- a/lib/signalwire/rest/request_options.rb +++ b/lib/signalwire/rest/request_options.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # REST — the synchronous REST client and its per-namespace resources. module REST # RequestOptions — the REST request-options envelope (plan 4.2). # diff --git a/lib/signalwire/rest/rest_client.rb b/lib/signalwire/rest/rest_client.rb index 3e6b3400..4c8018ec 100644 --- a/lib/signalwire/rest/rest_client.rb +++ b/lib/signalwire/rest/rest_client.rb @@ -6,7 +6,9 @@ require_relative 'phone_call_handler' require_relative 'namespaces/generated' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # REST — the synchronous REST client and its per-namespace resources. module REST # REST client for the SignalWire platform APIs. # diff --git a/lib/signalwire/security/security_utils.rb b/lib/signalwire/security/security_utils.rb index 51776d8d..a3ad1db0 100644 --- a/lib/signalwire/security/security_utils.rb +++ b/lib/signalwire/security/security_utils.rb @@ -14,6 +14,7 @@ # hostname validation -- are available in every port. module SignalWire + # Security — webhook signature validation, session tokens and request hardening. module Security # Stateless security hygiene helpers exposed as module functions. # diff --git a/lib/signalwire/security/session_manager.rb b/lib/signalwire/security/session_manager.rb index 8089ff87..1083cc1b 100644 --- a/lib/signalwire/security/session_manager.rb +++ b/lib/signalwire/security/session_manager.rb @@ -10,7 +10,9 @@ require 'base64' require 'time' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Security — webhook signature validation, session tokens and request hardening. module Security # Stateless HMAC-SHA256 session manager for secure SWAIG tool tokens. # diff --git a/lib/signalwire/security/webhook_middleware.rb b/lib/signalwire/security/webhook_middleware.rb index 26cd8919..42c1f759 100644 --- a/lib/signalwire/security/webhook_middleware.rb +++ b/lib/signalwire/security/webhook_middleware.rb @@ -37,7 +37,9 @@ require 'rack' require_relative 'webhook_validator' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Security — webhook signature validation, session tokens and request hardening. module Security # Rack middleware that rejects webhook requests with bad signatures. # diff --git a/lib/signalwire/security/webhook_validator.rb b/lib/signalwire/security/webhook_validator.rb index 4cde269e..6d0af1fa 100644 --- a/lib/signalwire/security/webhook_validator.rb +++ b/lib/signalwire/security/webhook_validator.rb @@ -29,7 +29,9 @@ require 'rack/utils' require 'uri' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Security — webhook signature validation, session tokens and request hardening. module Security # Stateless validator for SignalWire-signed webhook requests. # diff --git a/lib/signalwire/server/agent_server.rb b/lib/signalwire/server/agent_server.rb index 26530e64..e20ebe34 100644 --- a/lib/signalwire/server/agent_server.rb +++ b/lib/signalwire/server/agent_server.rb @@ -8,6 +8,7 @@ require 'json' require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire # Multi-agent hosting on a single Rack application. # diff --git a/lib/signalwire/serverless/lambda_handler.rb b/lib/signalwire/serverless/lambda_handler.rb index 485d345f..ebe1208e 100644 --- a/lib/signalwire/serverless/lambda_handler.rb +++ b/lib/signalwire/serverless/lambda_handler.rb @@ -10,7 +10,9 @@ require 'stringio' require 'uri' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Serverless — adapters that run an agent under Lambda / CGI / GCF / Azure. module Serverless # Private mixin: translates a Rack response triple into the Lambda # response-hash shape. Extracted from {LambdaHandler} purely to keep that diff --git a/lib/signalwire/skills/builtin/api_ninjas_trivia.rb b/lib/signalwire/skills/builtin/api_ninjas_trivia.rb index 3383daa0..ca221a5a 100644 --- a/lib/signalwire/skills/builtin/api_ninjas_trivia.rb +++ b/lib/signalwire/skills/builtin/api_ninjas_trivia.rb @@ -3,8 +3,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class ApiNinjasTriviaSkill < SkillBase VALID_CATEGORIES = { @@ -26,6 +29,11 @@ class ApiNinjasTriviaSkill < SkillBase def name = 'api_ninjas_trivia' def description = 'Get trivia questions from API Ninjas' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true # Extracts the configuration (tool_name / api_key / categories) off @@ -38,6 +46,10 @@ def initialize(agent = nil, params = nil) @categories = get_param('categories') || VALID_CATEGORIES.keys end + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @api_key = get_param('api_key', env_var: 'API_NINJAS_KEY') @tool_name = get_param('tool_name', default: 'get_trivia') @@ -64,10 +76,20 @@ def get_tools ] end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools get_tools.map { |tool| { datamap: tool } } end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'api_key' => { 'type' => 'string', 'required' => true, 'hidden' => true, 'env_var' => 'API_NINJAS_KEY' }, diff --git a/lib/signalwire/skills/builtin/claude_skills.rb b/lib/signalwire/skills/builtin/claude_skills.rb index 30e535f6..2e892679 100644 --- a/lib/signalwire/skills/builtin/claude_skills.rb +++ b/lib/signalwire/skills/builtin/claude_skills.rb @@ -4,8 +4,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Loads Claude SKILL.md files as agent tools. # @@ -18,8 +21,17 @@ module Builtin class ClaudeSkillsSkill < SkillBase def name = 'claude_skills' def description = 'Load Claude SKILL.md files as agent tools' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup # Load-path validation (Python parity: validate_packages then the # skills_path exists/is-a-directory checks). @@ -34,20 +46,39 @@ def setup def instance_key = "claude_skills_#{@skills_path}" + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools @discovered.map { |skill| skill_tool(skill) } end + # Speech-recognition hints this skill contributes to the AI verb, biasing + # the recognizer toward the vocabulary the skill's domain uses. + # + # @return [Array] def get_hints @discovered.flat_map { |s| s[:name].split(/[-_]/) }.uniq end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections @discovered.map do |skill| { 'title' => "Claude Skill: #{skill[:name]}", 'body' => skill[:body][0, 200] } end end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'skills_path' => { 'type' => 'string', 'required' => true }, diff --git a/lib/signalwire/skills/builtin/custom_skills.rb b/lib/signalwire/skills/builtin/custom_skills.rb index 2907f0f0..57acdb7e 100644 --- a/lib/signalwire/skills/builtin/custom_skills.rb +++ b/lib/signalwire/skills/builtin/custom_skills.rb @@ -3,15 +3,27 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # User-defined custom tools. class CustomSkillsSkill < SkillBase def name = 'custom_skills' def description = 'Register user-defined custom tools' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @tools_config = get_param('tools') return false unless @tools_config.is_a?(Array) @@ -24,6 +36,12 @@ def instance_key "custom_skills_#{tool_name}" end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools (@tools_config || []).filter_map do |tool_def| next unless tool_def.is_a?(Hash) && tool_def['name'] @@ -32,6 +50,10 @@ def register_tools end end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'tools' => { 'type' => 'array', 'required' => true } diff --git a/lib/signalwire/skills/builtin/datasphere.rb b/lib/signalwire/skills/builtin/datasphere.rb index 1c2d5535..81dc74a8 100644 --- a/lib/signalwire/skills/builtin/datasphere.rb +++ b/lib/signalwire/skills/builtin/datasphere.rb @@ -8,8 +8,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Private mixin holding {DatasphereSkill}'s param parsing, URL building, # search HTTP call, and response formatting. Extracted purely to keep the @@ -117,8 +120,17 @@ class DatasphereSkill < SkillBase def name = 'datasphere' def description = 'Search knowledge using SignalWire DataSphere RAG stack' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup read_params @@ -142,6 +154,12 @@ def cleanup nil end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [ { @@ -158,6 +176,10 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # Data this skill merges into the agent's `global_data`, so its prompts + # and tools can reference the values as `${global_data.*}`. + # + # @return [Hash] def get_global_data { 'datasphere_enabled' => true, @@ -166,6 +188,11 @@ def get_global_data } end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -176,6 +203,10 @@ def get_prompt_sections ] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'space_name' => { 'type' => 'string', 'required' => true }, diff --git a/lib/signalwire/skills/builtin/datasphere_serverless.rb b/lib/signalwire/skills/builtin/datasphere_serverless.rb index 93f80286..ecfde7da 100644 --- a/lib/signalwire/skills/builtin/datasphere_serverless.rb +++ b/lib/signalwire/skills/builtin/datasphere_serverless.rb @@ -6,14 +6,26 @@ require_relative '../skill_registry' require_relative '../../datamap/data_map' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class DatasphereServerlessSkill < SkillBase def name = 'datasphere_serverless' def description = 'Search knowledge using SignalWire DataSphere with serverless DataMap execution' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup load_params return false unless required_params_present? @@ -25,6 +37,12 @@ def setup def instance_key = "datasphere_serverless_#{@tool_name}" + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools dm = DataMap.new(@tool_name) .description('Search the knowledge base for information on any topic and return relevant results') @@ -42,6 +60,10 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # Data this skill merges into the agent's `global_data`, so its prompts + # and tools can reference the values as `${global_data.*}`. + # + # @return [Hash] def get_global_data { 'datasphere_serverless_enabled' => true, @@ -50,6 +72,11 @@ def get_global_data } end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -60,6 +87,10 @@ def get_prompt_sections ] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'space_name' => { 'type' => 'string', 'required' => true }, diff --git a/lib/signalwire/skills/builtin/datetime.rb b/lib/signalwire/skills/builtin/datetime.rb index b0e7b4cc..cd7c2251 100644 --- a/lib/signalwire/skills/builtin/datetime.rb +++ b/lib/signalwire/skills/builtin/datetime.rb @@ -3,8 +3,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class DateTimeSkill < SkillBase TIMEZONE_DESCRIPTION = "Timezone name (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC." @@ -45,6 +48,12 @@ def get_parameter_schema # rubocop:disable Lint/UselessMethodDefinition super end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [get_current_time_tool, get_current_date_tool] end @@ -53,6 +62,11 @@ def register_tools # on the class so it appears on public_instance_methods(false). def get_hints = [] + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections PROMPT_SECTIONS.map(&:dup) end diff --git a/lib/signalwire/skills/builtin/google_maps.rb b/lib/signalwire/skills/builtin/google_maps.rb index 6c4ae7a2..6bf5c76a 100644 --- a/lib/signalwire/skills/builtin/google_maps.rb +++ b/lib/signalwire/skills/builtin/google_maps.rb @@ -7,8 +7,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Private HTTP/formatting helpers for {GoogleMapsSkill}, extracted to # keep the skill class small. Not part of the public skill surface. @@ -95,6 +98,10 @@ class GoogleMapsSkill < SkillBase def name = 'google_maps' def description = 'Validate addresses and compute driving routes using Google Maps' + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @api_key = get_param('api_key', env_var: 'GOOGLE_MAPS_API_KEY') @lookup_tool = get_param('lookup_tool_name', default: 'lookup_address') @@ -104,14 +111,29 @@ def setup true end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [lookup_tool_def, route_tool_def] end + # Speech-recognition hints this skill contributes to the AI verb, biasing + # the recognizer toward the vocabulary the skill's domain uses. + # + # @return [Array] def get_hints %w[address location route directions miles distance] end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -122,6 +144,10 @@ def get_prompt_sections ] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'api_key' => { 'type' => 'string', 'required' => true, 'hidden' => true, diff --git a/lib/signalwire/skills/builtin/info_gatherer.rb b/lib/signalwire/skills/builtin/info_gatherer.rb index e004bc48..71891d6f 100644 --- a/lib/signalwire/skills/builtin/info_gatherer.rb +++ b/lib/signalwire/skills/builtin/info_gatherer.rb @@ -3,8 +3,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Private helpers for {InfoGathererSkill}. Extracted to a mixin so the # skill class stays focused on its public surface (the audit reads the @@ -138,8 +141,17 @@ class InfoGathererSkill < SkillBase def name = 'info_gatherer' def description = 'Gather answers to a configurable list of questions' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @questions = get_param('questions') return false unless valid_questions?(@questions) @@ -155,14 +167,29 @@ def instance_key prefix && !prefix.to_s.empty? ? "info_gatherer_#{prefix}" : 'info_gatherer' end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [start_tool_definition, submit_tool_definition] end + # Data this skill merges into the agent's `global_data`, so its prompts + # and tools can reference the values as `${global_data.*}`. + # + # @return [Hash] def get_global_data { @namespace => { 'questions' => @questions, 'question_index' => 0, 'answers' => [] } } end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -174,6 +201,10 @@ def get_prompt_sections ] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'questions' => { 'type' => 'array', 'required' => true }, 'prefix' => { 'type' => 'string' }, diff --git a/lib/signalwire/skills/builtin/joke.rb b/lib/signalwire/skills/builtin/joke.rb index 5c7fabbd..04f09736 100644 --- a/lib/signalwire/skills/builtin/joke.rb +++ b/lib/signalwire/skills/builtin/joke.rb @@ -4,8 +4,11 @@ require_relative '../skill_registry' require_relative '../../datamap/data_map' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class JokeSkill < SkillBase FALLBACK_MESSAGE = 'Sorry, there is a problem with the joke service right now. ' \ @@ -14,6 +17,10 @@ class JokeSkill < SkillBase def name = 'joke' def description = 'Tell jokes using the API Ninjas joke API' + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @api_key = get_param('api_key', env_var: 'API_NINJAS_KEY') @tool_name = get_param('tool_name', default: 'get_joke') @@ -22,6 +29,12 @@ def setup true end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools dm = DataMap.new(tool_name) .description('Get a random joke from API Ninjas') @@ -38,10 +51,19 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # Data this skill merges into the agent's `global_data`, so its prompts + # and tools can reference the values as `${global_data.*}`. + # + # @return [Hash] def get_global_data { 'joke_skill_enabled' => true } end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -64,6 +86,10 @@ def joke_telling_bullets attr_reader :api_key, :tool_name private :api_key, :tool_name + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'api_key' => { 'type' => 'string', 'required' => true, 'hidden' => true, 'env_var' => 'API_NINJAS_KEY' }, diff --git a/lib/signalwire/skills/builtin/math.rb b/lib/signalwire/skills/builtin/math.rb index b0e15fdf..a16262d4 100644 --- a/lib/signalwire/skills/builtin/math.rb +++ b/lib/signalwire/skills/builtin/math.rb @@ -3,8 +3,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class MathSkill < SkillBase EXPRESSION_DESCRIPTION = "Mathematical expression to evaluate (e.g., '2 + 3 * 4', '(10 + 5) / 3')" @@ -41,6 +44,12 @@ def get_parameter_schema # rubocop:disable Lint/UselessMethodDefinition } ].freeze + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [{ name: 'calculate', @@ -53,6 +62,11 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections PROMPT_SECTIONS.map(&:dup) end diff --git a/lib/signalwire/skills/builtin/mcp_gateway.rb b/lib/signalwire/skills/builtin/mcp_gateway.rb index dfb76dda..285af806 100644 --- a/lib/signalwire/skills/builtin/mcp_gateway.rb +++ b/lib/signalwire/skills/builtin/mcp_gateway.rb @@ -13,8 +13,11 @@ require_relative '../skill_registry' require_relative '../../utils/url_validator' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # MCP Gateway skill — bridges MCP (Model Context Protocol) servers with # SWAIG functions. @@ -31,6 +34,9 @@ module Builtin class MCPGatewaySkill < SkillBase def name = 'mcp_gateway' def description = 'Bridge MCP servers with SWAIG functions' + # This skill's own version, independent of the SDK's. + # + # @return [String] '1.0.0' def version = '1.0.0' # Validate configuration and connectivity. Returns +true+ when the skill diff --git a/lib/signalwire/skills/builtin/native_vector_search.rb b/lib/signalwire/skills/builtin/native_vector_search.rb index 0332f1bf..089e3da9 100644 --- a/lib/signalwire/skills/builtin/native_vector_search.rb +++ b/lib/signalwire/skills/builtin/native_vector_search.rb @@ -7,15 +7,27 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Network/remote mode only (as per porting manifest). class NativeVectorSearchSkill < SkillBase def name = 'native_vector_search' def description = 'Search document indexes using vector similarity and keyword search (local or remote)' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @remote_url = get_param('remote_url') @index_name = get_param('index_name') @@ -38,17 +50,31 @@ def instance_key = "native_vector_search_#{@tool_name}" 'count' => { 'type' => 'integer', 'description' => 'Number of results to return' } }.freeze + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [{ name: @tool_name, description: @tool_desc, parameters: TOOL_PARAMETERS, handler: method(:handle_search) }] end + # Speech-recognition hints this skill contributes to the AI verb, biasing + # the recognizer toward the vocabulary the skill's domain uses. + # + # @return [Array] def get_hints base = ['search', 'find', 'look up', 'documentation', 'knowledge base'] base.concat(@custom_hints) if @custom_hints.is_a?(Array) base end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'remote_url' => { 'type' => 'string', 'required' => true }, diff --git a/lib/signalwire/skills/builtin/play_background_file.rb b/lib/signalwire/skills/builtin/play_background_file.rb index 17bd9eae..14c6cad0 100644 --- a/lib/signalwire/skills/builtin/play_background_file.rb +++ b/lib/signalwire/skills/builtin/play_background_file.rb @@ -3,12 +3,20 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class PlayBackgroundFileSkill < SkillBase def name = 'play_background_file' def description = 'Control background file playback' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true # Extracts the configuration (tool_name / files) off ``params`` at @@ -20,6 +28,10 @@ def initialize(agent = nil, params = nil) @files = get_param('files') end + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @tool_name = get_param('tool_name', default: 'play_background_file') @files = get_param('files') @@ -47,10 +59,20 @@ def get_tools ] end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools get_tools.map { |tool| { datamap: tool } } end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'files' => { 'type' => 'array', 'required' => true, diff --git a/lib/signalwire/skills/builtin/spider.rb b/lib/signalwire/skills/builtin/spider.rb index c54a086a..9cfe7839 100644 --- a/lib/signalwire/skills/builtin/spider.rb +++ b/lib/signalwire/skills/builtin/spider.rb @@ -6,12 +6,20 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class SpiderSkill < SkillBase def name = 'spider' def description = 'Fast web scraping and crawling capabilities' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true # Default user-agent. @@ -55,6 +63,10 @@ def initialize(agent = nil, params = nil) @remove_xpaths = DEFAULT_REMOVE_XPATHS.dup end + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @max_text_length = get_param('max_text_length', default: 10_000).to_i @timeout = get_param('timeout', default: 5).to_i @@ -83,14 +95,28 @@ def instance_key "spider_#{get_param('tool_name', default: 'spider')}" end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [scrape_tool, crawl_tool, extract_tool] end + # Speech-recognition hints this skill contributes to the AI verb, biasing + # the recognizer toward the vocabulary the skill's domain uses. + # + # @return [Array] def get_hints ['scrape', 'crawl', 'extract', 'web page', 'website', 'spider'] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'timeout' => { 'type' => 'integer', 'default' => 5 }, diff --git a/lib/signalwire/skills/builtin/swml_transfer.rb b/lib/signalwire/skills/builtin/swml_transfer.rb index e36759b3..d924fe27 100644 --- a/lib/signalwire/skills/builtin/swml_transfer.rb +++ b/lib/signalwire/skills/builtin/swml_transfer.rb @@ -4,8 +4,11 @@ require_relative '../skill_registry' require_relative '../../datamap/data_map' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class SwmlTransferSkill < SkillBase PARAMETER_SCHEMA = { @@ -18,8 +21,17 @@ class SwmlTransferSkill < SkillBase def name = 'swml_transfer' def description = 'Transfer calls between agents based on pattern matching' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @transfers = get_param('transfers') return false unless @transfers.is_a?(Hash) && !@transfers.empty? @@ -31,6 +43,12 @@ def setup def instance_key = "swml_transfer_#{@tool_name}" + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools dm = build_transfer_data_map @@ -45,12 +63,21 @@ def register_tools [{ datamap: dm.to_swaig_function }] end + # Speech-recognition hints this skill contributes to the AI verb, biasing + # the recognizer toward the vocabulary the skill's domain uses. + # + # @return [Array] def get_hints hints = [] @transfers&.each_key { |pattern| hints.concat(pattern_hints(pattern)) } hints.push('transfer', 'connect', 'speak to', 'talk to') end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections return [] unless @transfers && !@transfers.empty? @@ -62,6 +89,10 @@ def get_prompt_sections [transferring_section(bullets), transfer_instructions_section] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema PARAMETER_SCHEMA end diff --git a/lib/signalwire/skills/builtin/weather_api.rb b/lib/signalwire/skills/builtin/weather_api.rb index af31512f..eb27c3e2 100644 --- a/lib/signalwire/skills/builtin/weather_api.rb +++ b/lib/signalwire/skills/builtin/weather_api.rb @@ -4,8 +4,11 @@ require_relative '../skill_registry' require_relative '../../datamap/data_map' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class WeatherApiSkill < SkillBase def name = 'weather_api' @@ -21,6 +24,10 @@ def initialize(agent = nil, params = nil) @temp_unit = get_param('temperature_unit', default: 'fahrenheit') end + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @api_key = get_param('api_key', env_var: 'WEATHER_API_KEY') @tool_name = get_param('tool_name', default: 'get_weather') @@ -43,6 +50,12 @@ def get_tools ] end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools get_tools.map { |tool| { datamap: tool } } end @@ -112,6 +125,10 @@ def fallback_message public + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'api_key' => { 'type' => 'string', 'required' => true, 'hidden' => true, diff --git a/lib/signalwire/skills/builtin/web_search.rb b/lib/signalwire/skills/builtin/web_search.rb index 6a3b875e..82e95360 100644 --- a/lib/signalwire/skills/builtin/web_search.rb +++ b/lib/signalwire/skills/builtin/web_search.rb @@ -7,8 +7,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin # Private mixin: {WebSearchSkill}'s search orchestration + scrape loop. # Extracted purely to keep the skill class within the size budget; every @@ -381,9 +384,21 @@ class WebSearchSkill < SkillBase def name = 'web_search' def description = 'Search the web for information using Google Custom Search API' + # This skill's own version, independent of the SDK's. + # + # @return [String] '2.0.0' def version = '2.0.0' + # This skill may be loaded more than once on one agent — each instance + # is distinguished by its `prefix` param, which also namespaces its + # tools and its slice of `global_data`. + # + # @return [Boolean] true def supports_multiple_instances? = true + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup read_core_params read_latency_params @@ -396,6 +411,12 @@ def setup def instance_key = "web_search_#{tool_name}" + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [ { @@ -410,10 +431,19 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # Data this skill merges into the agent's `global_data`, so its prompts + # and tools can reference the values as `${global_data.*}`. + # + # @return [Hash] def get_global_data { 'web_search_enabled' => true, 'search_provider' => 'Google Custom Search', 'quality_filtering' => true } end + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections [ { @@ -424,6 +454,10 @@ def get_prompt_sections ] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema core_parameter_schema.merge(latency_parameter_schema) end diff --git a/lib/signalwire/skills/builtin/wikipedia_search.rb b/lib/signalwire/skills/builtin/wikipedia_search.rb index 4ac2033c..0e1c4228 100644 --- a/lib/signalwire/skills/builtin/wikipedia_search.rb +++ b/lib/signalwire/skills/builtin/wikipedia_search.rb @@ -7,8 +7,11 @@ require_relative '../skill_base' require_relative '../skill_registry' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills + # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin class WikipediaSearchSkill < SkillBase def name = 'wikipedia_search' @@ -17,12 +20,22 @@ def description = 'Search Wikipedia for information about a topic and get articl DEFAULT_NO_RESULTS_MSG = "I couldn't find any Wikipedia articles for that query. " \ 'Try rephrasing your search or using different keywords.' + # Called once after construction. Return false to abort loading — the + # agent then refuses to register this skill's tools. + # + # @return [Boolean] true when the skill is ready to run def setup @num_results = [1, get_param('num_results', default: 1).to_i].max @no_results_msg = get_param('no_results_message', default: DEFAULT_NO_RESULTS_MSG) true end + # The SWAIG tool definitions this skill contributes to its agent. Each + # entry is a `{name:, description:, parameters:, handler:}` hash; the + # descriptions are what the model reads to decide when and how to call + # the tool. + # + # @return [Array] def register_tools [ { @@ -39,6 +52,11 @@ def register_tools # Returns [] — this skill ships no example hints. def get_hints = [] + # The POM sections this skill contributes to the agent's prompt, + # teaching the model when to reach for the skill's tools. Returned as + # fresh copies, so a caller mutating them does not corrupt skill state. + # + # @return [Array] def get_prompt_sections body = 'You can search Wikipedia for factual information using search_wiki. ' \ "This will return up to #{num_results} Wikipedia article summaries." @@ -50,6 +68,10 @@ def get_prompt_sections [{ 'title' => 'Wikipedia Search', 'body' => body, 'bullets' => bullets }] end + # The JSON-Schema description of this skill's configuration params, for + # GUI and validation consumers. + # + # @return [Hash] def get_parameter_schema { 'num_results' => { 'type' => 'integer', 'default' => 1, 'min' => 1, 'max' => 5 }, diff --git a/lib/signalwire/skills/skill_base.rb b/lib/signalwire/skills/skill_base.rb index c35c964c..5264d0b3 100644 --- a/lib/signalwire/skills/skill_base.rb +++ b/lib/signalwire/skills/skill_base.rb @@ -8,7 +8,9 @@ require_relative '../swaig/function_result' require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills # Base class for all skills. Subclasses override the metadata methods # and +register_tools+ to supply tool hashes. @@ -23,12 +25,18 @@ class SkillBase def name = raise(NotImplementedError, "#{self.class}#name") def description = raise(NotImplementedError, "#{self.class}#description") + # This skill's own version, independent of the SDK's. + # + # @return [String] '1.0.0' def version = '1.0.0' def required_env_vars = [] # The gem names this skill needs loadable before it can run; # consumed by {#validate_packages}. def required_packages = [] private :required_packages # internal hook; not part of the public API + # Only one instance of this skill may be loaded per agent. + # + # @return [Boolean] false def supports_multiple_instances? = false # First positional arg is the owning AgentBase (or nil for diff --git a/lib/signalwire/skills/skill_manager.rb b/lib/signalwire/skills/skill_manager.rb index 0a5ffdd4..8655278c 100644 --- a/lib/signalwire/skills/skill_manager.rb +++ b/lib/signalwire/skills/skill_manager.rb @@ -8,7 +8,9 @@ require_relative 'skill_base' require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills # Thread-safe lifecycle manager for loaded skill instances. # diff --git a/lib/signalwire/skills/skill_name.rb b/lib/signalwire/skills/skill_name.rb index ac74ebba..8f90638f 100644 --- a/lib/signalwire/skills/skill_name.rb +++ b/lib/signalwire/skills/skill_name.rb @@ -6,6 +6,7 @@ # See LICENSE file in the project root for full license information. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills # Named constants for the skills that ship built in with this gem. # diff --git a/lib/signalwire/skills/skill_registry.rb b/lib/signalwire/skills/skill_registry.rb index f963d44c..e0e08924 100644 --- a/lib/signalwire/skills/skill_registry.rb +++ b/lib/signalwire/skills/skill_registry.rb @@ -8,7 +8,9 @@ require_relative '../logging' require_relative 'skill_name' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Skills — the modular capability framework: skill base, registry, manager, builtins. module Skills # @api private — class-method helpers that introspect registered skill # factories. Extracted from {SkillRegistry} (which +extend+s it) so the diff --git a/lib/signalwire/swaig/function_result.rb b/lib/signalwire/swaig/function_result.rb index ea5c4732..7abfc614 100644 --- a/lib/signalwire/swaig/function_result.rb +++ b/lib/signalwire/swaig/function_result.rb @@ -7,7 +7,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Swaig — the SWAIG function-call surface: results, actions and typed payloads. module Swaig # ------------------------------------------------------------------ # Closed-set vocabularies for SWAIG verbs. diff --git a/lib/signalwire/swaig/parameter_schema.rb b/lib/signalwire/swaig/parameter_schema.rb index 80696929..9c5989fb 100644 --- a/lib/signalwire/swaig/parameter_schema.rb +++ b/lib/signalwire/swaig/parameter_schema.rb @@ -7,7 +7,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Swaig — the SWAIG function-call surface: results, actions and typed payloads. module Swaig # ------------------------------------------------------------------ # ParameterSchema — a typed, block-DSL builder for SWAIG tool diff --git a/lib/signalwire/swaig/swaig_function.rb b/lib/signalwire/swaig/swaig_function.rb index ba05b0f0..548bf27f 100644 --- a/lib/signalwire/swaig/swaig_function.rb +++ b/lib/signalwire/swaig/swaig_function.rb @@ -15,7 +15,9 @@ require_relative 'function_result' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Swaig — the SWAIG function-call surface: results, actions and typed payloads. module Swaig # Represents a SWAIG function — a tool the AI model can call. class SWAIGFunction diff --git a/lib/signalwire/swml/document.rb b/lib/signalwire/swml/document.rb index 72b9d5c7..a326e3af 100644 --- a/lib/signalwire/swml/document.rb +++ b/lib/signalwire/swml/document.rb @@ -2,7 +2,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML class Document attr_reader :version, :sections diff --git a/lib/signalwire/swml/schema.rb b/lib/signalwire/swml/schema.rb index ad33d3c6..5621af75 100644 --- a/lib/signalwire/swml/schema.rb +++ b/lib/signalwire/swml/schema.rb @@ -2,7 +2,9 @@ require 'json' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML class Schema attr_reader :verbs diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 7ab3f056..743ddce3 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -8,7 +8,9 @@ require_relative 'document' require_relative 'schema' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML # rubocop:disable Metrics/ClassLength -- one Python class (SWMLService): the # full public surface (tool registry, auth helpers, verb auto-vivification, diff --git a/lib/signalwire/swml/swml_builder.rb b/lib/signalwire/swml/swml_builder.rb index 2b998a47..ebb8740c 100644 --- a/lib/signalwire/swml/swml_builder.rb +++ b/lib/signalwire/swml/swml_builder.rb @@ -14,6 +14,7 @@ # PHP SignalWire\SWML\SWMLBuilder. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML # Fluent builder for SWML documents. # diff --git a/lib/signalwire/swml/swml_handler.rb b/lib/signalwire/swml/swml_handler.rb index f10d4c7c..f50ea186 100644 --- a/lib/signalwire/swml/swml_handler.rb +++ b/lib/signalwire/swml/swml_handler.rb @@ -14,6 +14,7 @@ # AIVerbHandler, VerbHandlerRegistry}. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML # Base interface for SWML verb handlers. # diff --git a/lib/signalwire/swml/swml_renderer.rb b/lib/signalwire/swml/swml_renderer.rb index 7a579296..6b084d7c 100644 --- a/lib/signalwire/swml/swml_renderer.rb +++ b/lib/signalwire/swml/swml_renderer.rb @@ -14,7 +14,9 @@ require_relative 'swml_builder' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # SWML — SWML document construction, rendering and serving. module SWML # Renders SWML documents for SignalWire AI Agents with AI and SWAIG # components, built on top of the SWML::Service document model. diff --git a/lib/signalwire/utils/schema_utils.rb b/lib/signalwire/utils/schema_utils.rb index ba3fbfdb..74cf76e7 100644 --- a/lib/signalwire/utils/schema_utils.rb +++ b/lib/signalwire/utils/schema_utils.rb @@ -8,7 +8,9 @@ require 'json' require_relative '../error' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Utils — small shared helpers with no dependency on the agent surface. module Utils # SchemaValidationError — Ruby port of # signalwire.utils.schema_utils.SchemaValidationError. diff --git a/lib/signalwire/utils/serverless.rb b/lib/signalwire/utils/serverless.rb index e2c4f217..b383ef58 100644 --- a/lib/signalwire/utils/serverless.rb +++ b/lib/signalwire/utils/serverless.rb @@ -8,6 +8,7 @@ # environment (i.e. not 'server'). module SignalWire + # Utils — small shared helpers with no dependency on the agent surface. module Utils module_function diff --git a/lib/signalwire/utils/url_validator.rb b/lib/signalwire/utils/url_validator.rb index 4045a7cf..5bddb07c 100644 --- a/lib/signalwire/utils/url_validator.rb +++ b/lib/signalwire/utils/url_validator.rb @@ -11,7 +11,9 @@ require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Utils — small shared helpers with no dependency on the agent surface. module Utils # SSRF-prevention guard for user-supplied URLs. # diff --git a/lib/signalwire/web/web_service.rb b/lib/signalwire/web/web_service.rb index 03c231f4..92a33552 100644 --- a/lib/signalwire/web/web_service.rb +++ b/lib/signalwire/web/web_service.rb @@ -15,7 +15,9 @@ require_relative '../core/security_config' require_relative '../logging' +# SignalWire — root namespace of the Ruby SDK. module SignalWire + # Web — the HTTP serving layer shared by the agent and the multi-agent server. module Web # Static file serving service with an HTTP API. # From 9840e4da79030a221f0a35d44892cf0d3beadc33 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:54:14 -0400 Subject: [PATCH 33/90] docs(rest,relay,core,web): http_client, call, security_config, web_service (79 decls) http_client.rb: the verb methods (params/body/request_options and what a 204 returns), the retry driver and its transport-vs-status retry split, TLS configuration (always VERIFY_PEER, never VERIFY_NONE), and the CRUD resource bases including why update() picks PATCH vs PUT. call.rb: the constructor's identity fields and the remaining RELAY control methods, naming the wire method each sends. security_config.rb: the defaults/env/config-file layering and the fact that ssl_enabled needs an explicit true/1/yes while HSTS is opt-OUT. web_service.rb: the constructor's serving policy, the path-traversal containment check in handle_request, the block-list matching rule, and the RFC 7235/7617 details of the basic-auth comparison. DOC-SURFACE ruby: 86.2% -> 88.6% (2982/3366). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/core/security_config.rb | 47 +++++++++ lib/signalwire/relay/call.rb | 96 ++++++++++++++++++ lib/signalwire/rest/http_client.rb | 132 +++++++++++++++++++++++++ lib/signalwire/web/web_service.rb | 67 +++++++++++++ 4 files changed, 342 insertions(+) diff --git a/lib/signalwire/core/security_config.rb b/lib/signalwire/core/security_config.rb index 05cb1e83..1a6a58e5 100644 --- a/lib/signalwire/core/security_config.rb +++ b/lib/signalwire/core/security_config.rb @@ -161,12 +161,16 @@ def log_config(service_name) private + # @api private — the memoized `security_config` logger. def logger return @logger if defined?(@logger) @logger = SignalWire::Logging.logger('security_config') end + # @api private — a one-line summary of the effective security settings for the + # startup log. Reports only WHETHER basic auth is configured — never the + # username or password. def config_summary has_basic_auth = !(basic_auth_user.nil? || basic_auth_password.nil?) "ssl_enabled=#{ssl_enabled} domain=#{domain.inspect} allowed_hosts=#{allowed_hosts.inspect} " \ @@ -174,6 +178,8 @@ def config_summary "rate_limit=#{rate_limit} use_hsts=#{use_hsts} has_basic_auth=#{has_basic_auth}" end + # @api private — seed every setting from DEFAULTS (secure-by-default) before + # the environment and config file are layered on top. Basic auth starts unset. def set_defaults set_ssl_defaults set_host_defaults @@ -183,6 +189,9 @@ def set_defaults self.basic_auth_password = nil end + # @api private — the host/limit defaults: allowed hosts and CORS origins both + # wide open (`*`), a 10 MiB request cap, 60 requests/minute, and a 30-second + # request timeout. def set_host_defaults self.allowed_hosts = parse_list(DEFAULTS[ALLOWED_HOSTS]) self.cors_origins = parse_list(DEFAULTS[CORS_ORIGINS]) @@ -191,6 +200,8 @@ def set_host_defaults self.request_timeout = DEFAULTS[REQUEST_TIMEOUT] end + # @api private — the TLS defaults: disabled, no cert/key/domain, and + # CERT_REQUIRED verification for when it is turned on. def set_ssl_defaults self.ssl_enabled = DEFAULTS[SSL_ENABLED] self.ssl_cert_path = nil @@ -199,6 +210,9 @@ def set_ssl_defaults self.ssl_verify_mode = DEFAULTS[SSL_VERIFY_MODE] end + # @api private — read the TLS settings from the environment. `ssl_enabled` is + # true only for an explicit `true`/`1`/`yes` (case-insensitive), so any other + # value leaves TLS OFF rather than accidentally enabling it. def load_ssl_from_env self.ssl_enabled = %w[true 1 yes].include?(ENV[SSL_ENABLED].to_s.downcase) self.ssl_cert_path = ENV.fetch(SSL_CERT_PATH, nil) @@ -207,6 +221,9 @@ def load_ssl_from_env self.ssl_verify_mode = ENV.fetch(SSL_VERIFY_MODE, DEFAULTS[SSL_VERIFY_MODE]) end + # @api private — read the host/limit settings from the environment, falling + # back to DEFAULTS for each unset variable. The three numeric limits are + # coerced with `to_i`. def load_hosts_from_env self.allowed_hosts = parse_list(env_or_default(ALLOWED_HOSTS)) self.cors_origins = parse_list(env_or_default(CORS_ORIGINS)) @@ -215,16 +232,28 @@ def load_hosts_from_env self.request_timeout = env_or_default(REQUEST_TIMEOUT).to_i end + # @api private — the named environment variable, or its DEFAULTS entry. + # + # @param key [String] the environment variable name, which is also its DEFAULTS key def env_or_default(key) ENV.fetch(key, DEFAULTS[key]) end + # @api private — read the HSTS settings from the environment. An unset + # `SWML_USE_HSTS` keeps the default (on); anything other than the literal + # `"false"` also leaves it on — HSTS is opt-OUT, not opt-in. def load_hsts_from_env use_hsts_env = ENV[USE_HSTS].to_s.downcase self.use_hsts = use_hsts_env.empty? ? DEFAULTS[USE_HSTS] : (use_hsts_env != 'false') self.hsts_max_age = ENV.fetch(HSTS_MAX_AGE, DEFAULTS[HSTS_MAX_AGE]).to_i end + # @api private — layer the config file's `security` section over the + # environment. Falls back to the service's discovered config file when none was + # passed; a missing file or an absent/empty section is a no-op. + # + # @param config_file [String, nil] explicit path, or nil to auto-discover + # @param service_name [String] used for config-file discovery def load_config_file(config_file, service_name) config_file ||= ConfigLoader.find_config_file(service_name) return unless config_file @@ -238,6 +267,8 @@ def load_config_file(config_file, service_name) apply_security_section(section) end + # @api private — apply the four sub-sections of a `security` config block: + # ssl, hosts/limits, hsts and auth. def apply_security_section(section) apply_ssl_section(section) apply_hosts_section(section) @@ -245,6 +276,9 @@ def apply_security_section(section) apply_auth_section(section) end + # @api private — apply the TLS keys from a config section. Each is applied only + # when the key is PRESENT, so an explicit `false` overrides while an absent key + # leaves the environment-derived value alone. def apply_ssl_section(section) self.ssl_enabled = section['ssl_enabled'] if section.key?('ssl_enabled') self.ssl_cert_path = section['ssl_cert_path'] if section.key?('ssl_cert_path') @@ -253,23 +287,31 @@ def apply_ssl_section(section) self.ssl_verify_mode = section['ssl_verify_mode'] if section.key?('ssl_verify_mode') end + # @api private — apply `allowed_hosts` / `cors_origins` (comma-separated string + # or list) from a config section, then the numeric limits. def apply_hosts_section(section) self.allowed_hosts = parse_list(section['allowed_hosts']) if section.key?('allowed_hosts') self.cors_origins = parse_list(section['cors_origins']) if section.key?('cors_origins') apply_int_section(section) end + # @api private — apply the numeric limits (`max_request_size`, `rate_limit`, + # `request_timeout`) from a config section, each coerced with `to_i`. def apply_int_section(section) self.max_request_size = section['max_request_size'].to_i if section.key?('max_request_size') self.rate_limit = section['rate_limit'].to_i if section.key?('rate_limit') self.request_timeout = section['request_timeout'].to_i if section.key?('request_timeout') end + # @api private — apply `use_hsts` / `hsts_max_age` from a config section. def apply_hsts_section(section) self.use_hsts = section['use_hsts'] if section.key?('use_hsts') self.hsts_max_age = section['hsts_max_age'].to_i if section.key?('hsts_max_age') end + # @api private — apply `security.auth.basic.user` / `.password` from a config + # section. A missing or non-Hash `auth`/`basic` block leaves the credentials + # unchanged rather than clearing them. def apply_auth_section(section) auth_config = section['auth'] return unless auth_config.is_a?(Hash) @@ -289,6 +331,11 @@ def parse_list(value) value.split(',').map(&:strip).reject(&:empty?) end + # @api private — warn ONCE that no basic-auth password was configured and a + # random one was generated. That password exists only in this process, so + # external callers get 401 unless they read it from this process's environment. + # + # @param username [String] the username the generated password pairs with def warn_basic_auth_autogen(username) return if @basic_auth_autogen_warned diff --git a/lib/signalwire/relay/call.rb b/lib/signalwire/relay/call.rb index 4d294175..c288699e 100644 --- a/lib/signalwire/relay/call.rb +++ b/lib/signalwire/relay/call.rb @@ -19,6 +19,17 @@ class Call :direction, :device, :segment_id attr_accessor :state + # @param client [Client] the RelayClient this call's RPCs are sent through + # @param call_id [String] the server's identifier for this call leg + # @param node_id [String] the RELAY node that owns the call; part of how the + # platform addresses it + # @param project_id [String] the SignalWire project the call belongs to + # @param context [String] the context the call arrived on (inbound) + # @param tag [String] the caller-supplied correlation tag, when one was set + # @param direction [String] `"inbound"` or `"outbound"` + # @param device [Hash] the raw device descriptor for this leg + # @param state [String] the call's current state (see {CallState}) + # @param segment_id [String] the call-segment identifier def initialize(client, call_id:, node_id:, project_id: '', context: '', tag: '', direction: '', device: {}, state: '', segment_id: '') @client = client @@ -170,6 +181,10 @@ def block_until(condition, mutex, timeout) end end + # Whether the call has reached its terminal state. Non-blocking, unlike the + # `wait_for_*` helpers. + # + # @return [Boolean] def ended? @ended end @@ -325,10 +340,18 @@ def answer(**kwargs) _execute('answer', kwargs.empty? ? nil : kwargs.transform_keys(&:to_s)) end + # End the call by sending the RELAY `calling.end` method. + # + # @param reason [String] why the call is ending, sent as the `reason` wire param + # @return [Hash] the server's result def hangup(reason: 'hangup') _execute('end', { 'reason' => reason }) end + # Hand the call back to the platform's dial plan without answering it, so + # another consumer (or the next route) can take it. Sends `calling.pass`. + # + # @return [Hash] the server's result def pass_call _execute('pass') end @@ -343,6 +366,10 @@ def connect(devices:, **kwargs) _execute('connect', params) end + # Tear down a peer connection established by {#connect}, leaving this leg up. + # Sends `calling.disconnect`. + # + # @return [Hash] the server's result def disconnect _execute('disconnect') end @@ -355,6 +382,9 @@ def hold _execute('hold') end + # Take the call off hold, resuming two-way media. Sends `calling.unhold`. + # + # @return [Hash] the server's result def unhold _execute('unhold') end @@ -367,6 +397,9 @@ def denoise _execute('denoise') end + # Stop background-noise reduction on the call. Sends `calling.denoise.stop`. + # + # @return [Hash] the server's result def denoise_stop _execute('denoise.stop') end @@ -391,6 +424,11 @@ def join_conference(name:, **kwargs) _execute('join_conference', params) end + # Remove this call from a conference it joined. Sends + # `calling.leave_conference`. + # + # @param conference_id [String] the conference to leave + # @return [Hash] the server's result def leave_conference(conference_id:) _execute('leave_conference', { 'conference_id' => conference_id }) end @@ -413,6 +451,11 @@ def bind_digit(digits:, bind_method:, **kwargs) _execute('bind_digit', params) end + # Remove every DTMF binding registered via {#bind_digit}, so digits stop + # triggering their bound behaviour. Sends `calling.clear_digit_bindings`. + # + # @param kwargs [Hash] extra wire params, keys stringified; omitted when empty + # @return [Hash] the server's result def clear_digit_bindings(**kwargs) _execute('clear_digit_bindings', kwargs.empty? ? nil : kwargs.transform_keys(&:to_s)) end @@ -428,6 +471,12 @@ def queue_enter(queue_name:, control_id: nil, **kwargs) _execute('queue.enter', params) end + # Remove the call from a queue it entered. Sends `calling.queue.leave`. + # + # @param queue_name [String] the queue to leave + # @param control_id [String, nil] correlation id; a fresh UUID is minted when omitted + # @param kwargs [Hash] extra wire params, keys stringified + # @return [Hash] the server's result def queue_leave(queue_name:, control_id: nil, **kwargs) cid = control_id || SecureRandom.uuid params = { 'control_id' => cid, 'queue_name' => queue_name } @@ -466,6 +515,12 @@ def live_transcribe(action:, **kwargs) _execute('live_transcribe', params) end + # Start, stop or reconfigure real-time translation on the call. Sends + # `calling.live_translate`. + # + # @param action [String] the operation to perform, sent as the `action` wire param + # @param kwargs [Hash] the translation configuration, keys stringified + # @return [Hash] the server's result def live_translate(action:, **kwargs) params = { 'action' => action } kwargs.each { |k, v| params[k.to_s] = v } @@ -482,6 +537,9 @@ def join_room(name:, **kwargs) _execute('join_room', params) end + # Remove this call from a video room it joined. Sends `calling.leave_room`. + # + # @return [Hash] the server's result def leave_room _execute('leave_room') end @@ -505,14 +563,28 @@ def ai_message(**kwargs) _execute('ai_message', kwargs.transform_keys(&:to_s)) end + # Put the AI agent attached to this call on hold, so it stops responding while + # the leg stays up. Sends `calling.ai_hold`. + # + # @param kwargs [Hash] extra wire params, keys stringified; omitted when empty + # @return [Hash] the server's result def ai_hold(**kwargs) _execute('ai_hold', kwargs.empty? ? nil : kwargs.transform_keys(&:to_s)) end + # Resume an AI agent that was held by {#ai_hold}. Sends `calling.ai_unhold`. + # + # @param kwargs [Hash] extra wire params, keys stringified; omitted when empty + # @return [Hash] the server's result def ai_unhold(**kwargs) _execute('ai_unhold', kwargs.empty? ? nil : kwargs.transform_keys(&:to_s)) end + # Attach an Amazon Bedrock AI agent to the call. This is its own RELAY method + # (`calling.amazon_bedrock`), not `calling.ai` with an engine parameter. + # + # @param kwargs [Hash] the Bedrock agent configuration, keys stringified + # @return [Hash] the server's result def amazon_bedrock(**kwargs) _execute('amazon_bedrock', kwargs.transform_keys(&:to_s)) end @@ -611,6 +683,15 @@ def play_and_collect(media, collect, volume: nil, control_id: nil, start_action(action, 'play_and_collect', params, on_completed: on_completed) end + # Collect caller input WITHOUT playing a prompt first, for when the prompt was + # played separately. Sends `calling.collect` and returns immediately. + # + # @param collect_opts [Hash] the collect configuration (digits / speech rules), + # merged into the wire params with its keys stringified + # @param control_id [String, nil] correlation id; a fresh UUID is minted when omitted + # @param on_completed [Proc, nil] invoked with the terminal event when the collect finishes + # @param kwargs [Hash] extra wire params, keys stringified + # @return [StandaloneCollectAction] a handle to wait on or stop def collect(collect_opts, control_id: nil, on_completed: nil, **kwargs) cid = control_id || SecureRandom.uuid params = { 'control_id' => cid } @@ -725,6 +806,13 @@ def send_fax(document:, control_id: nil, on_completed: nil, **kwargs) start_action(action, 'send_fax', params, on_completed: on_completed) end + # Start receiving an inbound fax on this call. Sends `calling.receive_fax` and + # returns immediately. + # + # @param control_id [String, nil] correlation id; a fresh UUID is minted when omitted + # @param on_completed [Proc, nil] invoked with the terminal event when the fax finishes + # @param kwargs [Hash] extra wire params, keys stringified + # @return [FaxAction] a handle to wait on or stop def receive_fax(control_id: nil, on_completed: nil, **kwargs) cid = control_id || SecureRandom.uuid params = { 'control_id' => cid } @@ -793,10 +881,18 @@ def ai(control_id: nil, on_completed: nil, **kwargs) start_action(action, 'ai', params, on_completed: on_completed) end + # A short human-readable summary: the call id, its current state and its + # direction. Carries no credentials. + # + # @return [String] def to_s "Call(id=#{call_id}, state=#{@state}, direction=#{direction})" end + # Same as {#to_s} — the default `#inspect` would dump every ivar including the + # owning client. + # + # @return [String] def inspect to_s end diff --git a/lib/signalwire/rest/http_client.rb b/lib/signalwire/rest/http_client.rb index 655cd7cf..52a46ebe 100644 --- a/lib/signalwire/rest/http_client.rb +++ b/lib/signalwire/rest/http_client.rb @@ -32,6 +32,14 @@ class SignalWireRestError < SignalWire::Error x-request-id x-signalwire-request-id request-id x-amzn-requestid ].freeze + # @param status_code [Integer, nil] the HTTP status, or nil for a transport + # failure that never produced a response + # @param body [Object] the decoded error body, or the transport error's message + # @param url [String] the FULL request URL that failed — scheme, host, path and + # query, exactly what went on the wire + # @param method_name [String] the HTTP method, e.g. "POST" + # @param headers [Hash, nil] the response headers, or nil for a transport error; + # the platform request id is pulled from them into {#request_id} def initialize(status_code, body, url, method_name = 'GET', headers = nil) @status_code = status_code @body = body @@ -44,6 +52,10 @@ def initialize(status_code, body, url, method_name = 'GET', headers = nil) private + # @api private — compose the exception message. A nil status reads as "failed + # to reach the server" rather than a status line, and the platform request id + # is appended when one was found — that id is what support needs to trace the + # call server-side. def build_message base = if @status_code.nil? "#{@method_name} #{@url} failed to reach the server: #{@body}" @@ -74,6 +86,9 @@ def extract_request_id(headers) # with one +rescue+, instead of a bare +Errno::ECONNREFUSED+ / +SocketError+ # / +Net::OpenTimeout+ leaking out of the REST client. class SignalWireRestTransportError < SignalWireRestError + # @param body [String] the underlying transport error's message + # @param url [String] the full request URL that failed + # @param method_name [String] the HTTP method, e.g. "GET" def initialize(body, url, method_name = 'GET') super(nil, body, url, method_name) end @@ -86,19 +101,30 @@ def initialize(body, url, method_name = 'GET') class Attempt attr_reader :value + # A completed attempt carrying the decoded success body. + # + # @param value [Object] the value {HttpClient#request} returns to the caller + # @return [Attempt] def self.done(value) new(true, value) end + # An attempt that should be retried. Backoff has ALREADY been slept by the + # time this is constructed, so the caller loops immediately. + # + # @return [Attempt] def self.retry new(false, nil) end + # @param done [Boolean] whether the retry loop is finished + # @param value [Object, nil] the success body when done, nil when retrying def initialize(done, value) @done = done @value = value end + # @return [Boolean] true when the retry loop should stop and return {#value} def done? @done end @@ -174,22 +200,58 @@ def inspect end alias to_s inspect + # Issue a GET. + # + # @param path [String] path appended to the client's base URL + # @param params [Hash, nil] query parameters; omitted from the URL when nil or empty + # @param request_options [RequestOptions, nil] per-request overrides of the + # client's timeout / retries / backoff / abort signal + # @return [Hash] the decoded JSON body, or `{}` for a 204 / empty body + # @raise [SignalWireRestError] on a non-2xx response or a transport failure def get(path, params = nil, request_options: nil) request('GET', path, params: params, request_options: request_options) end + # Issue a POST with a JSON body. + # + # @param path [String] path appended to the client's base URL + # @param body [Hash, nil] serialized as the JSON request body + # @param params [Hash, nil] query parameters + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded JSON body, or `{}` for a 204 / empty body + # @raise [SignalWireRestError] on a non-2xx response or a transport failure def post(path, body = nil, params: nil, request_options: nil) request('POST', path, body: body, params: params, request_options: request_options) end + # Issue a PUT with a JSON body — a full replacement of the resource. + # + # @param path [String] path appended to the client's base URL + # @param body [Hash, nil] serialized as the JSON request body + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded JSON body, or `{}` for a 204 / empty body + # @raise [SignalWireRestError] on a non-2xx response or a transport failure def put(path, body = nil, request_options: nil) request('PUT', path, body: body, request_options: request_options) end + # Issue a PATCH with a JSON body — a partial update of the resource. + # + # @param path [String] path appended to the client's base URL + # @param body [Hash, nil] serialized as the JSON request body + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded JSON body, or `{}` for a 204 / empty body + # @raise [SignalWireRestError] on a non-2xx response or a transport failure def patch(path, body = nil, request_options: nil) request('PATCH', path, body: body, request_options: request_options) end + # Issue a DELETE. + # + # @param path [String] path appended to the client's base URL + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded JSON body, or `{}` for a 204 / empty body + # @raise [SignalWireRestError] on a non-2xx response or a transport failure def delete(path, request_options: nil) request('DELETE', path, request_options: request_options) end @@ -237,6 +299,13 @@ def loopback_host?(host) %w[127.0.0.1 localhost ::1 [::1]].include?(hostname) end + # @api private — the retry driver every verb funnels through. Composes the + # absolute URL, resolves the client-default and per-request options, then loops + # attempts until one is done. The abort signal is checked cooperatively before + # each attempt. Errors carry the FULL request URL, not the bare path. + # + # @return [Object] the decoded success body + # @raise [SignalWireRestError] terminal HTTP error, or {SignalWireRestTransportError} def request(method, path, body: nil, params: nil, request_options: nil) uri = build_uri(path, params) opts = RequestOptions.resolve(@request_options, request_options) @@ -285,6 +354,12 @@ def check_abort!(opts, url, method) raise SignalWireRestTransportError.new('request cancelled by abort_signal', url, method) end + # @api private — decide whether a TRANSPORT failure gets another attempt. A + # transport error means the request never reached the server, so it is retried + # regardless of method idempotency. Sleeps the exponential backoff before + # returning true, so the caller loops immediately. + # + # @return [Boolean] true when a retry was scheduled def retry_transport?(opts, attempt) return false unless attempt <= opts.retries @@ -371,12 +446,19 @@ def retry_after_seconds(response) nil end + # @api private — compose the absolute request URI from the client's base URL + # and +path+, attaching +params+ as a form-encoded query string when non-empty. + # + # @return [URI] def build_uri(path, params) uri = URI("#{@base_url}#{path}") uri.query = URI.encode_www_form(params) if params && !params.empty? uri end + # @api private — the Net::HTTP request object for +method+. + # + # @raise [ArgumentError] for a method outside GET/POST/PUT/PATCH/DELETE def build_request(method, uri) klass = { 'GET' => Net::HTTP::Get, 'POST' => Net::HTTP::Post, 'PUT' => Net::HTTP::Put, @@ -387,6 +469,9 @@ def build_request(method, uri) klass.new(uri) end + # @api private — stamp the fixed request headers: the Basic-auth header built + # from the project id and token, JSON content/accept types, and the SDK's + # versioned User-Agent. def apply_headers(req) req['Authorization'] = @auth_header req['Content-Type'] = 'application/json' @@ -394,6 +479,10 @@ def apply_headers(req) req['User-Agent'] = USER_AGENT end + # @api private — enable TLS on the transport with VERIFY_PEER. There is no + # VERIFY_NONE path. When a CA bundle was configured (constructor arg or + # SIGNALWIRE_REST_CA_FILE) it is trusted IN ADDITION to the OpenSSL defaults, + # for private- or pinned-CA deployments. def configure_ssl(http) http.use_ssl = true # Always verify the server certificate. When an explicit CA bundle @@ -410,6 +499,9 @@ def configure_ssl(http) http.cert_store = store end + # @api private — the error body as decoded JSON when it parses, else the raw + # response body string. An error response is not guaranteed to be JSON, so this + # never raises on top of the failure it is reporting. def parse_error_body(response) JSON.parse(response.body) rescue StandardError @@ -419,6 +511,9 @@ def parse_error_body(response) # Base for all namespace/resource classes. class BaseResource + # @param http [HttpClient] the transport every request on this resource goes through + # @param base_path [String] the collection path this resource is anchored at, + # e.g. "/api/fabric/resources/addresses" def initialize(http, base_path) @http = http @base_path = base_path @@ -435,6 +530,12 @@ def _path(*parts) # +signalwire.rest._base.ReadResource+: the read half of the CRUD surface, # extended by CrudResource with create/update/delete. class ReadResource < BaseResource + # List this resource's collection — ONE raw page, exactly as the server + # returned it. Use {#paginate} to walk every page. + # + # @param request_options [RequestOptions, nil] per-request overrides + # @param params [Hash] filter / paging query parameters; omitted when empty + # @return [Hash] the decoded page def list(request_options: nil, **params) @http.get(@base_path, params.empty? ? nil : params, request_options: request_options) end @@ -456,6 +557,12 @@ def paginate(request_options: nil, **params) request_options) end + # Fetch one item of this collection by id. + # + # @param resource_id [String] the item's identifier, appended to the base path + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded item + # @raise [SignalWireRestError] 404 when no such item exists def get(resource_id, request_options: nil) @http.get(_path(resource_id), request_options: request_options) end @@ -484,15 +591,33 @@ class << self attr_writer :update_method end + # Create an item in this collection via POST. + # + # @param request_options [RequestOptions, nil] per-request overrides + # @param kwargs [Hash] the fields of the new item, sent as the JSON body + # @return [Hash] the decoded created item def create(request_options: nil, **kwargs) @http.post(@base_path, kwargs, request_options: request_options) end + # Update one item by id. The HTTP verb is the class's `update_method` — PATCH + # for most resources, PUT for the ones whose routes only accept a full + # replacement (see {CrudResource.update_method}). + # + # @param resource_id [String] the item's identifier + # @param request_options [RequestOptions, nil] per-request overrides + # @param kwargs [Hash] the fields to change, sent as the JSON body + # @return [Hash] the decoded updated item def update(resource_id, request_options: nil, **kwargs) m = self.class.update_method.downcase @http.send(m, _path(resource_id), kwargs, request_options: request_options) end + # Delete one item by id. + # + # @param resource_id [String] the item's identifier + # @param request_options [RequestOptions, nil] per-request overrides + # @return [Hash] the decoded body, or `{}` when the server answers 204 def delete(resource_id, request_options: nil) @http.delete(_path(resource_id), request_options: request_options) end @@ -504,6 +629,13 @@ def delete(resource_id, request_options: nil) # list/create/get/update/delete surface, issuing # +GET {base_path}/{resource_id}/addresses+. class CrudWithAddresses < CrudResource + # List the addresses bound to one item of this collection, issuing + # `GET {base_path}/{resource_id}/addresses`. + # + # @param resource_id [String] the item whose addresses to list + # @param request_options [RequestOptions, nil] per-request overrides + # @param params [Hash] filter / paging query parameters; omitted when empty + # @return [Hash] the decoded page of addresses def list_addresses(resource_id, request_options: nil, **params) @http.get(_path(resource_id, 'addresses'), params.empty? ? nil : params, request_options: request_options) diff --git a/lib/signalwire/web/web_service.rb b/lib/signalwire/web/web_service.rb index 92a33552..5eefcd5b 100644 --- a/lib/signalwire/web/web_service.rb +++ b/lib/signalwire/web/web_service.rb @@ -36,6 +36,20 @@ class WebService attr_reader :port, :directories, :enable_directory_browsing, :max_file_size, :enable_cors, :allowed_extensions, :blocked_extensions, :security + # @param port [Integer] the port to bind; 0 binds an ephemeral port + # @param directories [Hash{String => String}, nil] route to local directory map; + # when nil, whatever the config file declared is kept + # @param basic_auth [Array(String, String), nil] `[user, pass]` required for every + # request; falls back to the SecurityConfig's credentials + # @param config_file [String, nil] explicit config path, or nil to auto-discover + # @param enable_directory_browsing [Boolean] serve `index.html` for a directory + # request instead of refusing it + # @param allowed_extensions [Array, nil] when set, ONLY these file + # extensions are served — an allow-list that overrides the block-list + # @param blocked_extensions [Array] never-served extensions and names + # (defaults to DEFAULT_BLOCKED_EXTENSIONS: .env, .git, .key, .pem, …) + # @param max_file_size [Integer] refuse to serve a file larger than this, in bytes + # @param enable_cors [Boolean] whether CORS headers are emitted def initialize(port: 8002, directories: nil, basic_auth: nil, config_file: nil, enable_directory_browsing: false, allowed_extensions: nil, blocked_extensions: nil, max_file_size: 100 * 1024 * 1024, enable_cors: true) @@ -50,6 +64,9 @@ def initialize(port: 8002, directories: nil, basic_auth: nil, config_file: nil, init_security(config_file, basic_auth) end + # @api private — build the SecurityConfig for the `web` service and resolve the + # basic-auth pair (explicit arg wins over the config's), leaving the server and + # its thread unstarted. def init_security(config_file, basic_auth) @security = SignalWire::Core::SecurityConfig.new(config_file: config_file, service_name: 'web') @basic_auth = basic_auth || @security.get_basic_auth @@ -124,6 +141,10 @@ def file_allowed?(path) private + # @api private — construct the WEBrick server with logging silenced (the + # service does its own) and TLS applied when a cert/key pair was given. + # + # @return [WEBrick::HTTPServer] def build_server(host, bind_port, ssl_cert, ssl_key) opts = { BindAddress: host, Port: bind_port, @@ -133,6 +154,8 @@ def build_server(host, bind_port, ssl_cert, ssl_key) WEBrick::HTTPServer.new(opts) end + # @api private — turn on WEBrick TLS with the given PEM certificate and private + # key. A missing cert or key leaves the server plain HTTP. def apply_ssl(opts, ssl_cert, ssl_key) kwargs = if ssl_cert && ssl_key { SSLEnable: true, @@ -144,6 +167,8 @@ def apply_ssl(opts, ssl_cert, ssl_key) opts.merge!(kwargs) end + # @api private — mount +directory+ at +route+ on the running server, routing + # each request through {#handle_request}. def mount_directory(route, directory) service = self @server.mount_proc(route) do |req, res| @@ -151,6 +176,11 @@ def mount_directory(route, directory) end end + # @api private — serve one request: enforce basic auth, then resolve the + # request path INSIDE the mounted directory. The resolved absolute path must be + # the directory itself or below it — that check is what stops a `../` traversal + # from escaping the mount — and a path outside it is 403, not 404, so a probe + # cannot distinguish "escaped" from "absent". def handle_request(req, res, route, directory) return unless authorized?(req, res) @@ -163,6 +193,9 @@ def handle_request(req, res, route, directory) serve_path(res, full) end + # @api private — resolve a request to a file: a directory request becomes its + # `index.html`, and anything that is not a servable file is 403 (directory + # browsing disabled), as is a file rejected by the size/extension filters. def serve_path(res, full) full = File.join(full, 'index.html') if File.directory?(full) return deny(res, 403, 'Directory browsing disabled') unless File.file?(full) @@ -171,6 +204,8 @@ def serve_path(res, full) write_file(res, full) end + # @api private — write a file to the response with its MIME type, a one-hour + # public cache header, and the SecurityConfig's security headers. def write_file(res, full) res.status = 200 res.body = File.binread(full) @@ -179,11 +214,18 @@ def write_file(res, full) @security.get_security_headers.each { |header, value| res[header] = value } end + # @api private — a plain-text refusal at +status+. The body is the only detail + # given; no path or filesystem information is leaked. def deny(res, status, message) res.status = status res.body = message end + # @api private — enforce basic auth. Returns true when no credentials are + # configured (auth is off) or the request's match; otherwise sets a 401 + # challenge on the response and returns false. + # + # @return [Boolean] true when the request may proceed def authorized?(req, res) user, pass = @basic_auth return true if user.nil? || pass.nil? @@ -196,6 +238,12 @@ def authorized?(req, res) false end + # @api private — constant-time comparison of the request's `Authorization` + # header against the configured pair. The scheme is matched case-insensitively + # (RFC 7235), and a decoded payload with NO colon is rejected outright rather + # than defaulting the password to the empty string (RFC 7617). + # + # @return [Boolean] true when both halves match def credentials_match?(req, user, pass) # Split on the FIRST space and compare the scheme case-INSENSITIVELY # (RFC 7235; the reference does `scheme.lower() != "basic"`). @@ -213,6 +261,12 @@ def credentials_match?(req, user, pass) false end + # @api private — whether a path is on the block-list. An entry starting with a + # dot matches the file's extension or its exact name; any other entry matches + # the exact name or ANY path component, so a directory name like + # `__pycache__` blocks everything beneath it. + # + # @return [Boolean] def blocked?(path) name = File.basename(path) ext = File.extname(path).downcase @@ -225,14 +279,21 @@ def blocked?(path) end end + # @api private — the MIME type WEBrick infers for the file, falling back to + # `application/octet-stream` for an unknown extension. def mime_type(full) WEBrick::HTTPUtils.mime_type(full, WEBrick::HTTPUtils::DefaultMimeTypes) || 'application/octet-stream' end + # @api private — ensure a mount route starts with a slash, so `"docs"` and + # `"/docs"` mount at the same place. def normalize_route(route) route.start_with?('/') ? route : "/#{route}" end + # @api private — seed the port and directory map from the `service` section of + # the config file (explicit path, else auto-discovered for the `web` service). + # Sets the built-in defaults first, so a missing file leaves a usable config. def load_config(config_file) @directories = {} @port = 8002 @@ -245,6 +306,9 @@ def load_config(config_file) apply_service_section(loader.get_section('service')) end + # @api private — apply the config's `service` section: `port` and the + # `directories` route map, then the file filters. A nil or empty section is a + # no-op. def apply_service_section(service) return if service.nil? || service.empty? @@ -253,6 +317,9 @@ def apply_service_section(service) apply_service_filters(service) end + # @api private — apply the config's file-serving filters: `max_file_size`, + # `allowed_extensions`, `blocked_extensions` and `enable_directory_browsing` + # (coerced to a real Boolean). def apply_service_filters(service) @max_file_size = service['max_file_size'].to_i if service.key?('max_file_size') @allowed_extensions = service['allowed_extensions'] if service.key?('allowed_extensions') From 2cdd923fc989ffed19c37579db5f08969176e62c Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:56:56 -0400 Subject: [PATCH 34/90] docs(skills): math, google_maps, mcp_gateway, info_gatherer (65 decls) math.rb: the tokenizer's character whitelist (why evaluating model-supplied input is safe without eval), unary-minus disambiguation, and each recursive-descent level's precedence and associativity including the 1000 cap on the exponent. google_maps.rb: the Geocoding/Routes calls, the field mask, and the pattern of turning every failure into a spoken FunctionResult. mcp_gateway.rb: the auth/connection config (including why verify_ssl is read off @params rather than get_param), SSRF validation of the gateway URL, and the 5xx-only retry rule. info_gatherer.rb: prefix-derived tool names and global_data namespace, the confirm-before-record rule, and where per-call progress is persisted. DOC-SURFACE ruby: 88.6% -> 90.5% (3047/3366). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/skills/builtin/google_maps.rb | 62 +++++++++++++++++ .../skills/builtin/info_gatherer.rb | 61 +++++++++++++++++ lib/signalwire/skills/builtin/math.rb | 56 ++++++++++++++++ lib/signalwire/skills/builtin/mcp_gateway.rb | 67 +++++++++++++++++++ 4 files changed, 246 insertions(+) diff --git a/lib/signalwire/skills/builtin/google_maps.rb b/lib/signalwire/skills/builtin/google_maps.rb index 6bf5c76a..4a8f5476 100644 --- a/lib/signalwire/skills/builtin/google_maps.rb +++ b/lib/signalwire/skills/builtin/google_maps.rb @@ -18,6 +18,11 @@ module Builtin module GoogleMapsHttp private + # @api private — call the Google Geocoding API for +address+. A non-2xx + # response yields an empty list rather than raising, so a Maps outage + # degrades to "address not found" instead of failing the call. + # + # @return [Array] the API's `results`, possibly empty def geocode(address) resp = Net::HTTP.get_response(geocode_uri(address)) return [] unless resp.is_a?(Net::HTTPSuccess) @@ -25,6 +30,11 @@ def geocode(address) JSON.parse(resp.body)['results'] || [] end + # @api private — render one geocode result as the tool's spoken answer: the + # API's canonical `formatted_address` (falling back to what the caller said) + # plus its lat/lng. + # + # @return [Swaig::FunctionResult] def format_geocode_result(result, address) location = result.dig('geometry', 'location') || {} formatted = result['formatted_address'] || address @@ -33,16 +43,29 @@ def format_geocode_result(result, address) ) end + # @api private — the Geocoding API URI with the address and the skill's API key + # as query parameters. + # + # @return [URI] def geocode_uri(address) uri = URI('https://maps.googleapis.com/maps/api/geocode/json') uri.query = URI.encode_www_form(address: address, key: @api_key) uri end + # @api private — the result returned when geocoding matched nothing. Asks the + # caller for a more specific address rather than reporting a failure, so the + # model keeps the conversation moving. + # + # @return [Swaig::FunctionResult] def geocode_not_found Swaig::FunctionResult.new("I couldn't find that address. Could you provide a more specific address?") end + # @api private — call the Google Routes API for a driving route between the two + # coordinate pairs. + # + # @return [Array] the API's `routes`, possibly empty def fetch_routes(origin_lat, origin_lng, dest_lat, dest_lng) uri = URI('https://routes.googleapis.com/directions/v2:computeRoutes') http = Net::HTTP.new(uri.host, uri.port) @@ -52,6 +75,11 @@ def fetch_routes(origin_lat, origin_lng, dest_lat, dest_lng) JSON.parse(http.request(request).body)['routes'] || [] end + # @api private — the Routes API POST request: the API key header plus a field + # mask narrowing the response to distance and duration, which is all this skill + # reports. + # + # @return [Net::HTTP::Post] def build_route_request(uri, origin_lat, origin_lng, dest_lat, dest_lng) request = Net::HTTP::Post.new(uri.path) request['Content-Type'] = 'application/json' @@ -61,6 +89,10 @@ def build_route_request(uri, origin_lat, origin_lng, dest_lat, dest_lng) request end + # @api private — the Routes API JSON body. Fixed at `DRIVE` with + # `TRAFFIC_AWARE` routing, so the reported duration reflects current traffic. + # + # @return [String] JSON def route_request_body(origin_lat, origin_lng, dest_lat, dest_lng) { origin: { location: { latLng: { latitude: origin_lat, longitude: origin_lng } } }, @@ -70,6 +102,10 @@ def route_request_body(origin_lat, origin_lng, dest_lat, dest_lng) }.to_json end + # @api private — render one route as the tool's spoken answer, converting the + # API's metres to miles and its duration-in-seconds string to whole minutes. + # + # @return [Swaig::FunctionResult] def format_route(route) distance_mi = (route['distanceMeters'] || 0) / 1609.344 duration_min = (route['duration'] || '0s').to_s.delete('s').to_i / 60.0 @@ -79,6 +115,9 @@ def format_route(route) end end + # Geocode addresses and compute driving routes through the Google Maps + # Geocoding and Routes APIs. Requires a `GOOGLE_MAPS_API_KEY` (or an `api_key` + # param); the skill refuses to load without one. class GoogleMapsSkill < SkillBase include GoogleMapsHttp @@ -95,7 +134,13 @@ class GoogleMapsSkill < SkillBase 'dest_lng' => { 'type' => 'number', 'description' => 'Destination longitude' } }.freeze + # The name this skill is added under (`agent.add_skill('google_maps')`). + # + # @return [String] def name = 'google_maps' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Validate addresses and compute driving routes using Google Maps' # Called once after construction. Return false to abort loading — the @@ -159,6 +204,9 @@ def get_parameter_schema private + # @api private — the prompt bullets, naming the skill's CONFIGURED tool names + # (which the caller may have renamed) so the model refers to the tools it will + # actually be offered. def prompt_bullets [ "Use #{@lookup_tool} to validate and geocode addresses or business names", @@ -168,6 +216,8 @@ def prompt_bullets ] end + # @api private — the address-lookup tool definition, under whatever name the + # `lookup_tool_name` param configured. def lookup_tool_def { name: @lookup_tool, @@ -177,6 +227,8 @@ def lookup_tool_def } end + # @api private — the route-computation tool definition, under whatever name the + # `route_tool_name` param configured. def route_tool_def { name: @route_tool, @@ -186,6 +238,11 @@ def route_tool_def } end + # @api private — the address-lookup handler. An empty address, no match, or a + # raised error each become a spoken FunctionResult rather than an exception, so + # the model always gets something it can say. + # + # @return [Swaig::FunctionResult] def handle_lookup(args, _raw_data) address = (args['address'] || '').strip return Swaig::FunctionResult.new('Please provide an address or business name to look up.') if address.empty? @@ -198,6 +255,11 @@ def handle_lookup(args, _raw_data) Swaig::FunctionResult.new("Error looking up address: #{e.message}") end + # @api private — the route handler. All four coordinates are required; a + # missing one, an unroutable pair, or a raised error each become a spoken + # FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_route(args, _raw_data) coords = %w[origin_lat origin_lng dest_lat dest_lng].map { |k| args[k] } if coords.any?(&:nil?) diff --git a/lib/signalwire/skills/builtin/info_gatherer.rb b/lib/signalwire/skills/builtin/info_gatherer.rb index 71891d6f..0fb88928 100644 --- a/lib/signalwire/skills/builtin/info_gatherer.rb +++ b/lib/signalwire/skills/builtin/info_gatherer.rb @@ -15,18 +15,26 @@ module Builtin module InfoGathererHelpers private + # @api private — the tool that begins the question sequence. Takes no + # parameters: the questions and the caller's position in them live in the + # agent's global_data, not in the call. def start_tool_definition { name: @start_tool, description: 'Start the question sequence with the first question', parameters: {}, handler: method(:handle_start) } end + # @api private — the tool that records an answer and advances to the next + # question. def submit_tool_definition { name: @submit_tool, description: 'Submit an answer to the current question and move to the next one', parameters: submit_tool_parameters, handler: method(:handle_submit) } end + # @api private — the submit tool's schema. `confirmed_by_user` is a separate + # flag rather than something inferred, so a question marked `confirm` cannot be + # recorded until the model has explicitly read the answer back. def submit_tool_parameters { 'answer' => { 'type' => 'string', 'description' => "The user's answer to the current question" }, @@ -35,12 +43,21 @@ def submit_tool_parameters 'description' => 'Only set to true when the user has explicitly confirmed the answer.' } } end + # @api private — a usable question list is a non-empty Array of Hashes, each + # carrying both a `key_name` (where the answer is stored) and a + # `question_text` (what is asked). + # + # @return [Boolean] def valid_questions?(questions) return false unless questions.is_a?(Array) && !questions.empty? questions.all? { |q| q.is_a?(Hash) && q['key_name'] && q['question_text'] } end + # @api private — derive the two tool names and the global_data namespace from + # the instance `prefix`, so several info-gatherers on one agent neither collide + # on tool names nor overwrite each other's answers. An empty prefix yields the + # unprefixed defaults. def configure_tool_names(prefix) slug = prefix && !prefix.empty? ? prefix : nil @start_tool = slug ? "#{slug}_start_questions" : 'start_questions' @@ -48,6 +65,11 @@ def configure_tool_names(prefix) @namespace = slug ? "skill:#{slug}" : 'skill:info_gatherer' end + # @api private — the start handler: read the stored progress and instruct the + # model to ask the current question. An empty or already-exhausted question + # list yields a spoken "no questions" result rather than an error. + # + # @return [Swaig::FunctionResult] def handle_start(_args, raw_data) questions, index, = load_progress(raw_data) if questions.empty? || index >= questions.size @@ -58,6 +80,12 @@ def handle_start(_args, raw_data) Swaig::FunctionResult.new(instruction) end + # @api private — the submit handler: record the answer under the current + # question's `key_name`, advance the index and persist both back into + # global_data. A question marked `confirm` whose `confirmed_by_user` flag is + # not set is NOT recorded — the model is sent back to confirm first. + # + # @return [Swaig::FunctionResult] def handle_submit(args, raw_data) answer = args['answer'] || '' questions, index, answers = load_progress(raw_data) @@ -87,6 +115,10 @@ def apply_state(result, questions, new_index, new_answers) result end + # @api private — the result that sends the model back to read an answer aloud + # and get explicit confirmation before it is recorded. + # + # @return [Swaig::FunctionResult] def confirmation_prompt(answer) Swaig::FunctionResult.new( "Before submitting, read the answer \"#{answer}\" back to the user and ask them to confirm." @@ -109,12 +141,21 @@ def submit_result(questions, new_index) result end + # @api private — this instance's slice of the agent's global_data, keyed by the + # prefix-derived namespace. Empty when nothing has been stored yet. + # + # @return [Hash] def extract_state(raw_data) return {} unless raw_data.is_a?(Hash) (raw_data['global_data'] || {})[@namespace] || {} end + # @api private — the instruction text the model is given for one question: the + # numbered question, plus the question's own `prompt_add` note and a + # read-it-back directive when it is marked `confirm`. + # + # @return [String] def generate_instruction(question, index, total, first) instr = base_instruction(question['question_text'], index + 1, total, first) prompt_add = question['prompt_add'] @@ -125,6 +166,11 @@ def generate_instruction(question, index, total, first) instr end + # @api private — the question text with its "[Question N of M]" marker. The + # FIRST question also carries the ask-one-at-a-time protocol and names the + # submit tool, so the model learns the loop once rather than on every turn. + # + # @return [String] def base_instruction(text, num, total, first) if first "Ask each question one at a time, wait for the user's answer, " \ @@ -136,10 +182,20 @@ def base_instruction(text, num, total, first) end end + # Walk the caller through a configured list of questions one at a time, + # recording each answer into the agent's global_data. Progress survives across + # turns because it lives in global_data, not in the skill instance. Supports + # multiple instances via `prefix`, and per-question read-back confirmation. class InfoGathererSkill < SkillBase include InfoGathererHelpers + # The name this skill is added under (`agent.add_skill('info_gatherer')`). + # + # @return [String] def name = 'info_gatherer' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Gather answers to a configurable list of questions' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -162,6 +218,11 @@ def setup true end + # The key this instance is tracked under, so several info-gatherers can coexist + # on one agent: `info_gatherer_` when a prefix was configured, else the + # bare skill name. + # + # @return [String] def instance_key prefix = get_param('prefix') prefix && !prefix.to_s.empty? ? "info_gatherer_#{prefix}" : 'info_gatherer' diff --git a/lib/signalwire/skills/builtin/math.rb b/lib/signalwire/skills/builtin/math.rb index a16262d4..3d73f56c 100644 --- a/lib/signalwire/skills/builtin/math.rb +++ b/lib/signalwire/skills/builtin/math.rb @@ -9,13 +9,23 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Evaluate arithmetic expressions for the model, WITHOUT ever calling `eval`. + # The expression is tokenized against a character whitelist and evaluated by a + # hand-written recursive-descent parser, so a hostile string reaches no Ruby + # interpreter. Supports `+ - * / % **` and parentheses. class MathSkill < SkillBase EXPRESSION_DESCRIPTION = "Mathematical expression to evaluate (e.g., '2 + 3 * 4', '(10 + 5) / 3')" INVALID_EXPRESSION_MESSAGE = 'Error: Invalid expression. Only numbers and basic math operators ' \ '(+, -, *, /, %, **, parentheses) are allowed.' + # The name this skill is added under (`agent.add_skill('math')`). + # + # @return [String] def name = 'math' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Perform basic mathematical calculations' # The math skill has no external packages or environment to @@ -94,11 +104,18 @@ def handle_calculate(args, _raw_data) class MathTokenizer UNARY_PRECEDERS = %w[( + - * / % **].freeze + # @param expr [String] the arithmetic expression to tokenize def initialize(expr) @expr = expr @tokens = [] end + # Tokenize the expression into number and operator tokens. + # + # @return [Array] the token list + # @raise [RuntimeError] on a character outside digits, `.`, whitespace and the + # supported operators — that whitelist is what makes evaluating + # model-supplied input safe def tokens idx = 0 idx = step(idx) while idx < @expr.length @@ -107,6 +124,11 @@ def tokens private + # @api private — consume one token starting at +idx+ and return the next index. + # Whitespace is skipped; `**` is matched before `*` so exponentiation is not + # read as two multiplications. + # + # @raise [RuntimeError] on an unsupported character def step(idx) char = @expr[idx] if /\s/.match?(char) then idx + 1 @@ -117,15 +139,21 @@ def step(idx) end end + # @api private — append a token and return the index to continue from. def push_token(token, next_idx) @tokens << token next_idx end + # @api private — whether a character begins a number. A `-` counts only in + # UNARY position (at the start, or right after an operator or an open paren), + # so `3 - 2` is a subtraction while `-3` is a negative literal. def number_start?(char) char =~ /[\d.]/ || (char == '-' && (@tokens.empty? || UNARY_PRECEDERS.include?(@tokens.last))) end + # @api private — read a numeric literal (optionally sign-prefixed) starting at + # +idx+ and return the index after it. def read_number(idx) num_str = +'' if @expr[idx] == '-' @@ -146,11 +174,18 @@ class SafeEvaluator ADD_OPS = %w[+ -].freeze MUL_OPS = %w[* / %].freeze + # @param expr [String] the arithmetic expression to evaluate def initialize(expr) @tokens = MathTokenizer.new(expr).tokens @pos = 0 end + # Parse and evaluate the tokenized expression. + # + # @return [Numeric] the computed value + # @raise [RuntimeError] on a malformed expression, or when tokens remain after + # a complete expression was parsed + # @raise [ZeroDivisionError] on division or modulo by zero def evaluate result = parse_expr raise 'Unexpected tokens after expression' unless @pos >= @tokens.length @@ -160,6 +195,8 @@ def evaluate private + # @api private — the lowest precedence level: terms joined by `+` / `-`, + # evaluated left to right. def parse_expr left = parse_term while @pos < @tokens.length && ADD_OPS.include?(@tokens[@pos]) @@ -171,6 +208,8 @@ def parse_expr left end + # @api private — powers joined by `*` / `/` / `%`, evaluated left to right + # (binding tighter than `+` / `-`). def parse_term left = parse_power while @pos < @tokens.length && MUL_OPS.include?(@tokens[@pos]) @@ -181,6 +220,10 @@ def parse_term left end + # @api private — apply one multiplicative operator. `/` produces a Float, so + # integer division never silently truncates. + # + # @raise [ZeroDivisionError] when +right+ is zero for `/` or `%` def apply_mul_op(left, oper, right) case oper when '*' then left * right @@ -195,6 +238,11 @@ def apply_mul_op(left, oper, right) end end + # @api private — exponentiation, which binds tighter than `*` and is RIGHT + # associative (`2 ** 3 ** 2` is `2 ** 9`). The exponent is capped at 1000 so a + # model-supplied expression cannot hang the process computing a huge power. + # + # @raise [RuntimeError] when the exponent exceeds 1000 def parse_power base = parse_unary if @pos < @tokens.length && @tokens[@pos] == '**' @@ -207,6 +255,7 @@ def parse_power base end + # @api private — a leading unary `-` or `+` applied to an atom. def parse_unary if @pos < @tokens.length && @tokens[@pos] == '-' @pos += 1 @@ -219,6 +268,10 @@ def parse_unary end end + # @api private — the innermost level: a parenthesized expression or a numeric + # literal (Integer unless it contains a `.`). + # + # @raise [RuntimeError] on an unexpected token or a truncated expression def parse_atom raise 'Unexpected end of expression' if @pos >= @tokens.length @@ -233,6 +286,9 @@ def parse_atom end end + # @api private — a parenthesized sub-expression, consuming both parens. + # + # @raise [RuntimeError] when the closing parenthesis is missing def parse_parenthesized @pos += 1 val = parse_expr diff --git a/lib/signalwire/skills/builtin/mcp_gateway.rb b/lib/signalwire/skills/builtin/mcp_gateway.rb index 285af806..e7a542cf 100644 --- a/lib/signalwire/skills/builtin/mcp_gateway.rb +++ b/lib/signalwire/skills/builtin/mcp_gateway.rb @@ -32,7 +32,13 @@ module Builtin # SERVER half (``signalwire.mcp_gateway.*`` — the subprocess + sandbox # daemon) is deliberately NOT ported; see PORT_PHILOSOPHY_RUBY.md. class MCPGatewaySkill < SkillBase + # The name this skill is added under (`agent.add_skill('mcp_gateway')`). + # + # @return [String] def name = 'mcp_gateway' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Bridge MCP servers with SWAIG functions' # This skill's own version, independent of the SDK's. # @@ -162,6 +168,9 @@ def connection_params_schema } end + # No extra gems are needed — the gateway is reached over plain Net::HTTP. + # + # @return [Array] empty def required_packages = [] # Lazily populate config ivars if #setup hasn't run yet, so the hook @@ -181,6 +190,10 @@ def read_config @session_id = nil end + # @api private — read the gateway credentials (bearer token, or basic-auth + # user + password) and the gateway URL, each falling back to its + # `MCP_GATEWAY_*` environment variable. Trailing slashes are stripped off the + # URL so paths compose cleanly. def read_auth_config @auth_token = get_param('auth_token', env_var: 'MCP_GATEWAY_AUTH_TOKEN') @auth_user = get_param('auth_user', env_var: 'MCP_GATEWAY_AUTH_USER') @@ -188,6 +201,11 @@ def read_auth_config @gateway_url = (get_param('gateway_url', default: '') || '').sub(%r{/+\z}, '') end + # @api private — read the service list, session timeout, tool-name prefix, + # retry count, request timeout and TLS-verification flag. `verify_ssl` is read + # STRAIGHT off the params rather than through `get_param`, because + # `false || default` would resurrect the default and silently re-enable + # verification the operator explicitly turned off. def read_connection_config @services = normalize_services(@params['services']) @session_timeout = get_param('session_timeout', default: 300).to_i @@ -202,6 +220,11 @@ def read_connection_config @verify_ssl = @params.fetch('verify_ssl', true) != false end + # @api private — normalise the configured service list, stringifying the keys + # of each Hash entry so symbol- and string-keyed config both work. A non-Array + # yields an empty list. + # + # @return [Array] def normalize_services(services) return [] unless services.is_a?(Array) @@ -223,6 +246,11 @@ def valid_auth? false end + # @api private — the gateway URL must be present AND pass the SSRF validator, + # which is what stops a config value from pointing the skill at an internal + # address. Logs the specific reason before returning false. + # + # @return [Boolean] def valid_gateway_url? if @gateway_url.nil? || @gateway_url.empty? logger&.error('Missing required parameter: gateway_url') @@ -283,6 +311,10 @@ def filter_tools(tools, service_name) tools.select { |t| filter.include?(t['name']) } end + # @api private — the configured entry for a service by name, tolerating both + # String and Symbol `name` keys. + # + # @return [Hash, nil] def service_config_for(service_name) @services.find { |s| s.is_a?(Hash) && (s['name'] || s[:name]) == service_name } end @@ -337,6 +369,12 @@ def call_mcp_tool(service_name, tool_name, args, raw_data) Swaig::FunctionResult.new(dispatch_with_retry(service_name, tool_name, request_body)) end + # @api private — proxy one MCP tool call through the gateway. Every failure — + # exhausted retries or an unexpected exception — is converted to a spoken + # failure STRING, so the model always receives something it can say rather than + # an exception escaping into the SWAIG response. + # + # @return [String] the gateway's result, or a failure message def dispatch_with_retry(service_name, tool_name, request_body) url = "#{@gateway_url}/services/#{service_name}/call" result, error = attempt_dispatch(url, request_body) @@ -362,6 +400,10 @@ def attempt_dispatch(url, request_body) [nil, last_error] end + # @api private — only a 5xx is retried: a 4xx is the gateway rejecting the + # request itself, and retrying it would just repeat the rejection. + # + # @return [Boolean] def retryable?(resp, last_error, attempt) return false unless resp.is_a?(Net::HTTPServerError) @@ -369,11 +411,20 @@ def retryable?(resp, last_error, attempt) true end + # @api private — the session id sent to the gateway so it can correlate a + # conversation's tool calls: the agent's `mcp_call_id` global-data value, else + # the call id, else the literal `"unknown"`. + # + # @return [String] def resolve_session_id(raw_data) global = raw_data['global_data'] || raw_data[:global_data] || {} global['mcp_call_id'] || raw_data['call_id'] || 'unknown' end + # @api private — the gateway's `error` field when the body parses, else the + # bare HTTP status. Never raises on top of the failure it is reporting. + # + # @return [String] def error_message(resp) parsed = parse_json(resp&.body) parsed['error'] || "HTTP #{resp&.code}" @@ -381,6 +432,10 @@ def error_message(resp) "HTTP #{resp&.code}" end + # @api private — parse a JSON body, yielding an empty Hash rather than raising + # on malformed input. + # + # @return [Hash] def parse_json(body) JSON.parse(body.to_s) rescue JSON::ParserError @@ -392,6 +447,11 @@ def service_descriptions @services.filter_map { |service| describe_service(service) } end + # @api private — one line describing a configured service for the prompt + # section: its name plus whether all of its tools or an explicit subset are + # exposed. + # + # @return [String] def describe_service(service) return service.to_s unless service.is_a?(Hash) @@ -433,6 +493,11 @@ def make_request(method, url, json: nil) }.freeze private_constant :REQUEST_CLASSES + # @api private — build the Net::HTTP request for a gateway call, applying the + # configured auth and the JSON body. + # + # @raise [KeyError] for a method outside GET/POST/DELETE + # @return [Net::HTTPRequest] def build_request(method, uri, json) req = REQUEST_CLASSES.fetch(method.upcase).new(uri) apply_auth(req) @@ -449,6 +514,8 @@ def apply_auth(req) end end + # @api private — attach a JSON body and its content type. A nil +json+ leaves + # the request bodiless, which is what a GET wants. def apply_json_body(req, json) return unless json From 2010a9c41d0e1932f1a0cb1f69db502ba60011ae Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 17:58:36 -0400 Subject: [PATCH 35/90] docs(core,serverless,utils,swaig): auth_handler, lambda_handler, schema_utils, function_result (54 decls) auth_handler.rb: the per-method env checks, the RFC 7235 case-insensitive scheme compare and RFC 7617 no-colon rejection, and the fact that the *_info helpers deliberately expose no secrets and the 401 is identical for every failure mode. lambda_handler.rb: the payload-v1-vs-v2 split at every extraction point and in both response shapes (cookies vs multiValueHeaders), plus the base64 body handling. schema_utils.rb: the $defs.SWMLMethod.anyOf verb-registry walk, why the verb's ACTUAL name is the definition's single properties key, and the closed-schema condition for unknown-key rejection. function_result.rb: the record_call/tap/max_participants validators and why join_conference collapses to a bare name when all options are default. DOC-SURFACE ruby: 90.5% -> 92.1% (3101/3366). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/core/auth_handler.rb | 54 ++++++++++++++++++ lib/signalwire/serverless/lambda_handler.rb | 62 +++++++++++++++++++++ lib/signalwire/swaig/function_result.rb | 38 +++++++++++++ lib/signalwire/utils/schema_utils.rb | 56 +++++++++++++++++++ 4 files changed, 210 insertions(+) diff --git a/lib/signalwire/core/auth_handler.rb b/lib/signalwire/core/auth_handler.rb index d8fd5d85..08a0ab86 100644 --- a/lib/signalwire/core/auth_handler.rb +++ b/lib/signalwire/core/auth_handler.rb @@ -121,6 +121,10 @@ def get_auth_info private + # @api private — build the enabled-auth-method table from the security config. + # Basic is ALWAYS enabled (the config always yields a pair); bearer and api_key + # are enabled only when the config actually carries a token/key. The API-key + # header defaults to `X-API-Key`. def setup_auth_methods @auth_methods = {} username, password = @security_config.get_basic_auth @@ -136,6 +140,10 @@ def setup_auth_methods @auth_methods['api_key'] = { 'enabled' => true, 'key' => api_key, 'header' => header } end + # @api private — read an optional attribute off the security config, or nil + # when the config object does not expose it. Lets any object with + # `get_basic_auth` serve as a config without having to declare the optional + # bearer/api-key readers. def config_attr(name) @security_config.respond_to?(name) ? @security_config.public_send(name) : nil end @@ -150,6 +158,11 @@ def authenticate_env(env) nil end + # @api private — whether the request's `Authorization` header carries a valid + # bearer token. The scheme is compared case-INSENSITIVELY per RFC 7235 while + # being carried verbatim into the credential carrier. + # + # @return [Boolean] def bearer_env_ok?(env) return false unless @auth_methods.dig('bearer', 'enabled') @@ -174,6 +187,11 @@ def split_authorization(header) [scheme, param.strip] end + # @api private — whether the request carries a valid API key in the configured + # header (translated to its Rack `HTTP_*` env key). The comparison itself is + # timing-safe. + # + # @return [Boolean] def api_key_env_ok?(env) return false unless @auth_methods.dig('api_key', 'enabled') @@ -182,6 +200,10 @@ def api_key_env_ok?(env) !key.nil? && verify_api_key(key) end + # @api private — whether the request's `Authorization` header carries valid + # HTTP Basic credentials. + # + # @return [Boolean] def basic_env_ok?(env) return false unless @auth_methods.dig('basic', 'enabled') @@ -191,6 +213,12 @@ def basic_env_ok?(env) verify_basic_auth(creds) end + # @api private — decode an `Authorization: Basic` header into credentials. The + # scheme is matched case-insensitively (RFC 7235), and a decoded payload with + # NO colon is rejected outright rather than defaulting the password to the + # empty string (RFC 7617). Malformed base64 also yields nil. + # + # @return [BasicCredentials, nil] def parse_basic_auth(header) scheme, param = split_authorization(header) # RFC 7235 case-insensitive scheme compare (reference: @@ -209,35 +237,60 @@ def parse_basic_auth(header) nil end + # @api private — constant-time string comparison, so a wrong credential cannot + # be recovered by timing the response. Both sides are stringified first, so a + # nil compares as `""` rather than raising. + # + # @return [Boolean] def secure_compare(lhs, rhs) Rack::Utils.secure_compare(lhs.to_s, rhs.to_s) end + # @api private — the 401 Rack triple: a `Basic realm="SignalWire Service"` + # challenge and a plain-text body. Identical for every failure mode, so a probe + # cannot tell which auth method it got wrong. + # + # @return [Array(Integer, Hash, Array)] def unauthorized_response [401, { 'content-type' => 'text/plain', 'www-authenticate' => 'Basic realm="SignalWire Service"' }, ['Authentication required']] end + # @api private — log a failed authentication with the client address, method + # and path. The attempted credentials are deliberately NOT logged. def log_auth_failure(env) logger.warn("auth_failed ip=#{env['REMOTE_ADDR']} method=#{env['REQUEST_METHOD']} " \ "path=#{env['PATH_INFO']}") end + # @api private — the memoized `auth_handler` logger. def logger return @logger if defined?(@logger) @logger = SignalWire::Logging.logger('auth_handler') end + # @api private — the public description of basic auth: enabled plus the + # username. Never the password. + # + # @return [Hash] def basic_auth_info { 'enabled' => true, 'username' => @auth_methods['basic']['username'] } end + # @api private — the public description of bearer auth: enabled plus a usage + # hint. Never the token. + # + # @return [Hash] def bearer_auth_info { 'enabled' => true, 'hint' => 'Use Authorization: Bearer ' } end + # @api private — the public description of API-key auth: enabled plus which + # header to send it in. Never the key. + # + # @return [Hash] def api_key_info header = @auth_methods['api_key']['header'] { 'enabled' => true, 'header' => header, 'hint' => "Use #{header}: " } @@ -249,6 +302,7 @@ def api_key_info class AuthError < SignalWire::Error attr_reader :response + # @param response [Array] the Rack 401 triple to return for this failure def initialize(response) @response = response super('Invalid authentication credentials') diff --git a/lib/signalwire/serverless/lambda_handler.rb b/lib/signalwire/serverless/lambda_handler.rb index ebe1208e..c1cdcde8 100644 --- a/lib/signalwire/serverless/lambda_handler.rb +++ b/lib/signalwire/serverless/lambda_handler.rb @@ -21,6 +21,10 @@ module Serverless module ResponseTranslation private + # @api private — translate a Rack response triple into the Lambda response + # hash, in whichever payload format the incoming event used. + # + # @return [Hash] def build_response(event, status, headers, body) payload = collect_body(body) encoded, is_base64 = maybe_base64(payload, headers) @@ -45,6 +49,10 @@ def split_response_headers(headers) [flat_headers, multi_headers] end + # @api private — the payload-v2 response shape. v2 has no `multiValueHeaders`; + # multiple `Set-Cookie` values go in a dedicated `cookies` array instead. + # + # @return [Hash] def response_v2(status, flat_headers, multi_headers, encoded, is_base64) response = { 'statusCode' => status.to_i, @@ -56,6 +64,10 @@ def response_v2(status, flat_headers, multi_headers, encoded, is_base64) response end + # @api private — the payload-v1 response shape, which carries repeated headers + # in `multiValueHeaders` alongside the flattened `headers`. + # + # @return [Hash] def response_v1(status, flat_headers, multi_headers, encoded, is_base64) { 'statusCode' => status.to_i, @@ -66,6 +78,10 @@ def response_v1(status, flat_headers, multi_headers, encoded, is_base64) } end + # @api private — join a Rack body into one binary string. A nil body becomes + # empty rather than raising. + # + # @return [String] binary-encoded def collect_body(body) return ''.b if body.nil? @@ -105,6 +121,11 @@ module RequestTranslation private + # @api private — translate a Lambda invocation event into a Rack env. Content + # type and length are set as the unprefixed `CONTENT_*` keys Rack expects; every + # other header becomes `HTTP_*`. + # + # @return [Hash] the Rack env def build_env(event) version = detect_version(event) headers = extract_headers(event) @@ -116,6 +137,12 @@ def build_env(event) env end + # @api private — the request-derived Rack env keys. The server name, port and + # URL scheme come from the proxy headers API Gateway sets, so a URL the app + # builds matches what the client actually called. The raw event is stashed under + # `signalwire.lambda_event` for handlers that need it. + # + # @return [Hash] def base_rack_env(event, version, headers, body_io) STATIC_RACK_ENV.merge( 'REQUEST_METHOD' => extract_method(event, version), @@ -129,6 +156,8 @@ def base_rack_env(event, version, headers, body_io) ) end + # @api private — copy the request headers into the env as `HTTP_*` keys, + # skipping the two that Rack expects unprefixed. def add_http_headers(env, headers) headers.each do |name, value| next if SKIPPED_HTTP_HEADERS.include?(name) @@ -137,6 +166,11 @@ def add_http_headers(env, headers) end end + # @api private — which Lambda payload format this event uses. API Gateway HTTP + # API and Function URLs send `version: "2.0"`; everything else (REST API, ALB, + # a direct invoke) is treated as v1. + # + # @return [Integer] 2 or 1 def detect_version(event) # API Gateway HTTP API / Function URLs use payload v2 and include # a 'version' key of "2.0". Everything else (REST API, ALB, direct @@ -144,6 +178,10 @@ def detect_version(event) event['version'].to_s.start_with?('2') ? 2 : 1 end + # @api private — the HTTP method. v2 nests it under `requestContext.http`; v1 + # puts it at `httpMethod`. Defaults to GET when neither is present. + # + # @return [String] def extract_method(event, version) if version == 2 event.dig('requestContext', 'http', 'method') || event['httpMethod'] || 'GET' @@ -152,6 +190,11 @@ def extract_method(event, version) end end + # @api private — the request path, trying the v2 `rawPath`, the v1 `path` and + # the nested `requestContext.http.path` in turn, and guaranteeing a leading + # slash. + # + # @return [String] def extract_path(event, _version) raw = event['rawPath'] || @@ -162,6 +205,10 @@ def extract_path(event, _version) raw end + # @api private — the query string: v2's pre-encoded `rawQueryString` when + # present, else re-encoded from v1's single- or multi-value parameter maps. + # + # @return [String] def extract_query_string(event, _version) return event['rawQueryString'] if event['rawQueryString'] && !event['rawQueryString'].empty? @@ -171,12 +218,22 @@ def extract_query_string(event, _version) URI.encode_www_form(query_param_pairs(params)) end + # @api private — flatten a query-parameter map into `[key, value]` pairs, + # expanding an Array value into one pair per element so repeated parameters + # survive re-encoding. + # + # @return [Array] def query_param_pairs(params) params.flat_map do |k, v| v.is_a?(Array) ? v.map { |vv| [k, vv] } : [[k, v]] end end + # @api private — the request headers, lower-cased. Single-value `headers` win + # over `multiValueHeaders`; a name present only in the multi-value map is + # comma-joined. + # + # @return [Hash{String => String}] def extract_headers(event) raw = event['headers'] || {} multi = event['multiValueHeaders'] || {} @@ -190,6 +247,11 @@ def extract_headers(event) merged end + # @api private — the request body as a readable stream plus its byte length, + # base64-decoding it when the event flags it encoded. An absent or empty body + # yields an empty stream and a nil length, so no CONTENT_LENGTH is set. + # + # @return [Array(StringIO, Integer/nil)] def extract_body(event) body = event['body'] return [StringIO.new(''.b), nil] if body.nil? || body.empty? diff --git a/lib/signalwire/swaig/function_result.rb b/lib/signalwire/swaig/function_result.rb index 7abfc614..856dd698 100644 --- a/lib/signalwire/swaig/function_result.rb +++ b/lib/signalwire/swaig/function_result.rb @@ -760,24 +760,37 @@ def end_of_speech_timeout=(value) set_end_of_speech_timeout(value) end + # Attach arbitrary metadata to the result. Writer form of {#set_metadata}; + # returns the assigned value, not self. def metadata=(value) set_metadata(value) end + # Whether the AI speaks its response BEFORE running this result's actions + # (true) or after. Writer form of {#set_post_process}. def post_process=(value) set_post_process(value) end + # The text the model receives as this tool's answer. Writer form of + # {#set_response}. def response=(value) set_response(value) end + # Milliseconds to wait for a speech event before proceeding. Writer form of + # {#set_speech_event_timeout}. def speech_event_timeout=(value) set_speech_event_timeout(value) end private + # @api private — reject a record_call whose format is not wav/mp3/mp4 or whose + # direction is not speak/listen/both, so a bad value fails here rather than + # being rejected mid-call by the server. + # + # @raise [ArgumentError] naming the offending field def validate_record_call!(format, direction) raise ArgumentError, "format must be 'wav', 'mp3', or 'mp4'" unless RecordFormat::ALL.include?(format) return if RecordDirection::ALL.include?(direction) @@ -785,6 +798,10 @@ def validate_record_call!(format, direction) raise ArgumentError, "direction must be 'speak', 'listen', or 'both'" end + # @api private — reject a tap whose direction is not speak/hear/both, whose + # codec is not PCMU/PCMA, or whose packetization time is not positive. + # + # @raise [ArgumentError] naming the offending field def validate_tap!(direction, codec, rtp_ptime) raise ArgumentError, "direction must be 'speak', 'hear', or 'both'" unless TapDirection::ALL.include?(direction) raise ArgumentError, "codec must be 'PCMU' or 'PCMA'" unless Codec::ALL.include?(codec) @@ -891,10 +908,16 @@ def swml_envelope(verb, params) } end + # @api private — whether any action has been queued on this result. + # + # @return [Boolean] def actions? @action && !@action.empty? end + # @api private — whether a non-empty response text has been set. + # + # @return [Boolean] def response? @response && !@response.empty? end @@ -905,6 +928,9 @@ def sms_blank?(value) value.nil? || (value.respond_to?(:empty?) && value.empty?) end + # @api private — the join_conference action. When every option is at its + # default the wire value collapses to the bare conference NAME rather than a + # params object, matching the reference's emitted shape. def join_conference_action(name, opts) validate_join_conference!(name, opts) join_params = if join_conference_all_defaults?(opts) @@ -929,18 +955,30 @@ def validate_join_conference!(name, opts) raise ArgumentError, 'name cannot be empty' if name.to_s.strip.empty? end + # @api private — the conference participant cap must be a positive Integer no + # greater than 250, which is the server's own limit. + # + # @raise [ArgumentError] def validate_max_participants!(max_participants) return if max_participants.is_a?(Integer) && max_participants.positive? && max_participants <= 250 raise ArgumentError, 'max_participants must be a positive integer <= 250' end + # @api private — whether no join_conference option departs from its default, + # which is what lets the action emit the bare name instead of a params object. + # + # @return [Boolean] def join_conference_all_defaults?(opts) JOIN_CONFERENCE_PARAM_SPEC.none? do |_wire_key, opts_key, include_check| include_check.call(opts[opts_key]) end end + # @api private — the join_conference params object: the name plus only those + # options that differ from their default, in the spec's declared wire-key order. + # + # @return [Hash{String => Object}] def build_join_conference_params(name, opts) params = { 'name' => name } JOIN_CONFERENCE_PARAM_SPEC.each do |wire_key, opts_key, include_check| diff --git a/lib/signalwire/utils/schema_utils.rb b/lib/signalwire/utils/schema_utils.rb index 74cf76e7..be1e4766 100644 --- a/lib/signalwire/utils/schema_utils.rb +++ b/lib/signalwire/utils/schema_utils.rb @@ -214,6 +214,10 @@ def validate_verb_top_level_keys(verb_name, verb_config) [errors.empty?, errors] end + # @api private — the generated method body's trailing lines: fold any extra + # kwargs into the config, then add the verb. + # + # @return [Array] Python source lines def method_body_kwargs_lines(verb_name) [' # Add any additional parameters from kwargs', ' for key, value in kwargs.items():', @@ -223,12 +227,20 @@ def method_body_kwargs_lines(verb_name) " return self.add_verb('#{verb_name}', config)"] end + # @api private — the generated signature's parameter list: `self`, one entry + # per schema property (required ones without a default), then `**kwargs`. + # + # @return [Array] def signature_param_parts(verb_name, params, keys) required = get_verb_required_properties(verb_name).to_set param_parts = keys.map { |name| format_signature_param(name, params[name], required) } ['self', *param_parts, '**kwargs'] end + # @api private — one generated parameter. A required property is annotated + # bare; an optional one becomes `Optional[T] = None`. + # + # @return [String] def format_signature_param(name, defn, required) t = python_type_annotation(defn) return "#{name}: #{t}" if required.include?(name) @@ -236,6 +248,11 @@ def format_signature_param(name, defn, required) "#{name}: Optional[#{t}] = None" end + # @api private — the generated method's docstring: a summary line plus one + # `Args:` entry per property, carrying the schema's own description with + # newlines flattened. + # + # @return [String] def signature_docstring(verb_name, params, keys) doc = "\"\"\"\n Add the #{verb_name} verb to the current document\n \n" keys.each do |name| @@ -249,21 +266,36 @@ def signature_docstring(verb_name, params, keys) doc end + # @api private — a verb entry's `definition.properties` block, or nil when the + # entry does not have that shape. + # + # @return [Hash, nil] def verb_definition_properties(verb_entry) verb_entry['definition']['properties'] rescue StandardError nil end + # @api private — the bundled schema at `lib/signalwire/swml/schema.json`, used + # when the constructor was given no explicit path. + # + # @return [String] def default_schema_path # Bundled schema lives in lib/signalwire/swml/schema.json File.expand_path('../swml/schema.json', __dir__) end + # @api private — whether an environment value reads as true: `1`, `true` or + # `yes`, case- and whitespace-insensitive. + # + # @return [Boolean] def env_boolish(value) %w[1 true yes].include?(value.to_s.strip.downcase) end + # @api private — build the verb table by walking `$defs.SWMLMethod.anyOf`, + # which is the schema's registry of every verb. A schema missing that structure + # leaves the table empty rather than raising. def extract_verbs defs = @schema['$defs'] return unless defs.is_a?(Hash) @@ -277,6 +309,9 @@ def extract_verbs any_of.each { |entry| register_verb_entry(entry, defs) } end + # @api private — resolve one `anyOf` `$ref` to its definition and record it + # under its ACTUAL verb name — the single key of the definition's `properties` + # block, which is not always the schema's own name. def register_verb_entry(entry, defs) schema_name = entry_schema_name(entry) return if schema_name.nil? @@ -349,6 +384,11 @@ def schema_error_detail(_verb_name, errors) msg end + # @api private — the fallback validator used when json_schemer is unavailable: + # presence of every required property, and nothing deeper. Matches the + # reference's own lightweight path. + # + # @return [Array(Boolean, Array)] def validate_verb_lightweight(verb_name, verb_config) errors = [] get_verb_required_properties(verb_name).each do |prop| @@ -385,6 +425,9 @@ def top_level_key_errors(verb_name, verb_config, schema) errors end + # @api private — one error per `required` property absent from the config. + # + # @return [Array] def missing_required_errors(verb_name, verb_config, schema) required = schema['required'] return [] unless required.is_a?(Array) @@ -393,6 +436,11 @@ def missing_required_errors(verb_name, verb_config, schema) .map { |req| "Missing required property '#{req}' for verb '#{verb_name}'" } end + # @api private — one error per config key not declared in the schema's + # `properties`. Only called for a CLOSED schema; an open one legitimately + # accepts extras. + # + # @return [Array] def unknown_key_errors(verb_name, verb_config, schema) props = schema['properties'] allowed = props.is_a?(Hash) ? props.keys : [] @@ -411,6 +459,10 @@ def schema_closed?(schema) schema['additionalProperties'] == false end + # @api private — the Python type annotation for a schema property, used by the + # codegen output. Anything not a known scalar or an array becomes `Any`. + # + # @return [String] def python_type_annotation(defn) return 'Any' unless defn.is_a?(Hash) @@ -421,6 +473,10 @@ def python_type_annotation(defn) 'Any' end + # @api private — `List[T]` for an array property, recursing into `items`; an + # array with no item schema becomes `List[Any]`. + # + # @return [String] def python_array_annotation(defn) item = defn['items'].is_a?(Hash) ? python_type_annotation(defn['items']) : 'Any' "List[#{item}]" From f5ff9e81966e33ef82a19798a7bb39a87dd92227 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 18:01:54 -0400 Subject: [PATCH 36/90] docs(skills): the remaining 14 builtin skills (118 decls) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per skill: what it does, which credentials/env vars it needs, and the shape it emits. The load-bearing distinctions stated explicitly — which skills are DataMap tools that run on SignalWire's servers (weather_api, joke, api_ninjas_trivia, datasphere_serverless, play_background_file, swml_transfer) vs webhook-handler skills; where a model argument is server-side escaped (${lc:enc:args.location}); the dual response shapes accepted from upstream (chunks|results, text|content); the every-failure-becomes-a-spoken-result pattern; and the actual behaviour where it differs from the tool description (spider's crawl fetches only the start page, its extract applies no selectors). DOC-SURFACE ruby: 92.1% -> 95.6% (3219/3366). Co-Authored-By: Claude Opus 5 (1M context) --- .../skills/builtin/api_ninjas_trivia.rb | 32 +++++++++++++ .../skills/builtin/claude_skills.rb | 15 ++++++ .../skills/builtin/custom_skills.rb | 15 ++++++ lib/signalwire/skills/builtin/datasphere.rb | 47 +++++++++++++++++++ .../skills/builtin/datasphere_serverless.rb | 39 +++++++++++++++ lib/signalwire/skills/builtin/datetime.rb | 26 ++++++++++ lib/signalwire/skills/builtin/joke.rb | 11 +++++ .../skills/builtin/native_vector_search.rb | 31 ++++++++++++ .../skills/builtin/play_background_file.rb | 45 ++++++++++++++++++ lib/signalwire/skills/builtin/spider.rb | 44 +++++++++++++++++ .../skills/builtin/swml_transfer.rb | 43 +++++++++++++++++ lib/signalwire/skills/builtin/weather_api.rb | 38 +++++++++++++++ lib/signalwire/skills/builtin/web_search.rb | 42 +++++++++++++++++ .../skills/builtin/wikipedia_search.rb | 22 +++++++++ 14 files changed, 450 insertions(+) diff --git a/lib/signalwire/skills/builtin/api_ninjas_trivia.rb b/lib/signalwire/skills/builtin/api_ninjas_trivia.rb index ca221a5a..dc93865a 100644 --- a/lib/signalwire/skills/builtin/api_ninjas_trivia.rb +++ b/lib/signalwire/skills/builtin/api_ninjas_trivia.rb @@ -9,6 +9,9 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Fetch trivia questions from API Ninjas as a DataMap tool — the request runs + # ON SignalWire's servers, so there is no webhook back to this agent. Requires + # an `API_NINJAS_KEY` (or an `api_key` param). class ApiNinjasTriviaSkill < SkillBase VALID_CATEGORIES = { 'artliterature' => 'Art and Literature', @@ -27,7 +30,13 @@ class ApiNinjasTriviaSkill < SkillBase 'sportsleisure' => 'Sports and Leisure' }.freeze + # The name this skill is added under (`agent.add_skill('api_ninjas_trivia')`). + # + # @return [String] def name = 'api_ninjas_trivia' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Get trivia questions from API Ninjas' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -61,6 +70,10 @@ def setup true end + # The key this instance is tracked under — `api_ninjas_trivia_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "api_ninjas_trivia_#{@tool_name}" # Returns the raw SWAIG tool DEFINITION hashes (the DataMap tool the @@ -99,6 +112,11 @@ def get_parameter_schema private + # @api private — the tool's JSON Schema: one required `category`, constrained + # to the configured category list so the model cannot invent one the API would + # reject. + # + # @return [Hash] def tool_parameters { 'type' => 'object', @@ -109,6 +127,11 @@ def tool_parameters } end + # @api private — the category parameter's description, spelling out every + # configured category and what it covers, so the model can pick from the + # description alone. + # + # @return [String] def category_param_desc descs = @categories.map { |c| "#{c}: #{VALID_CATEGORIES[c] || c}" } "Category for trivia question. Options: #{descs.join('; ')}" @@ -124,6 +147,10 @@ def base_url base.sub(%r{/$}, '') end + # @api private — the DataMap: the trivia webhook, `error` as the failure key, + # and a spoken fallback used when the request fails. + # + # @return [Hash] def tool_data_map { 'webhooks' => [trivia_webhook], @@ -134,6 +161,11 @@ def tool_data_map } end + # @api private — the API Ninjas request the platform issues, with the key in + # the `X-Api-Key` header. The output template reads the first array element and + # explicitly tells the model to pause before revealing the answer. + # + # @return [Hash] def trivia_webhook output = Swaig::FunctionResult.new( 'Category %{array[0].category} question: %{array[0].question} ' \ diff --git a/lib/signalwire/skills/builtin/claude_skills.rb b/lib/signalwire/skills/builtin/claude_skills.rb index 2e892679..1a32c03b 100644 --- a/lib/signalwire/skills/builtin/claude_skills.rb +++ b/lib/signalwire/skills/builtin/claude_skills.rb @@ -19,7 +19,13 @@ module Builtin # registered per discovered skill. A loose `.md` file that is NOT a # `SKILL.md` inside a skill directory is ignored. class ClaudeSkillsSkill < SkillBase + # The name this skill is added under (`agent.add_skill('claude_skills')`). + # + # @return [String] def name = 'claude_skills' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Load Claude SKILL.md files as agent tools' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -44,6 +50,10 @@ def setup true end + # The key this instance is tracked under — `claude_skills_` — so + # one agent can load several skill directories without colliding. + # + # @return [String] def instance_key = "claude_skills_#{@skills_path}" # The SWAIG tool definitions this skill contributes to its agent. Each @@ -105,6 +115,11 @@ def valid_skills_path? @skills_path && !@skills_path.empty? && File.directory?(@skills_path) end + # @api private — one SWAIG tool per discovered SKILL.md. Calling the tool + # returns the skill file's BODY as the result: the model is handed the + # instructions to follow, not the output of running anything. + # + # @return [Hash] def skill_tool(skill) { name: "#{@tool_prefix}#{skill[:safe_name]}", diff --git a/lib/signalwire/skills/builtin/custom_skills.rb b/lib/signalwire/skills/builtin/custom_skills.rb index 57acdb7e..dfaff6e8 100644 --- a/lib/signalwire/skills/builtin/custom_skills.rb +++ b/lib/signalwire/skills/builtin/custom_skills.rb @@ -11,7 +11,13 @@ module Skills module Builtin # User-defined custom tools. class CustomSkillsSkill < SkillBase + # The name this skill is added under (`agent.add_skill('custom_skills')`). + # + # @return [String] def name = 'custom_skills' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Register user-defined custom tools' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -31,6 +37,10 @@ def setup true end + # The key this instance is tracked under — `custom_skills_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key tool_name = get_param('tool_name', default: 'custom') "custom_skills_#{tool_name}" @@ -62,6 +72,11 @@ def get_parameter_schema private + # @api private — one SWAIG tool from a `tools` config entry. The handler + # ignores its arguments and returns the entry's fixed `response` string, so + # these are canned-answer tools, not computed ones. + # + # @return [Hash] def build_custom_tool(tool_def) { name: tool_def['name'], diff --git a/lib/signalwire/skills/builtin/datasphere.rb b/lib/signalwire/skills/builtin/datasphere.rb index 81dc74a8..16555b5b 100644 --- a/lib/signalwire/skills/builtin/datasphere.rb +++ b/lib/signalwire/skills/builtin/datasphere.rb @@ -25,6 +25,10 @@ module DatasphereSearch private + # @api private — read the skill's configuration: the space, credentials + # (falling back to `SIGNALWIRE_PROJECT_ID` / `SIGNALWIRE_API_TOKEN`), the + # document to search, the result count and distance threshold, the tool name, + # optional tags, and the message spoken when nothing matches. def read_params @space_name = get_param('space_name') @project_id = get_param('project_id', env_var: 'SIGNALWIRE_PROJECT_ID') @@ -37,6 +41,8 @@ def read_params @no_results_msg = get_param('no_results_message', default: DEFAULT_NO_RESULTS_MESSAGE) end + # @api private — the prompt bullets, naming this instance's CONFIGURED tool + # name so the model refers to the tool it will actually be offered. def prompt_section_bullets [ "Use the #{tool_name} tool when users ask for information that might be in the knowledge base", @@ -53,6 +59,11 @@ def datasphere_host_url resolved_base_url('DATASPHERE_BASE_URL', "https://#{space_name}.signalwire.com") end + # @api private — the search handler: POST the query to DataSphere and format + # the chunks. An empty query, a non-2xx response, or a raised error each become + # a spoken FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_search(args, _raw_data) query = (args['query'] || '').strip return Swaig::FunctionResult.new('Please provide a search query.') if query.empty? @@ -67,6 +78,10 @@ def handle_search(args, _raw_data) Swaig::FunctionResult.new("Error searching knowledge base: #{e.message}") end + # @api private — POST the search: the document id, query string, distance + # threshold and count, plus `tags` when configured. + # + # @return [Net::HTTPResponse] def post_search(query) payload = { 'document_id' => document_id, 'query_string' => query, @@ -78,12 +93,20 @@ def post_search(query) http_for(uri).request(build_search_request(uri, payload)) end + # @api private — the Net::HTTP transport for +uri+, with TLS on for an https + # scheme (so a plain-http test endpoint still works). + # + # @return [Net::HTTP] def http_for(uri) http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = (uri.scheme == 'https') http end + # @api private — the DataSphere search request: JSON content/accept types, + # HTTP-basic auth from the project id and token, and the payload as the body. + # + # @return [Net::HTTP::Post] def build_search_request(uri, payload) req = Net::HTTP::Post.new(uri.path) req['Content-Type'] = 'application/json' @@ -93,6 +116,12 @@ def build_search_request(uri, payload) req end + # @api private — render the search response for the model. Chunks arrive under + # `chunks` from DataSphere itself and under `results` from some upstream + # shapes, so BOTH keys are accepted. No chunks yields the configured + # no-results message. + # + # @return [Swaig::FunctionResult] def format_search_response(data, query) # Real DataSphere uses `chunks`; audit fixtures also serve `results` # (real-shape upstream-response variation). Accept both shapes. @@ -104,6 +133,11 @@ def format_search_response(data, query) ) end + # @api private — render each chunk as a numbered, delimited block. The text is + # read from `text`, `content` or `chunk`, falling back to the raw JSON so an + # unexpected shape is still shown rather than silently dropped. + # + # @return [String] def format_chunks(chunks) chunks.each_with_index.map do |chunk, i| text = chunk['text'] || chunk['content'] || chunk['chunk'] || chunk.to_json @@ -112,13 +146,22 @@ def format_chunks(chunks) end end + # Search a SignalWire DataSphere document from the agent, over the platform's + # RAG search endpoint. Requires a space, project credentials and a document id; + # the skill refuses to load without all four. class DatasphereSkill < SkillBase include DatasphereSearch TOOL_DESCRIPTION = 'Search the knowledge base for information on any topic and return relevant results' + # The name this skill is added under (`agent.add_skill('datasphere')`). + # + # @return [String] def name = 'datasphere' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Search knowledge using SignalWire DataSphere RAG stack' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -142,6 +185,10 @@ def setup true end + # The key this instance is tracked under — `datasphere_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "datasphere_#{tool_name}" # Tears down the skill. A fresh Net::HTTP connection is opened per diff --git a/lib/signalwire/skills/builtin/datasphere_serverless.rb b/lib/signalwire/skills/builtin/datasphere_serverless.rb index ecfde7da..07eb7e16 100644 --- a/lib/signalwire/skills/builtin/datasphere_serverless.rb +++ b/lib/signalwire/skills/builtin/datasphere_serverless.rb @@ -12,8 +12,18 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # The DataSphere search as a DataMap tool: the search runs ON SignalWire's + # servers rather than through a webhook back to this agent, so there is no + # round trip to the agent process and no handler to time out. Same credentials + # and document as {DatasphereSkill}. class DatasphereServerlessSkill < SkillBase + # The name this skill is added under (`agent.add_skill('datasphere_serverless')`). + # + # @return [String] def name = 'datasphere_serverless' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Search knowledge using SignalWire DataSphere with serverless DataMap execution' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -35,6 +45,10 @@ def setup true end + # The key this instance is tracked under — `datasphere_serverless_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "datasphere_serverless_#{@tool_name}" # The SWAIG tool definitions this skill contributes to its agent. Each @@ -104,6 +118,9 @@ def get_parameter_schema private + # @api private — read the space, credentials (falling back to + # `SIGNALWIRE_PROJECT_ID` / `SIGNALWIRE_API_TOKEN`), document id, result count + # and distance threshold, tool name, and the no-results message. def load_params @space_name = get_param('space_name') @project_id = get_param('project_id', env_var: 'SIGNALWIRE_PROJECT_ID') @@ -116,6 +133,8 @@ def load_params default: "I couldn't find any relevant information in the knowledge base.") end + # @api private — the prompt bullets, naming this instance's CONFIGURED tool + # name. def prompt_bullets [ "Use the #{@tool_name} tool when users ask for information", @@ -125,6 +144,10 @@ def prompt_bullets ] end + # @api private — whether the space, project id, token and document id are all + # set. All four are required; the skill refuses to load otherwise. + # + # @return [Boolean] def required_params_present? %w[space_name project_id token document_id].all? do |k| v = instance_variable_get("@#{k}") @@ -132,6 +155,12 @@ def required_params_present? end end + # @api private — the headers SignalWire's servers send on the DataMap webhook: + # JSON content type plus the pre-encoded HTTP-basic credentials. These + # credentials travel INTO the emitted SWML, so the platform can call DataSphere + # on this project's behalf. + # + # @return [Hash{String => String}] def webhook_headers { 'Content-Type' => 'application/json', @@ -139,6 +168,11 @@ def webhook_headers } end + # @api private — the DataSphere search body embedded in the DataMap. The query + # is the SWML expression `${args.query}`, substituted server-side from the + # model's tool arguments rather than by this process. + # + # @return [Hash{String => Object}] def search_params { 'document_id' => @document_id, @@ -148,6 +182,11 @@ def search_params } end + # @api private — the DataMap `foreach` that renders the response server-side: + # iterate the response's `chunks`, cap at the configured count, and append each + # chunk's text as a delimited result block into `formatted_results`. + # + # @return [Hash{String => Object}] def foreach_config { 'input_key' => 'chunks', diff --git a/lib/signalwire/skills/builtin/datetime.rb b/lib/signalwire/skills/builtin/datetime.rb index cd7c2251..adadc3b5 100644 --- a/lib/signalwire/skills/builtin/datetime.rb +++ b/lib/signalwire/skills/builtin/datetime.rb @@ -9,6 +9,9 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Tell the model the current date and time, optionally in a named timezone. + # Timezones are resolved through tzinfo rather than by mutating the process's + # `TZ`, so concurrent calls for different zones never interfere. class DateTimeSkill < SkillBase TIMEZONE_DESCRIPTION = "Timezone name (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC." PROMPT_SECTIONS = [ @@ -23,7 +26,13 @@ class DateTimeSkill < SkillBase } ].freeze + # The name this skill is added under (`agent.add_skill('datetime')`). + # + # @return [String] def name = 'datetime' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Get current date, time, and timezone information' # Timezones are resolved through the ``tzinfo`` gem — a thread-safe, @@ -73,6 +82,8 @@ def get_prompt_sections private + # @api private — the current-time tool definition. The timezone parameter is + # optional and defaults to UTC. def get_current_time_tool { name: 'get_current_time', @@ -82,6 +93,8 @@ def get_current_time_tool } end + # @api private — the current-date tool definition. The timezone parameter is + # optional and defaults to UTC. def get_current_date_tool { name: 'get_current_date', @@ -93,6 +106,11 @@ def get_current_date_tool } end + # @api private — the time handler, formatting as 12-hour time with the zone + # abbreviation. An unknown timezone yields a spoken error naming it rather than + # silently falling back to UTC. + # + # @return [Swaig::FunctionResult] def handle_get_time(args, _raw_data) tz_name = (args['timezone'] || 'UTC').strip now = resolve_time(tz_name) @@ -104,6 +122,10 @@ def handle_get_time(args, _raw_data) end end + # @api private — the date handler, formatting as "Weekday, Month DD, YYYY" + # so TTS reads it naturally. An unknown timezone yields a spoken error. + # + # @return [Swaig::FunctionResult] def handle_get_date(args, _raw_data) tz_name = (args['timezone'] || 'UTC').strip now = resolve_time(tz_name) @@ -115,6 +137,10 @@ def handle_get_date(args, _raw_data) end end + # @api private — the current time in +tz_name+. `UTC` short-circuits; anything + # else goes through tzinfo. + # + # @return [Time, nil] nil when the timezone is unknown def resolve_time(tz_name) return Time.now.utc if tz_name.upcase == 'UTC' diff --git a/lib/signalwire/skills/builtin/joke.rb b/lib/signalwire/skills/builtin/joke.rb index 04f09736..0ebe2125 100644 --- a/lib/signalwire/skills/builtin/joke.rb +++ b/lib/signalwire/skills/builtin/joke.rb @@ -10,11 +10,20 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Fetch jokes from the API Ninjas joke API as a DataMap tool — the request runs + # ON SignalWire's servers, so there is no webhook back to this agent. Requires + # an `API_NINJAS_KEY` (or an `api_key` param). class JokeSkill < SkillBase FALLBACK_MESSAGE = 'Sorry, there is a problem with the joke service right now. ' \ 'Please try again later.' + # The name this skill is added under (`agent.add_skill('joke')`). + # + # @return [String] def name = 'joke' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Tell jokes using the API Ninjas joke API' # Called once after construction. Return false to abort loading — the @@ -74,6 +83,8 @@ def get_prompt_sections ] end + # @api private — the prompt bullets, naming this instance's CONFIGURED tool + # name (falling back to `get_joke`). def joke_telling_bullets [ "Use #{tool_name || 'get_joke'} to tell jokes when users ask for humor", diff --git a/lib/signalwire/skills/builtin/native_vector_search.rb b/lib/signalwire/skills/builtin/native_vector_search.rb index 089e3da9..82a90f5b 100644 --- a/lib/signalwire/skills/builtin/native_vector_search.rb +++ b/lib/signalwire/skills/builtin/native_vector_search.rb @@ -15,7 +15,13 @@ module Skills module Builtin # Network/remote mode only (as per porting manifest). class NativeVectorSearchSkill < SkillBase + # The name this skill is added under (`agent.add_skill('native_vector_search')`). + # + # @return [String] def name = 'native_vector_search' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Search document indexes using vector similarity and keyword search (local or remote)' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -43,6 +49,10 @@ def setup true end + # The key this instance is tracked under — `native_vector_search_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "native_vector_search_#{@tool_name}" TOOL_PARAMETERS = { @@ -88,6 +98,11 @@ def get_parameter_schema private + # @api private — the search handler. The per-call `count` argument overrides + # the configured default. An empty query, an unavailable service, or a raised + # error each become a spoken FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_search(args, _raw_data) query = (args['query'] || '').strip return Swaig::FunctionResult.new('Please provide a search query.') if query.empty? @@ -103,6 +118,11 @@ def handle_search(args, _raw_data) Swaig::FunctionResult.new("Error searching: #{e.message}") end + # @api private — POST the query, result count and similarity threshold to the + # search service's `/search` endpoint, adding `index_name` when one is + # configured. + # + # @return [Net::HTTPResponse] def post_search(query, count) # Python parity: POST to "/search" (the remote_url is # a base URL; the /search endpoint is appended). @@ -122,6 +142,11 @@ def search_endpoint "#{@remote_url.chomp('/')}/search" end + # @api private — the Net::HTTP transport for the search endpoint, with TLS on + # for an https scheme and 10s connect / 30s read timeouts so a hung index + # server cannot stall the SWAIG handler indefinitely. + # + # @return [Net::HTTP] def search_http(uri) http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = (uri.scheme == 'https') @@ -130,6 +155,12 @@ def search_http(uri) http end + # @api private — render the search response as numbered, delimited blocks. + # Results arrive under `results` or `chunks` depending on the backend, and each + # item's text under `text` or `content`, so both shapes are accepted; an + # unrecognised item falls back to its raw JSON rather than being dropped. + # + # @return [Swaig::FunctionResult] def format_results(data, query, count) results = data['results'] || data['chunks'] || [] return Swaig::FunctionResult.new("No results found for '#{query}'.") if results.empty? diff --git a/lib/signalwire/skills/builtin/play_background_file.rb b/lib/signalwire/skills/builtin/play_background_file.rb index 14c6cad0..7768b381 100644 --- a/lib/signalwire/skills/builtin/play_background_file.rb +++ b/lib/signalwire/skills/builtin/play_background_file.rb @@ -9,8 +9,17 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Let the model start and stop background audio during a call. Emitted as a + # DataMap whose expressions match the chosen action, so playback is controlled + # server-side with no webhook back to this agent. class PlayBackgroundFileSkill < SkillBase + # The name this skill is added under (`agent.add_skill('play_background_file')`). + # + # @return [String] def name = 'play_background_file' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Control background file playback' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -41,6 +50,10 @@ def setup true end + # The key this instance is tracked under — `play_background_file_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "play_background_file_#{@tool_name}" # Returns the raw SWAIG tool DEFINITION hashes (the DataMap tool the @@ -82,6 +95,11 @@ def get_parameter_schema private + # @api private — the tool's JSON Schema: one required `action`, constrained to + # the enum of `start_` values plus `stop`, so the model cannot name a file + # that was not configured. + # + # @return [Hash] def tool_parameters { 'type' => 'object', @@ -92,25 +110,48 @@ def tool_parameters } end + # @api private — a usable file entry is a Hash carrying all three of `key` + # (how the action names it), `description` (what the model is told) and `url` + # (what is played). + # + # @return [Boolean] def valid_file?(file) file.is_a?(Hash) && file['key'] && file['description'] && file['url'] end + # @api private — the action enum: `start_` for each configured file, plus + # the single `stop`. + # + # @return [Array] def enum_values @files.map { |f| "start_#{f['key']}" } + ['stop'] end + # @api private — the action parameter's description, pairing each + # `start_` with that file's description so the model can choose from the + # description alone. + # + # @return [String] def action_param_desc descriptions = @files.map { |f| "start_#{f['key']}: #{f['description']}" } descriptions << 'stop: Stop any currently playing background file' "Action to perform. Options: #{descriptions.join('; ')}" end + # @api private — the DataMap expressions: one start branch per configured file, + # then the stop branch. + # + # @return [Array] def expressions exprs = @files.map { |f| start_expression(f) } exprs << stop_expression end + # @api private — the DataMap branch that starts one file. Matched + # case-insensitively against the action argument. `post_process` is set so the + # AI speaks its line BEFORE playback begins rather than over it. + # + # @return [Hash] def start_expression(file) result = Swaig::FunctionResult.new( "Tell the user you are now going to play #{file['description']} for them." @@ -125,6 +166,10 @@ def start_expression(file) } end + # @api private — the DataMap branch that stops playback, matched + # case-insensitively against the action argument. + # + # @return [Hash] def stop_expression stop_result = Swaig::FunctionResult.new( 'Tell the user you have stopped the background file playback.' diff --git a/lib/signalwire/skills/builtin/spider.rb b/lib/signalwire/skills/builtin/spider.rb index 9cfe7839..cfaa2a11 100644 --- a/lib/signalwire/skills/builtin/spider.rb +++ b/lib/signalwire/skills/builtin/spider.rb @@ -12,8 +12,18 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Fetch a web page and hand its text to the model. Strips HTML down to text, + # caps the result at `max_text_length`, and caches per URL for the life of the + # skill instance. `SPIDER_BASE_URL` redirects every fetch through a configured + # host for testing. class SpiderSkill < SkillBase + # The name this skill is added under (`agent.add_skill('spider')`). + # + # @return [String] def name = 'spider' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Fast web scraping and crawling capabilities' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -91,6 +101,10 @@ def cleanup nil end + # The key this instance is tracked under — `spider_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key "spider_#{get_param('tool_name', default: 'spider')}" end @@ -127,6 +141,7 @@ def get_parameter_schema private + # @api private — the single-page scrape tool definition, prefixed with this instance's tool prefix. def scrape_tool { name: "#{@tool_prefix}scrape_url", @@ -137,6 +152,7 @@ def scrape_tool } end + # @api private — the crawl tool definition, prefixed with this instance's tool prefix. def crawl_tool { name: "#{@tool_prefix}crawl_site", @@ -147,6 +163,7 @@ def crawl_tool } end + # @api private — the structured-extract tool definition, prefixed with this instance's tool prefix. def extract_tool { name: "#{@tool_prefix}extract_structured_data", @@ -157,6 +174,11 @@ def extract_tool } end + # @api private — the scrape handler: fetch the URL's text and hand it to the + # model with a character count. A missing URL, an unreachable page, or a raised + # error each become a spoken FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_scrape(args, _raw_data) url = (args['url'] || '').strip return Swaig::FunctionResult.new('Please provide a URL to scrape') if url.empty? @@ -169,6 +191,10 @@ def handle_scrape(args, _raw_data) Swaig::FunctionResult.new("Error scraping #{url}: #{e.message}") end + # @api private — the crawl handler. This implementation fetches the START page + # only and reports it as a one-page crawl; it does not follow links. + # + # @return [Swaig::FunctionResult] def handle_crawl(args, _raw_data) url = (args['start_url'] || '').strip return Swaig::FunctionResult.new('Please provide a starting URL for the crawl') if url.empty? @@ -181,12 +207,21 @@ def handle_crawl(args, _raw_data) Swaig::FunctionResult.new("Error crawling #{url}: #{e.message}") end + # @api private — the crawl report: the host, the page and its length, plus the + # first 500 characters as a summary. + # + # @return [String] def crawl_summary(url, text) summary = text.length > 500 ? "#{text[0, 500]}..." : text "Crawled 1 page from #{URI(url).host}:\n\n" \ "1. #{url} (#{text.length} chars)\n Summary: #{summary}" end + # @api private — the structured-extract handler. Despite the tool's + # "selectors" description it applies none: it returns the page's first 2000 + # characters of text and lets the model do the extraction. + # + # @return [Swaig::FunctionResult] def handle_extract(args, _raw_data) url = (args['url'] || '').strip return Swaig::FunctionResult.new('Please provide a URL') if url.empty? @@ -199,6 +234,11 @@ def handle_extract(args, _raw_data) Swaig::FunctionResult.new("Error extracting data: #{e.message}") end + # @api private — the cached fetch: resolve any `SPIDER_BASE_URL` redirect, + # return the cached body when present, else fetch, strip to text, truncate to + # `max_text_length` and cache. Any failure yields nil rather than raising. + # + # @return [String, nil] def fetch_text(url) url = redirect_url(url) return @cache[url] if cache_hit?(url) @@ -213,6 +253,10 @@ def fetch_text(url) nil end + # @api private — whether this URL is already cached. Guards on the cache + # existing, so a lookup after {#cleanup} is a miss rather than an error. + # + # @return [Boolean] def cache_hit?(url) defined?(@cache) && @cache&.key?(url) end diff --git a/lib/signalwire/skills/builtin/swml_transfer.rb b/lib/signalwire/skills/builtin/swml_transfer.rb index d924fe27..1cac5d5d 100644 --- a/lib/signalwire/skills/builtin/swml_transfer.rb +++ b/lib/signalwire/skills/builtin/swml_transfer.rb @@ -10,6 +10,10 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Transfer a call to a destination chosen by pattern-matching the model's + # argument. Emitted as a DataMap, so the match and the transfer both happen + # server-side. Each configured destination is either a SWML `url` to hand the + # call to, or an `address` to connect to. class SwmlTransferSkill < SkillBase PARAMETER_SCHEMA = { 'transfers' => { 'type' => 'object', 'required' => true }, @@ -19,7 +23,13 @@ class SwmlTransferSkill < SkillBase 'required_fields' => { 'type' => 'object', 'default' => {} } }.freeze + # The name this skill is added under (`agent.add_skill('swml_transfer')`). + # + # @return [String] def name = 'swml_transfer' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Transfer calls between agents based on pattern matching' # This skill may be loaded more than once on one agent — each instance # is distinguished by its `prefix` param, which also namespaces its @@ -41,6 +51,10 @@ def setup true end + # The key this instance is tracked under — `swml_transfer_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "swml_transfer_#{@tool_name}" # The SWAIG tool definitions this skill contributes to its agent. Each @@ -99,6 +113,11 @@ def get_parameter_schema private + # @api private — the DataMap skeleton: the transfer tool, its required + # destination-selecting parameter, and one required parameter per configured + # `required_fields` entry. + # + # @return [DataMap] def build_transfer_data_map dm = DataMap.new(@tool_name) .description(@desc) @@ -109,6 +128,9 @@ def build_transfer_data_map dm end + # @api private — read the tool name and description, the + # destination-selecting parameter's name and description, the message spoken + # for an unmatched value, and any extra required fields. def read_transfer_params @tool_name = get_param('tool_name', default: 'transfer_call') @desc = get_param('description', default: 'Transfer call based on pattern matching') @@ -128,6 +150,9 @@ def normalize_transfer_config(config) true end + # @api private — fill a transfer destination's optional fields: the spoken + # hand-off and return messages, and `post_process` / `final`, both defaulting + # to true. `final` true means the call does NOT come back to this agent. def apply_transfer_defaults(config) config['message'] ||= 'Transferring you now...' config['return_message'] ||= 'The transfer is complete. How else can I help you?' @@ -135,6 +160,10 @@ def apply_transfer_defaults(config) config['final'] = true unless config.key?('final') end + # @api private — the result for one destination: speak the hand-off message, + # then either `swml_transfer` to a `url` or `connect` to an `address`. + # + # @return [Swaig::FunctionResult] def build_transfer_result(config) result = Swaig::FunctionResult.new(config['message']) result.set_post_process(config['post_process']) @@ -146,6 +175,12 @@ def build_transfer_result(config) result end + # @api private — speech-recognition hints derived from a destination's match + # pattern: strip the regex delimiters and flags, split an alternation into its + # branches, and drop a pattern that is empty or starts with a wildcard (which + # would be a useless hint). + # + # @return [Array] def pattern_hints(pattern) clean = pattern.gsub(%r{^/|/i*$}, '') return [] if clean.empty? || clean.start_with?('.') @@ -154,10 +189,18 @@ def pattern_hints(pattern) clean.split('|').map { |p| p.strip.downcase } end + # @api private — the prompt section listing the available destinations, naming + # this instance's CONFIGURED tool name. + # + # @return [Hash] def transferring_section(bullets) { 'title' => 'Transferring', 'body' => "Transfer calls using #{@tool_name}.", 'bullets' => bullets } end + # @api private — the prompt section telling the model when to call the transfer + # tool and which parameter carries the destination. + # + # @return [Hash] def transfer_instructions_section instructions = ["Use the #{@tool_name} function when a transfer is needed", "Pass the destination type to the '#{@param_name}' parameter"] diff --git a/lib/signalwire/skills/builtin/weather_api.rb b/lib/signalwire/skills/builtin/weather_api.rb index eb27c3e2..866ac82e 100644 --- a/lib/signalwire/skills/builtin/weather_api.rb +++ b/lib/signalwire/skills/builtin/weather_api.rb @@ -10,8 +10,17 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Current weather from WeatherAPI.com as a DataMap tool: the request runs ON + # SignalWire's servers, so there is no webhook back to this agent. Requires a + # `WEATHER_API_KEY` (or an `api_key` param). class WeatherApiSkill < SkillBase + # The name this skill is added under (`agent.add_skill('weather_api')`). + # + # @return [String] def name = 'weather_api' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Get current weather information from WeatherAPI.com' # Extracts the configuration (tool_name / api_key / temperature_unit) @@ -64,6 +73,10 @@ def register_tools attr_reader :api_key, :tool_name, :temp_unit + # @api private — the tool's JSON Schema: one required `location` string, which + # the model fills from what the caller said. + # + # @return [Hash] def tool_parameters { 'type' => 'object', @@ -75,6 +88,10 @@ def tool_parameters } end + # @api private — the DataMap: the weather webhook, `error` as the failure key, + # and the fallback message as the output used when the request fails. + # + # @return [Hash] def tool_data_map { 'webhooks' => [weather_webhook], @@ -83,6 +100,12 @@ def tool_data_map } end + # @api private — the WeatherAPI request the platform issues. The location is + # the SWML expression `${lc:enc:args.location}` — lower-cased and URL-encoded + # server-side — so the model's raw argument is never spliced into the URL + # unescaped. + # + # @return [Hash] def weather_webhook { 'url' => "#{base_url}/v1/current.json?key=#{api_key}&q=${lc:enc:args.location}&aqi=no", @@ -91,6 +114,11 @@ def weather_webhook } end + # @api private — which WeatherAPI response fields and unit name to use for the + # configured `temperature_unit`: the `_c` fields for celsius, otherwise the + # `_f` fields. + # + # @return [Hash{Symbol => String}] def temperature_fields if temp_unit == 'celsius' { temp: 'temp_c', feels: 'feelslike_c', unit: 'Celsius' } @@ -99,6 +127,12 @@ def temperature_fields end end + # @api private — the instruction the model receives, with the WeatherAPI + # response interpolated by SWML expressions. It asks for temperatures as + # natural-language numbers without symbols or abbreviations, because the text + # is spoken by TTS. + # + # @return [String] def response_template temp_field, feels_field, unit_name = temperature_fields.values_at(:temp, :feels, :unit) 'Tell the user the current weather conditions. ' \ @@ -118,6 +152,10 @@ def base_url resolved_base_url('WEATHER_API_BASE_URL', 'https://api.weatherapi.com') end + # @api private — what the model is told when the weather request fails, phrased + # so it can offer the caller a retry or a corrected location. + # + # @return [String] def fallback_message 'Sorry, I cannot get weather information right now. ' \ 'Please try again later or check if the location name is correct.' diff --git a/lib/signalwire/skills/builtin/web_search.rb b/lib/signalwire/skills/builtin/web_search.rb index 82e95360..38fd4f8d 100644 --- a/lib/signalwire/skills/builtin/web_search.rb +++ b/lib/signalwire/skills/builtin/web_search.rb @@ -176,6 +176,10 @@ def calculate_content_quality(text, url, query) 'text_length' => length, 'query_relevance' => relevance } end + # @api private — the lower-cased host of a URL, or the empty string when it + # does not parse. Feeds the per-result quality scoring. + # + # @return [String] def url_domain(url) URI(url).host.to_s.downcase rescue StandardError @@ -205,6 +209,10 @@ def format_snippet_results(query, results, num_results) wrap_response(lines.join("\n").rstrip) end + # @api private — the numbered block for one snippet-only result: title, URL and + # the CSE snippet. + # + # @return [Array] def snippet_result_lines(result, index) ["=== RESULT #{index + 1} ===", "Title: #{result['title']}", @@ -227,6 +235,11 @@ def monotonic_now Process.clock_gettime(Process::CLOCK_MONOTONIC) end + # @api private — call the Google Custom Search API and normalise each item to + # `{title, url, snippet}`. A non-2xx response yields an empty list rather than + # raising, so a search-API outage degrades to "no results". + # + # @return [Array] def google_search(query, num) uri = google_search_uri(query, num) response = Net::HTTP.get_response(uri) @@ -279,6 +292,8 @@ module WebSearchConfig :response_prefix, :response_postfix, :per_page_timeout, :overall_deadline, :parallel_scrape, :snippets_only + # @api private — the prompt bullets, naming this instance's CONFIGURED tool + # name and telling the model that results are already quality-filtered. def prompt_section_bullets [ "Use the #{tool_name} tool when users ask for information you need to look up", @@ -288,6 +303,10 @@ def prompt_section_bullets ] end + # @api private — the schema for the credentials and result-shaping params. The + # API key and engine id are marked hidden and carry their env-var names. + # + # @return [Hash] def core_parameter_schema { 'api_key' => { 'type' => 'string', 'required' => true, 'hidden' => true, @@ -318,6 +337,10 @@ def latency_parameter_schema } end + # @api private — read the credentials (falling back to `GOOGLE_SEARCH_API_KEY` + # / `GOOGLE_SEARCH_ENGINE_ID`), the result count, tool name, quality-score + # floor, inter-request delay, no-results message and the optional + # prefix/postfix wrapped around every non-empty result. def read_core_params @api_key = get_param('api_key', env_var: 'GOOGLE_SEARCH_API_KEY') @search_engine_id = get_param('search_engine_id', env_var: 'GOOGLE_SEARCH_ENGINE_ID') @@ -373,6 +396,11 @@ def bool_param(key, default) end end + # Search the web via Google Custom Search, scrape the resulting pages, score + # them for length and query relevance, and hand the model the high-quality + # ones. Bounded by per-page and overall deadlines so the handler finishes + # inside the platform's webhook timeout; falls back to CSE snippets when the + # deadline is hit or `snippets_only` is set. class WebSearchSkill < SkillBase include WebScraping include WebPageFetcher @@ -382,7 +410,13 @@ class WebSearchSkill < SkillBase 'Search the web for high-quality information, automatically filtering low-quality results' QUERY_PARAM_DESC = 'The search query - what you want to find information about' + # The name this skill is added under (`agent.add_skill('web_search')`). + # + # @return [String] def name = 'web_search' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Search the web for information using Google Custom Search API' # This skill's own version, independent of the SDK's. # @@ -409,6 +443,10 @@ def setup true end + # The key this instance is tracked under — `web_search_` — so several + # instances can coexist on one agent without colliding. + # + # @return [String] def instance_key = "web_search_#{tool_name}" # The SWAIG tool definitions this skill contributes to its agent. Each @@ -464,6 +502,10 @@ def get_parameter_schema private + # @api private — the search handler. An empty query or a raised error each + # become a spoken FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_search(args, _raw_data) query = (args['query'] || '').strip if query.empty? diff --git a/lib/signalwire/skills/builtin/wikipedia_search.rb b/lib/signalwire/skills/builtin/wikipedia_search.rb index 0e1c4228..ca00ba04 100644 --- a/lib/signalwire/skills/builtin/wikipedia_search.rb +++ b/lib/signalwire/skills/builtin/wikipedia_search.rb @@ -13,8 +13,17 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin + # Search Wikipedia and hand the model an article summary. Two upstream calls: + # a search for matching titles, then an intro-extract for each. Needs no + # credentials — the MediaWiki API is public. class WikipediaSearchSkill < SkillBase + # The name this skill is added under (`agent.add_skill('wikipedia_search')`). + # + # @return [String] def name = 'wikipedia_search' + # Human-readable summary of what the skill does, for skill listings. + # + # @return [String] def description = 'Search Wikipedia for information about a topic and get article summaries' DEFAULT_NO_RESULTS_MSG = "I couldn't find any Wikipedia articles for that query. " \ @@ -104,6 +113,10 @@ def num_results @num_results = 1 end + # @api private — the message spoken when nothing matched, memoized from the + # config with a default so it is usable before {#setup} has run. + # + # @return [String] def no_results_msg return @no_results_msg if defined?(@no_results_msg) && @no_results_msg @@ -146,6 +159,11 @@ def article_for(result) "**#{title}**\n\n#{content}" end + # @api private — the plain-text intro extract for one article title. A non-2xx + # response or a body without `query.pages` yields nil, and the caller falls + # back to the search snippet. + # + # @return [String, nil] def wiki_extract(title) extract_uri = URI( "#{api_endpoint}?action=query&prop=extracts&exintro&explaintext&format=json" \ @@ -158,6 +176,10 @@ def wiki_extract(title) pages.values.first&.dig('extract')&.strip end + # @api private — the search handler. An empty query or a raised error each + # become a spoken FunctionResult rather than an exception. + # + # @return [Swaig::FunctionResult] def handle_search(args, _raw_data) query = (args['query'] || '').strip return Swaig::FunctionResult.new('Please provide a search query for Wikipedia.') if query.empty? From a9db4e269944cc79467300e3e1d401c5c22090b6 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 18:06:41 -0400 Subject: [PATCH 37/90] =?UTF-8?q?docs(lib):=20document=20the=20last=20147?= =?UTF-8?q?=20declarations=20=E2=80=94=20DOC-SURFACE=20reaches=20100%?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit prefabs (survey/concierge/receptionist/faq_bot/info_gatherer): each agent's tool set, prompt sections and initial global_data, plus the validators and the matching rules its handlers use (concierge matches a service as a substring, faq_bot matches in both directions, receptionist requires an exact department name). swml/service, pom, logging, config_loader, session_manager, webhook_validator, url_validator, pagination, request_options, data_map and the small remainder: the load-bearing behaviour stated where it is not obvious — pagination terminates on an absent links.next and NOT on an empty data page; the SSRF check runs on the RESOLVED IP; the log scrub must sit on the emission path; the signature validator tries both port spellings because the signature covers the URL as sent; debug_components truncates the signature. DOC-SURFACE ruby: 95.6% -> 100.0% (3366/3366). Co-Authored-By: Claude Opus 5 (1M context) --- lib/signalwire/ai_chat/client.rb | 9 ++++ lib/signalwire/core/agent/prompt/manager.rb | 8 +++ lib/signalwire/core/agent/tools/registry.rb | 10 ++++ lib/signalwire/core/config_loader.rb | 22 +++++++++ lib/signalwire/core/logging_config.rb | 16 ++++++ lib/signalwire/core/pom_builder.rb | 4 ++ lib/signalwire/datamap/data_map.rb | 13 +++++ lib/signalwire/logging.rb | 21 ++++++++ lib/signalwire/pom/prompt_object_model.rb | 41 +++++++++++++++ lib/signalwire/pom/section.rb | 19 +++++++ lib/signalwire/prefabs/concierge.rb | 42 ++++++++++++++++ lib/signalwire/prefabs/faq_bot.rb | 24 +++++++++ lib/signalwire/prefabs/info_gatherer.rb | 24 +++++++++ lib/signalwire/prefabs/receptionist.rb | 25 ++++++++++ lib/signalwire/prefabs/survey.rb | 52 ++++++++++++++++++++ lib/signalwire/relay/collect_config.rb | 5 ++ lib/signalwire/relay/device.rb | 3 ++ lib/signalwire/relay/message.rb | 34 +++++++++++++ lib/signalwire/rest/pagination.rb | 19 +++++++ lib/signalwire/rest/request_options.rb | 15 ++++++ lib/signalwire/rest/rest_client.rb | 6 +++ lib/signalwire/runtime.rb | 5 ++ lib/signalwire/security/session_manager.rb | 14 ++++++ lib/signalwire/security/webhook_validator.rb | 25 ++++++++++ lib/signalwire/skills/skill_base.rb | 14 ++++++ lib/signalwire/swaig/parameter_schema.rb | 1 + lib/signalwire/swml/document.rb | 4 ++ lib/signalwire/swml/schema.rb | 8 +++ lib/signalwire/swml/service.rb | 44 +++++++++++++++++ lib/signalwire/utils/url_validator.rb | 20 ++++++++ 30 files changed, 547 insertions(+) diff --git a/lib/signalwire/ai_chat/client.rb b/lib/signalwire/ai_chat/client.rb index 51067fec..699f9655 100644 --- a/lib/signalwire/ai_chat/client.rb +++ b/lib/signalwire/ai_chat/client.rb @@ -75,6 +75,10 @@ class AIChatError < SignalWire::Error # The server-provided error message (without the +[code]+ prefix). attr_reader :server_message + # @param code [Integer, nil] the JSON-RPC error code, or nil when the failure + # rode the success envelope + # @param message [String] the server's error text; also readable via + # {#server_message} without the `[code]` prefix def initialize(code, message) @code = code @server_message = message @@ -359,6 +363,11 @@ def build_http(uri) http end + # @api private — the chat request: the Basic-auth header, JSON + # content/accept types, the SDK's versioned User-Agent, and the payload as the + # body. + # + # @return [Net::HTTP::Post] def build_request(uri, payload) req = Net::HTTP::Post.new(uri) req['Authorization'] = @auth_header diff --git a/lib/signalwire/core/agent/prompt/manager.rb b/lib/signalwire/core/agent/prompt/manager.rb index 7d3111b0..cd119d36 100644 --- a/lib/signalwire/core/agent/prompt/manager.rb +++ b/lib/signalwire/core/agent/prompt/manager.rb @@ -214,6 +214,9 @@ def validate_prompt_mode_exclusivity 'Please use either set_prompt_text() OR the prompt_add_* methods, not both.' end + # @api private — append subsection descriptors to +section+, tolerating both + # String and Symbol keys. An entry without a title is skipped rather than + # producing an untitled subsection. def add_subsections(section, subsections) return unless subsections.is_a?(Array) @@ -225,12 +228,17 @@ def add_subsections(section, subsections) end end + # @api private — append body text to a section, separating it from existing + # text with a blank line. An empty existing body is replaced outright rather + # than gaining a leading separator. def append_body(section, body) return unless body section.body = section.body.to_s.empty? ? body : "#{section.body}\n\n#{body}" end + # @api private — append a single `bullet` and/or a `bullets` array to a + # section. A nil/non-Array pair is a no-op. def append_bullets(section, bullet, bullets) to_add = [] to_add << bullet if bullet diff --git a/lib/signalwire/core/agent/tools/registry.rb b/lib/signalwire/core/agent/tools/registry.rb index 753bd203..247e9bfa 100644 --- a/lib/signalwire/core/agent/tools/registry.rb +++ b/lib/signalwire/core/agent/tools/registry.rb @@ -156,6 +156,9 @@ def build_definition(name, description, parameters, required, **opts) definition end + # @api private — add the optional SWAIG fields that were supplied: + # `fillers` (only when a non-empty Hash), `wait_file`, `wait_file_loops`, + # `webhook_url`, and `is_typed_handler` only when true. def apply_optional_fields(definition, opts) definition['fillers'] = opts[:fillers] if opts[:fillers].is_a?(Hash) && !opts[:fillers].empty? %i[wait_file wait_file_loops webhook_url].each do |key| @@ -164,6 +167,8 @@ def apply_optional_fields(definition, opts) definition['is_typed_handler'] = true if opts[:is_typed_handler] end + # @api private — merge caller-supplied extra SWAIG fields over the definition, + # stringifying their keys. A non-Hash is ignored. def merge_swaig_fields(definition, swaig_fields) return unless swaig_fields.is_a?(Hash) @@ -179,6 +184,11 @@ def normalise_parameters(parameters, required) schema.merge('required' => (existing + required).uniq) end + # @api private — a schema that already declares `type: object` passes through; + # a bare property map is wrapped as `{type: object, properties: …}`, and nil + # becomes an empty object schema. + # + # @return [Hash] def object_schema(parameters) return parameters if parameters.is_a?(Hash) && parameters['type'] == 'object' diff --git a/lib/signalwire/core/config_loader.rb b/lib/signalwire/core/config_loader.rb index 4364f3f4..8166f557 100644 --- a/lib/signalwire/core/config_loader.rb +++ b/lib/signalwire/core/config_loader.rb @@ -133,6 +133,9 @@ def self.find_config_file(service_name = nil, additional_paths = nil) private + # @api private — load the first readable config file from the search path. A + # file that fails to parse is SKIPPED and the search continues, so one broken + # config does not prevent a later valid one from being used. def load_config @config_paths.each do |path| next unless File.exist?(path) @@ -145,16 +148,29 @@ def load_config end end + # @api private — parse a config file as YAML or JSON, chosen by its extension. + # YAML is loaded in safe mode. + # + # @return [Hash] def parse_file(path) contents = File.read(path) path.end_with?('.yaml', '.yml') ? YAML.safe_load(contents) : JSON.parse(contents) end + # @api private — expand `${VAR}` / `${VAR:default}` references from the + # environment, then coerce the result to a scalar type. + # + # @return [Object] def substitute_string(value) result = value.gsub(VAR_PATTERN) { ENV.fetch(Regexp.last_match(1), Regexp.last_match(2) || '') } coerce_scalar(result) end + # @api private — turn a substituted string into a Boolean, Integer or Float + # when it looks like one, so `${PORT}` yields a number rather than a string. + # Anything else passes through unchanged. + # + # @return [Object] def coerce_scalar(result) lowered = result.downcase return true if lowered == 'true' @@ -165,6 +181,10 @@ def coerce_scalar(result) result end + # @api private — whether an underscore-joined path (`a_b_c`) resolves to a key + # in the nested Hash. + # + # @return [Boolean] def has_nested_key?(data, key_path) current = data key_path.split('_').each do |key| @@ -175,6 +195,8 @@ def has_nested_key?(data, key_path) true end + # @api private — write +value+ at an underscore-joined path, creating the + # intermediate Hashes as needed. def set_nested_key(data, key_path, value) keys = key_path.split('_') current = data diff --git a/lib/signalwire/core/logging_config.rb b/lib/signalwire/core/logging_config.rb index 6ecfd3e6..e30d663e 100644 --- a/lib/signalwire/core/logging_config.rb +++ b/lib/signalwire/core/logging_config.rb @@ -18,6 +18,8 @@ module SignalWire # Core — internal building blocks shared by the agent, SWML and SWAIG layers. module Core + # LoggingConfig — deployment-environment detection and the log-injection + # control-character scrub. module LoggingConfig module_function @@ -35,11 +37,18 @@ def get_execution_mode 'server' end + # @api private — whether AWS Lambda's marker variables are present. + # + # @return [Boolean] def lambda_env? env_set?('AWS_LAMBDA_FUNCTION_NAME') || env_set?('LAMBDA_TASK_ROOT') end private_class_method :lambda_env? + # @api private — whether Google Cloud Functions / Cloud Run marker variables + # are present. + # + # @return [Boolean] def google_cloud_function_env? env_set?('FUNCTION_TARGET') || env_set?('K_SERVICE') || @@ -47,6 +56,9 @@ def google_cloud_function_env? end private_class_method :google_cloud_function_env? + # @api private — whether Azure Functions marker variables are present. + # + # @return [Boolean] def azure_function_env? env_set?('AZURE_FUNCTIONS_ENVIRONMENT') || env_set?('FUNCTIONS_WORKER_RUNTIME') || @@ -54,6 +66,10 @@ def azure_function_env? end private_class_method :azure_function_env? + # @api private — whether an environment variable is set to a non-empty value. + # An empty string counts as unset, so `FOO=` does not trigger a detection. + # + # @return [Boolean] def env_set?(name) v = ENV.fetch(name, nil) !v.nil? && !v.empty? diff --git a/lib/signalwire/core/pom_builder.rb b/lib/signalwire/core/pom_builder.rb index a4067d19..4e58c6f6 100644 --- a/lib/signalwire/core/pom_builder.rb +++ b/lib/signalwire/core/pom_builder.rb @@ -132,6 +132,8 @@ def self.from_sections(sections) private + # @api private — append body text to a section, separating it from existing + # text with a blank line. An empty existing body is replaced outright. def append_body(section, body) section.body = if section.body && !section.body.empty? "#{section.body}\n\n#{body}" @@ -140,6 +142,8 @@ def append_body(section, body) end end + # @api private — index a section by title, so a later append can find it + # instead of creating a duplicate. def register_section(title, section) @sections[title] = section end diff --git a/lib/signalwire/datamap/data_map.rb b/lib/signalwire/datamap/data_map.rb index e35a5b98..f0da8669 100644 --- a/lib/signalwire/datamap/data_map.rb +++ b/lib/signalwire/datamap/data_map.rb @@ -26,6 +26,7 @@ module SignalWire class DataMap attr_reader :function_name + # @param function_name [String] the SWAIG function name this DataMap defines def initialize(function_name) @function_name = function_name @purpose_text = '' @@ -280,10 +281,18 @@ def self.add_parameters(builder, parameters) private + # @api private — convert a value to a Hash when it can be (a FunctionResult + # typically), else pass it through, so both typed builders and raw Hashes can + # be used as outputs. def to_h_if_possible(value) value.respond_to?(:to_h) ? value.to_h : value end + # @api private — the tool's JSON Schema from the declared parameters, adding + # `required` only when at least one parameter was marked required. No + # parameters yields an empty object schema. + # + # @return [Hash] def build_param_schema return { 'type' => 'object', 'properties' => {} } unless @parameters.any? @@ -292,6 +301,10 @@ def build_param_schema schema end + # @api private — the `data_map` object: expressions, webhooks, the fallback + # output and the global error keys, each included only when non-empty. + # + # @return [Hash] def build_data_map data_map = {} data_map['expressions'] = @expressions if @expressions.any? diff --git a/lib/signalwire/logging.rb b/lib/signalwire/logging.rb index fb567b24..e9b44586 100644 --- a/lib/signalwire/logging.rb +++ b/lib/signalwire/logging.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true module SignalWire + # Logging — the SDK's minimal leveled logger and its process-global level. module Logging LEVELS = { debug: 0, info: 1, warn: 2, error: 3, off: 4 }.freeze @@ -12,6 +13,11 @@ def self.global_level @global_level || resolve_level_from_env end + # Override the process-global log level, ignoring the environment. Pass nil + # via {.reset!} to go back to env-derived resolution. + # + # @param level [Symbol, String] one of the LEVELS keys + # @raise [ArgumentError] for an unknown level name def self.global_level=(level) level = level.to_sym if level.is_a?(String) raise ArgumentError, "Unknown log level: #{level}" unless LEVELS.key?(level) @@ -19,10 +25,16 @@ def self.global_level=(level) @global_level = level end + # Drop any explicitly-set level, so {.global_level} resolves from the + # environment again. Intended for tests that set a level and must not leak it + # into the next one. def self.reset! @global_level = nil end + # Whether logging is off entirely (level `:off`, i.e. `SIGNALWIRE_LOG_MODE=off`). + # + # @return [Boolean] def self.suppressed? global_level == :off end @@ -36,29 +48,38 @@ def self.logger(name) class Logger attr_reader :name + # @param name [String] the logger's namespace, prefixed to every line def initialize(name) @name = name @output = $stderr end + # Log at `:debug` — the most verbose level, dropped unless the global level is `:debug`. def debug(msg) log(:debug, msg) end + # Log at `:info`, the default level. def info(msg) log(:info, msg) end + # Log at `:warn` — something is wrong but the operation continued. def warn(msg) log(:warn, msg) end + # Log at `:error` — the operation failed. def error(msg) log(:error, msg) end private + # @api private — emit one line to stderr when +level+ passes the global + # threshold. Control characters are scrubbed BEFORE emission (log-injection + # defence): a caller-supplied newline or NUL must not be able to forge a log + # line, so the scrub has to be on the emission path rather than merely offered. def log(level, msg) return if Logging.suppressed? return if LEVELS[level] < LEVELS[Logging.global_level] diff --git a/lib/signalwire/pom/prompt_object_model.rb b/lib/signalwire/pom/prompt_object_model.rb index 98c94e43..19a123f0 100644 --- a/lib/signalwire/pom/prompt_object_model.rb +++ b/lib/signalwire/pom/prompt_object_model.rb @@ -24,6 +24,8 @@ module POM class PromptObjectModel attr_accessor :sections, :debug + # @param debug [Boolean] print the computed numbering to stderr while rendering; + # a troubleshooting aid for unexpected section numbers def initialize(debug: false) @sections = [] @debug = debug @@ -170,6 +172,12 @@ def add_pom_as_subsection(target, pom_to_add) private + # @api private — resolve a merge target given either a section title or a + # {Section} itself. + # + # @raise [ArgumentError] when no section has that title + # @raise [TypeError] when +target+ is neither a String nor a Section + # @return [Section] def resolve_target_section(target) case target when String @@ -202,6 +210,11 @@ def build(hash, is_subsection: false) section end + # Reject a malformed section descriptor: a non-Hash, a wrongly-typed field, or + # one with no content at all. A SUBSECTION must additionally carry a title, + # which a top-level section may omit. + # + # @raise [ArgumentError] def validate(hash, is_subsection: false) raise ArgumentError, 'Each section must be a Hash.' unless hash.is_a?(Hash) @@ -210,6 +223,11 @@ def validate(hash, is_subsection: false) raise ArgumentError, 'All subsections must have a title' if is_subsection && !hash.key?('title') end + # Reject a section whose `title` is not a String, whose `subsections` or + # `bullets` is not an Array, or whose `numbered` / `numberedBullets` is not a + # Boolean. Each is checked only when the key is present. + # + # @raise [ArgumentError] def validate_types(hash) if hash.key?('title') && !hash['title'].is_a?(String) raise ArgumentError, "'title' must be a string if present." @@ -221,18 +239,30 @@ def validate_types(hash) validate_boolean_field(hash, 'numberedBullets') end + # Reject a present-but-non-Array value for +key+. + # + # @raise [ArgumentError] def validate_array_field(hash, key) return unless hash.key?(key) && !hash[key].is_a?(Array) raise ArgumentError, "'#{key}' must be an Array if provided." end + # Reject a present-but-non-Boolean value for +key+. Only literal true/false + # pass — a truthy string does not. + # + # @raise [ArgumentError] def validate_boolean_field(hash, key) return unless hash.key?(key) && ![true, false].include?(hash[key]) raise ArgumentError, "'#{key}' must be a boolean if provided." end + # Reject a section with no content: it must have at least one of a non-empty + # body, non-empty bullets, or subsections. A section with only a title would + # render as a bare heading. + # + # @raise [ArgumentError] def validate_content(hash) return if %w[body bullets subsections].any? { |k| present?(hash, k) } @@ -240,10 +270,18 @@ def validate_content(hash) 'All sections must have either a non-empty body, non-empty bullets, or subsections' end + # Whether +key+ is present and holds a non-empty value. + # + # @return [Boolean] def present?(hash, key) hash.key?(key) && hash[key] && !hash[key].empty? end + # The {Section} keyword args for a descriptor Hash. Body and bullets are always + # passed (defaulted); the two numbering flags only when present, so an absent + # flag inherits Section's own default rather than being forced to false. + # + # @return [Hash] def section_kwargs(hash) kwargs = { body: hash.fetch('body', ''), bullets: hash.fetch('bullets', []) } kwargs[:numbered] = hash['numbered'] if hash.key?('numbered') @@ -262,6 +300,9 @@ def section_number(section, counter, any_section_numbered) [number, counter] end + # Print the computed numbering decisions to stderr, for diagnosing why a + # section did or did not get a number. Only called when the POM was built with + # `debug: true`. def debug_header(sections, any_section_numbered) warn "Any section numbered: #{any_section_numbered}" sections.each_with_index do |section, idx| diff --git a/lib/signalwire/pom/section.rb b/lib/signalwire/pom/section.rb index 32d4cf30..4885322f 100644 --- a/lib/signalwire/pom/section.rb +++ b/lib/signalwire/pom/section.rb @@ -135,6 +135,10 @@ def render_xml(indent: 0, section_number: nil) private + # @api private — a body must be a String. The error explicitly points at the + # `bullets:` parameter, because passing a list here is the common mistake. + # + # @raise [TypeError] def validate_body!(body) return if body.is_a?(String) @@ -143,6 +147,9 @@ def validate_body!(body) 'If you meant to pass a list of bullet points, use bullets parameter instead.' end + # @api private — bullets must be an Array or nil. + # + # @raise [TypeError] def validate_bullets!(bullets) return if bullets.nil? || bullets.is_a?(Array) @@ -167,6 +174,11 @@ def titled_or_numbered?(section_number) !@title.nil? || !section_number.empty? end + # @api private — the number a subsection renders under: the parent's number + # extended by its position when this level is numbered, else the parent's + # number unchanged. A subsection with `numbered: false` opts out. + # + # @return [Array] def child_section_number(section_number, subsection, idx, any_subsection_numbered) if any_subsection_numbered && subsection.numbered != false section_number + [idx + 1] @@ -175,6 +187,9 @@ def child_section_number(section_number, subsection, idx, any_subsection_numbere end end + # @api private — render each subsection as markdown. The heading level only + # deepens when this section is itself titled or numbered, so an untitled + # wrapper does not push its children a level down. def render_markdown_subsections(lines, level, section_number) any_subsection_numbered = @subsections.any?(&:numbered) nested = titled_or_numbered?(section_number) @@ -187,6 +202,8 @@ def render_markdown_subsections(lines, level, section_number) end end + # @api private — render the bullets as a `` element. Numbered bullets + # carry a 1-based `id` attribute. def render_xml_bullets(xml, indent_str) xml << "#{indent_str} " @bullets.each_with_index do |bullet, idx| @@ -199,6 +216,8 @@ def render_xml_bullets(xml, indent_str) xml << "#{indent_str} " end + # @api private — render each subsection inside a `` element, + # computing each child's number the same way the markdown renderer does. def render_xml_subsections(xml, indent_str, indent, section_number) xml << "#{indent_str} " any_subsection_numbered = @subsections.any?(&:numbered) diff --git a/lib/signalwire/prefabs/concierge.rb b/lib/signalwire/prefabs/concierge.rb index 46808b26..7c8c54b8 100644 --- a/lib/signalwire/prefabs/concierge.rb +++ b/lib/signalwire/prefabs/concierge.rb @@ -37,6 +37,15 @@ class Concierge # `self.special_instructions` (prefabs/concierge.py:79). attr_reader :hours_of_operation, :special_instructions + # @param venue_name [String] the venue the agent represents, used throughout its prompt + # @param services [Array] the services offered here + # @param amenities [Hash{String => Object}] amenity name to its details + # @param hours_of_operation [Hash{String => String}, String, nil] hours per label; + # a bare String is normalised to the default label so `global_data` always carries a map + # @param special_instructions [Array, nil] extra instruction bullets added to the prompt + # @param welcome_message [String, nil] the opening line; a default naming the venue is used when nil + # @param name [String] the agent's name + # @param route [String] the HTTP path the agent serves on def initialize(venue_name:, services:, amenities:, hours_of_operation: nil, special_instructions: nil, welcome_message: nil, name: 'concierge', route: '/concierge', **_opts) @@ -53,10 +62,18 @@ def initialize(venue_name:, services:, amenities:, hours_of_operation: nil, @route = route end + # The SWAIG tool names this prefab's agent exposes. + # + # @return [Array] def tools %w[get_amenity_info get_service_info check_availability get_directions] end + # The POM sections that make up the concierge agent's prompt: the venue + # welcome with its services and amenities, the special instructions when any + # were given, and the hours (always emitted, since they are defaulted). + # + # @return [Array] def prompt_sections sections = [ { @@ -72,6 +89,10 @@ def prompt_sections sections end + # The `global_data` the concierge agent starts with — the state its tools + # read and update over the course of the call. + # + # @return [Hash] def global_data { 'venue_name' => @venue_name, @@ -82,6 +103,10 @@ def global_data } end + # @api private — the amenity handler: look the amenity up case-insensitively + # and describe it, or list what IS available when it is unknown. + # + # @return [Swaig::FunctionResult] def handle_amenity_info(args, _raw_data) amenity = (args['amenity'] || '').downcase info = @amenities.find { |k, _v| k.downcase == amenity }&.last @@ -90,6 +115,11 @@ def handle_amenity_info(args, _raw_data) Swaig::FunctionResult.new("#{amenity.capitalize}: #{format_amenity_detail(info)}") end + # @api private — the service handler: match the request as a SUBSTRING of a + # known service, so a partial spoken name still resolves. An unmatched request + # gets the full service list rather than a bare refusal. + # + # @return [Swaig::FunctionResult] def handle_service_info(args, _raw_data) service = (args['service'] || '').downcase match = @services.find { |s| s.downcase.include?(service) } @@ -198,6 +228,10 @@ def instructions_section { 'title' => 'Instructions', 'bullets' => @special_instructions.map(&:to_s) } end + # @api private — the answer for an unknown amenity, naming every amenity that + # IS configured so the caller can pick one. + # + # @return [Swaig::FunctionResult] def amenity_not_found(amenity) Swaig::FunctionResult.new( "I don't have information about '#{amenity}'. " \ @@ -205,6 +239,10 @@ def amenity_not_found(amenity) ) end + # @api private — the answer for a service this venue does not offer, naming + # the ones it does. + # + # @return [Swaig::FunctionResult] def service_unavailable(service) Swaig::FunctionResult.new( "I'm sorry, we don't offer #{service} at #{@venue_name}. " \ @@ -212,6 +250,10 @@ def service_unavailable(service) ) end + # @api private — the answer for a location the agent has no directions to, + # redirecting the caller to front-desk staff. + # + # @return [Swaig::FunctionResult] def directions_unknown(location) Swaig::FunctionResult.new( "I don't have specific directions to #{location}. " \ diff --git a/lib/signalwire/prefabs/faq_bot.rb b/lib/signalwire/prefabs/faq_bot.rb index fbe80a00..9d885b45 100644 --- a/lib/signalwire/prefabs/faq_bot.rb +++ b/lib/signalwire/prefabs/faq_bot.rb @@ -38,6 +38,12 @@ class FaqBot # (prefabs/faq_bot.py:75). attr_reader :persona, :suggest_related + # @param faqs [Array] the question/answer pairs; must be non-empty + # @param suggest_related [Boolean] instruct the agent to offer related questions + # @param persona [String, nil] the agent's persona; a helpful-FAQ-bot default is used when nil + # @param name [String] the agent's name + # @param route [String] the HTTP path the agent serves on + # @raise [ArgumentError] when +faqs+ is empty or not an Array def initialize(faqs:, suggest_related: true, persona: nil, name: 'faq_bot', route: '/faq', **_opts) raise ArgumentError, 'faqs must be a non-empty Array' unless faqs.is_a?(Array) && !faqs.empty? @@ -49,10 +55,19 @@ def initialize(faqs:, suggest_related: true, persona: nil, @route = route end + # The SWAIG tool names this prefab's agent exposes. + # + # @return [Array] def tools %w[search_faq] end + # The POM sections that make up the FAQ agent's prompt: the persona with every + # question listed, plus a Related Questions section when `suggest_related` is + # on — the flag has to reach the PROMPT to change behaviour, not just + # `global_data`. + # + # @return [Array] def prompt_sections bullets = @faqs.map { |f| "Q: #{f['question']}" } sections = [ @@ -71,6 +86,10 @@ def prompt_sections sections end + # The `global_data` the FAQ agent starts with — the state its tools + # read and update over the course of the call. + # + # @return [Hash] def global_data { 'faqs' => @faqs, @@ -78,6 +97,11 @@ def global_data } end + # @api private — the FAQ lookup: match case-insensitively in BOTH directions + # (the query inside a question, or a question inside the query), so a partial + # spoken question still resolves. No match lists every topic the bot covers. + # + # @return [Swaig::FunctionResult] def handle_search(args, _raw_data) query = (args['query'] || '').downcase match = @faqs.find { |f| f['question'].downcase.include?(query) || query.include?(f['question'].downcase) } diff --git a/lib/signalwire/prefabs/info_gatherer.rb b/lib/signalwire/prefabs/info_gatherer.rb index f09122ea..803414ff 100644 --- a/lib/signalwire/prefabs/info_gatherer.rb +++ b/lib/signalwire/prefabs/info_gatherer.rb @@ -178,17 +178,23 @@ def register_info_gatherer_tools } }) end + # @api private — install the prefab's first prompt section on the agent. def build_info_gatherer_prompt section = prompt_sections.first prompt_add_section(section['title'], section['body']) end + # @api private — seed the question-flow state into the agent's `global_data`: + # the questions, a zero index and an empty answers list. def seed_static_global_data set_global_data( 'questions' => @questions, 'question_index' => 0, 'answers' => [] ) end + # @api private — tune the AI verb's speech timing for a question-and-answer + # flow: an 800 ms end-of-speech timeout and a 1000 ms speech-event timeout, so + # the agent does not cut a considered answer short. def configure_agent_settings set_params('end_of_speech_timeout' => 800, 'speech_event_timeout' => 1000) end @@ -220,12 +226,21 @@ def build_submit_result(questions, next_index, new_answers) result end + # @api private — the instruction the model receives for one question. The + # FIRST question carries a different lead-in, and a question needing + # confirmation appends the read-it-back directive. + # + # @return [String] def question_instruction(question_text, needs_confirmation, first:) "#{PROMPT_PREFIX[first ? :first : :next]}: #{question_text}\n\n" \ 'Make sure the answer fits the scope and context of the question before submitting it. ' + CONFIRM_TEXT[needs_confirmation ? true : false] end + # @api private — a non-empty Array whose every entry carries both a `key_name` + # and a `question_text` (either String- or Symbol-keyed). + # + # @raise [ArgumentError] naming the index of the offending question def validate_questions!(questions) raise ArgumentError, 'questions must be a non-empty Array' unless questions.is_a?(Array) && !questions.empty? @@ -256,10 +271,19 @@ def resolve_dynamic_questions(request_data, request) FALLBACK_QUESTIONS end + # @api private — read a named attribute off a request object, yielding an + # empty Hash when the object does not expose it or it is nil. Lets the + # question callback run against any request-like object. + # + # @return [Hash] def request_attr(request, name) (request.respond_to?(name) ? request.public_send(name) : nil) || {} end + # @api private — the initial question-flow state for a dynamically-resolved + # question list: the questions, a zero index and an empty answers list. + # + # @return [Hash] def fresh_global_data(questions) { 'questions' => questions, diff --git a/lib/signalwire/prefabs/receptionist.rb b/lib/signalwire/prefabs/receptionist.rb index a94b2dff..0f9bbcf2 100644 --- a/lib/signalwire/prefabs/receptionist.rb +++ b/lib/signalwire/prefabs/receptionist.rb @@ -40,10 +40,17 @@ def initialize(departments:, name: 'receptionist', route: '/receptionist', configure_agent_settings(voice) end + # The SWAIG tool names this prefab's agent exposes. + # + # @return [Array] def tools %w[transfer_to_department collect_caller_info] end + # The POM sections that make up the receptionist agent's prompt: the greeting + # plus one bullet per department with its description and number. + # + # @return [Array] def prompt_sections bullets = @departments.map { |d| "#{d['name']}: #{d['description'] || d['name']} (#{d['number']})" } [ @@ -55,6 +62,10 @@ def prompt_sections ] end + # The `global_data` the receptionist agent starts with: the department list and + # an empty `caller_info` bucket for its collect tool to fill. + # + # @return [Hash] def global_data { 'departments' => @departments, @@ -62,6 +73,11 @@ def global_data } end + # @api private — the transfer handler: look the department up by EXACT name + # and connect the call to its number. An unknown name gets the available list + # rather than a failed transfer. + # + # @return [Swaig::FunctionResult] def handle_transfer(args, _raw_data) dept_name = args['department'] dept = @departments.find { |d| d['name'] == dept_name } @@ -95,6 +111,11 @@ def configure_agent_settings(voice) @languages = [{ 'name' => 'English', 'code' => 'en-US', 'voice' => voice }] end + # @api private — a non-empty Array whose every entry carries both a `name` and + # a `number`. Returns the list with String-normalised keys. + # + # @raise [ArgumentError] naming the index of the offending department + # @return [Array] def validate_departments(departments) unless departments.is_a?(Array) && !departments.empty? raise ArgumentError, 'departments must be a non-empty Array' @@ -109,6 +130,10 @@ def validate_departments(departments) end end + # @api private — the answer for an unknown department, naming every one that + # IS configured so the caller can pick another. + # + # @return [Swaig::FunctionResult] def department_not_found_result names = @departments.map { |d| d['name'] }.join(', ') Swaig::FunctionResult.new( diff --git a/lib/signalwire/prefabs/survey.rb b/lib/signalwire/prefabs/survey.rb index 32f57d0e..fd2429c6 100644 --- a/lib/signalwire/prefabs/survey.rb +++ b/lib/signalwire/prefabs/survey.rb @@ -30,6 +30,10 @@ def validation_message(question, response) end end + # @api private — reject a rating outside 1..scale (default 5) or one that is + # not a whole number at all. + # + # @return [String, nil] the error text, or nil when valid def rating_error(question, response) scale = question['scale'] || 5 rating = Integer(response.strip, exception: false) @@ -38,6 +42,11 @@ def rating_error(question, response) "Invalid rating. Please provide a number between 1 and #{scale}." end + # @api private — reject an answer that is not one of the question's options. + # The comparison is case-insensitive and whitespace-trimmed, so a spoken answer + # matches without exact casing. + # + # @return [String, nil] the error text, or nil when valid def multiple_choice_error(question, response) options = question['options'] || [] return if options.any? { |opt| response.downcase.strip == opt.downcase } @@ -45,12 +54,19 @@ def multiple_choice_error(question, response) "Invalid choice. Please select one of: #{options.join(', ')}." end + # @api private — accept `yes`/`no`/`y`/`n`, case-insensitive and trimmed. + # + # @return [String, nil] the error text, or nil when valid def yes_no_error(response) return if %w[yes no y n].include?(response.downcase.strip) "Please answer with 'yes' or 'no'." end + # @api private — reject an empty answer only when the question is required. + # Required defaults to TRUE, so a question must opt OUT of being required. + # + # @return [String, nil] the error text, or nil when valid def open_ended_error(question, response) required = question.key?('required') ? question['required'] : true 'A response is required for this question.' if response.strip.empty? && required @@ -106,14 +122,25 @@ def initialize(survey_name:, questions:, introduction: nil, conclusion: nil, @route = route end + # The SWAIG tool names this prefab's agent exposes. + # + # @return [Array] def tools %w[start_survey submit_survey_answer get_survey_summary validate_response log_response] end + # The POM sections that make up the survey agent's prompt. + # + # @return [Array] def prompt_sections [personality_section, instructions_section, questions_section] end + # The `global_data` the survey agent starts with: the survey name, brand and + # retry budget, plus the `survey` state object holding the questions, the + # current index and the collected responses. + # + # @return [Hash] def global_data { 'survey_name' => @survey_name, 'brand_name' => @brand_name, @@ -125,15 +152,27 @@ def global_data } end + # @api private — the start handler: speak the introduction and ask the first + # question, numbered so the caller knows how long the survey is. + # + # @return [Swaig::FunctionResult] def handle_start(_args, _raw_data) q = @questions.first Swaig::FunctionResult.new("#{@introduction}\n\n[Question 1 of #{@questions.size}]: #{q['text']}") end + # @api private — the submit handler: acknowledge the answer back to the model. + # The response is carried in the agent's `global_data` by the runtime, not + # stored on this object. + # + # @return [Swaig::FunctionResult] def handle_submit(args, _raw_data) Swaig::FunctionResult.new("Response recorded: #{args['answer']}") end + # @api private — the summary handler: speak the closing message. + # + # @return [Swaig::FunctionResult] def handle_summary(_args, _raw_data) Swaig::FunctionResult.new(@conclusion) end @@ -197,12 +236,20 @@ def on_summary(summary, _raw_data = nil) private + # @api private — a survey needs at least one question; an empty list is + # rejected at construction rather than producing an agent with nothing to ask. + # + # @raise [ArgumentError] def validate_questions!(questions) return if questions.is_a?(Array) && !questions.empty? raise ArgumentError, 'questions must be a non-empty Array' end + # @api private — the opening line used when the caller supplied no + # `introduction:`. + # + # @return [String] def default_introduction(survey_name) "Welcome to the #{survey_name}. Let's get started." end @@ -227,6 +274,11 @@ def instructions_section } end + # @api private — the prompt section listing every question with its id and + # type, so the model knows the full sequence and what kind of answer each + # expects. An untyped question is presented as open-ended. + # + # @return [Hash] def questions_section { 'title' => "Survey: #{@survey_name}", diff --git a/lib/signalwire/relay/collect_config.rb b/lib/signalwire/relay/collect_config.rb index 277addd5..14281798 100644 --- a/lib/signalwire/relay/collect_config.rb +++ b/lib/signalwire/relay/collect_config.rb @@ -128,6 +128,9 @@ def hash [self.class, to_h].hash end + # A human-readable summary showing only the fields that are SET, in wire order. + # + # @return [String] def to_s "CollectConfig(#{to_h.inspect})" end @@ -150,6 +153,8 @@ def present_fields }.compact.to_a end + # @api private — stringify a Hash's top-level keys, matching the wire frame's + # string-keyed top level. A non-Hash passes through unchanged. def stringify(hash) return hash unless hash.is_a?(Hash) diff --git a/lib/signalwire/relay/device.rb b/lib/signalwire/relay/device.rb index ef6f807b..5785593d 100644 --- a/lib/signalwire/relay/device.rb +++ b/lib/signalwire/relay/device.rb @@ -133,6 +133,9 @@ def hash [self.class, @type, @params].hash end + # A human-readable summary: the device type and its params. + # + # @return [String] def to_s "Device(type=#{@type}, params=#{@params.inspect})" end diff --git a/lib/signalwire/relay/message.rb b/lib/signalwire/relay/message.rb index d65f64a2..028ed928 100644 --- a/lib/signalwire/relay/message.rb +++ b/lib/signalwire/relay/message.rb @@ -12,11 +12,19 @@ module Relay # lifecycle/completion. Relies on the host defining {#to_h} and the # @message_id/@direction/@state ivars. module MessageSerialization + # A short human-readable summary: the message id, direction, delivery state and + # the two numbers. Carries no credentials. + # + # @return [String] def to_s "Message(id=#{@message_id}, direction=#{@direction}, " \ "state=#{@state}, from=#{@from_number}, to=#{@to_number})" end + # Same as {#to_s} — the default `#inspect` would dump every ivar including the + # listener list. + # + # @return [String] def inspect to_s end @@ -65,6 +73,17 @@ class Message :reason, :result attr_accessor :state + # @param message_id [String] the server's identifier for this message + # @param context [String] the messaging context it belongs to + # @param direction [String] `"inbound"` or `"outbound"` + # @param from_number [String] the sender in E.164 + # @param to_number [String] the recipient in E.164 + # @param body [String] the message text + # @param media [Array, nil] MMS media URLs; nil becomes an empty Array + # @param segments [Integer] how many SMS segments the message was split into + # @param state [String] the delivery state (see {MessageState}) + # @param reason [String] why delivery failed, when it did + # @param tags [Array, nil] caller-supplied correlation tags; nil becomes an empty Array def initialize(message_id: '', context: '', direction: '', from_number: '', to_number: '', body: '', media: nil, segments: 0, state: '', reason: '', tags: nil) @@ -95,6 +114,10 @@ def on_event(handler, &block) @listeners << callback end + # Whether the message has reached a terminal delivery state. Non-blocking, + # unlike {#wait}. + # + # @return [Boolean] def done? @done end @@ -153,6 +176,9 @@ def to_h private + # @api private — hand a state event to every registered listener. A raising + # listener is warned about and the remaining listeners still run, so one bad + # handler cannot suppress the others. def notify_listeners(event) @listeners.each do |handler| handler.call(event) @@ -172,12 +198,17 @@ def wait_until_done(timeout) end end + # @api private — set each field as an ivar, defaulting `media` and `tags` to + # empty Arrays so callers never have to nil-check them. def assign_value_fields(**fields) fields[:media] = fields[:media] || [] fields[:tags] = fields[:tags] || [] fields.each { |name, value| instance_variable_set("@#{name}", value) } end + # @api private — initialise the completion machinery: the mutex and condition + # variable {#wait} blocks on, the done flag, the terminal event, and the + # callback and listener slots. def init_completion_tracking @mutex = Mutex.new @condition = ConditionVariable.new @@ -198,6 +229,9 @@ def _resolve(event) invoke_on_completed(event) end + # @api private — fire the on-completed callback OUTSIDE the mutex, so a + # callback that touches this message cannot deadlock. A raising callback is + # warned about, not propagated. def invoke_on_completed(event) return unless @on_completed diff --git a/lib/signalwire/rest/pagination.rb b/lib/signalwire/rest/pagination.rb index 8dd9b785..29751dc1 100644 --- a/lib/signalwire/rest/pagination.rb +++ b/lib/signalwire/rest/pagination.rb @@ -21,6 +21,13 @@ class PaginatedIterator attr_reader :http, :path, :params, :data_key, :index, :items, :done + # @param http [HttpClient] the transport each page fetch goes through + # @param path [String] the collection path to page over + # @param params [Hash, nil] initial query parameters; duplicated so a caller + # mutating the original cannot corrupt iterator state + # @param data_key [String] the response key holding the page's items + # @param request_options [RequestOptions, nil] forwarded to EVERY page fetch, so + # pagination honours the same timeout/retry contract as a single call def initialize(http, path, params = nil, data_key = 'data', request_options = nil) @http = http @path = path @@ -42,6 +49,11 @@ def initialize(http, path, params = nil, data_key = 'data', request_options = ni @seen_next = {} end + # Yield every item across all pages, fetching pages as needed. Without a block + # returns an Enumerator, so the whole Enumerable surface (`map`, `take`, …) + # works lazily over the pages. + # + # @return [Enumerator, void] def each return enum_for(:each) unless block_given? @@ -91,6 +103,10 @@ def next_item private + # @api private — fetch one page, append its items, and decide whether to + # continue. Termination is driven ONLY by the absence of a `links.next` — an + # empty `data` array does NOT stop iteration, because a filtered page can + # legitimately match nothing while later pages still have items. def fetch_next params_for_request = @params.empty? ? nil : @params resp = @http.get(@path, params_for_request, request_options: @request_options) @@ -126,6 +142,9 @@ def params_from_next_url(next_url) query.each_with_object({}) { |(k, v), flat| merge_query_param(flat, k, v) } end + # @api private — fold one query pair into the params Hash, promoting a repeated + # key to an Array so a multi-value parameter in the `next` link survives being + # re-sent. def merge_query_param(flat, key, value) if flat.key?(key) existing = flat[key] diff --git a/lib/signalwire/rest/request_options.rb b/lib/signalwire/rest/request_options.rb index b07d9310..63a559d0 100644 --- a/lib/signalwire/rest/request_options.rb +++ b/lib/signalwire/rest/request_options.rb @@ -116,6 +116,12 @@ class EffectiveOptions attr_reader :timeout, :retries, :retry_on_status, :retry_backoff, :abort_signal + # @param timeout [Numeric, nil] per-attempt wall-clock cap in seconds; nil for no cap + # @param retries [Integer] retries AFTER the first attempt (total attempts = retries + 1) + # @param retry_on_status [Array, Set] statuses eligible for retry, + # further narrowed for non-idempotent methods by {#status_retryable?} + # @param retry_backoff [Numeric] base backoff in seconds, doubled each attempt + # @param abort_signal [#set?, nil] checked before every attempt for cooperative cancellation def initialize(timeout:, retries:, retry_on_status:, retry_backoff:, abort_signal:) @timeout = timeout @retries = retries @@ -146,16 +152,25 @@ def status_retryable?(method, status) # their own that responds to +set?+ (e.g. a wrapper over their app's own # cancellation) — this class is a convenience, not a requirement. class AbortSignal + # Create an unset signal. def initialize @mutex = Mutex.new @set = false end + # Set the signal, cancelling any request that checks it from here on. A request + # already in flight is not interrupted — the check happens between attempts. + # + # @return [AbortSignal] self, for chaining def set! @mutex.synchronize { @set = true } self end + # Whether the signal has been set. Thread-safe; the REST client calls this + # before each attempt. + # + # @return [Boolean] def set? @mutex.synchronize { @set } end diff --git a/lib/signalwire/rest/rest_client.rb b/lib/signalwire/rest/rest_client.rb index 4c8018ec..676776d2 100644 --- a/lib/signalwire/rest/rest_client.rb +++ b/lib/signalwire/rest/rest_client.rb @@ -97,6 +97,12 @@ def materialize_namespaces! Namespaces::Generated::ResourceTree.instance_methods(false).each { |m| send(m) } end + # @api private — fail before any request when the project, token, or endpoint + # is missing. An explicit `base_url` substitutes for the space, which is what + # lets a client be pointed at a local endpoint without one. The error names + # every environment variable, so the failure is self-diagnosing. + # + # @raise [ArgumentError] def validate_credentials!(project_id, api_token, space, base_url) return unless project_id.empty? || api_token.empty? || (space.empty? && (base_url.nil? || base_url.empty?)) diff --git a/lib/signalwire/runtime.rb b/lib/signalwire/runtime.rb index 3d55ddf7..5ac3c9c4 100644 --- a/lib/signalwire/runtime.rb +++ b/lib/signalwire/runtime.rb @@ -41,6 +41,11 @@ module Runtime [:azure_function, %w[AZURE_FUNCTIONS_ENVIRONMENT FUNCTIONS_WORKER_RUNTIME AzureWebJobsStorage]] ].freeze + # Detect the deployment environment from its marker environment variables, in + # MODE_SIGNALS order. + # + # @return [Symbol] `:cgi`, `:lambda`, `:google_cloud_function`, + # `:azure_function`, or `:server` when none match def self.execution_mode MODE_SIGNALS.each { |mode, vars| return mode if env_present?(*vars) } :server diff --git a/lib/signalwire/security/session_manager.rb b/lib/signalwire/security/session_manager.rb index 1083cc1b..5cec48ba 100644 --- a/lib/signalwire/security/session_manager.rb +++ b/lib/signalwire/security/session_manager.rb @@ -198,11 +198,20 @@ def debug_token(token) private + # @api private — the debug report for a token that does not split into the + # expected number of parts: how many parts it had and how long it was. The + # token itself is never included. + # + # @return [Hash] def malformed_debug(token, parts) { 'valid_format' => false, 'parts_count' => parts.length, 'token_length' => token ? token.length : 0 } end + # @api private — the debug report for a well-formed token: its components plus + # its expiry status relative to now. + # + # @return [Hash] def decoded_debug(_token, parts) status = expiry_status(parts[2], Time.now.to_i) { @@ -212,6 +221,11 @@ def decoded_debug(_token, parts) } end + # @api private — the token's components for the debug report. The call id and + # the SIGNATURE are truncated — the signature is the secret-bearing part, so it + # is never reported in full. + # + # @return [Hash] def debug_components(parts, expiry_date) { 'call_id' => truncate(parts[0]), 'function' => parts[1], diff --git a/lib/signalwire/security/webhook_validator.rb b/lib/signalwire/security/webhook_validator.rb index 6d0af1fa..70b4086b 100644 --- a/lib/signalwire/security/webhook_validator.rb +++ b/lib/signalwire/security/webhook_validator.rb @@ -178,8 +178,12 @@ def self._forbidden_triple [403, { 'content-type' => 'text/plain' }, ['']] end + # @api private — hex-encoded HMAC-SHA1, one of the two signature encodings the + # platform emits. def self._hex_hmac_sha1(key, message) = OpenSSL::HMAC.hexdigest('SHA1', key.to_s, message.to_s) + # @api private — base64-encoded HMAC-SHA1, the other signature encoding the + # platform emits. def self._b64_hmac_sha1(key, message) Base64.strict_encode64(OpenSSL::HMAC.digest('SHA1', key.to_s, message.to_s)) end @@ -202,6 +206,8 @@ def self._sorted_concat_params(params) items.map { |pair| _concat_pair(pair) }.join end + # @api private — one `key + value` term of the signature base string. A nil + # value contributes the key alone, matching the platform's own concatenation. def self._concat_pair((key, value)) = "#{key}#{value unless value.nil?}" # @api private — normalize Hash / Array-of-pairs into [key, value] items; @@ -213,12 +219,21 @@ def self._concat_items(params) nil end + # @api private — flatten a Hash of params into `[key, value]` items, expanding + # an Array value into one item per element so repeated keys each contribute a + # term to the signature. + # + # @return [Array] def self._hash_items(params) params.flat_map do |k, v| v.is_a?(Array) ? v.map { |vi| [k.to_s, vi] } : [[k.to_s, v]] end end + # @api private — normalise an Array of `[key, value]` pairs into signature + # items, ignoring entries that are not at least two-element Arrays. + # + # @return [Array] def self._pair_items(params) # Accept [k, v] pairs (the most common form). params.select { |pair| pair.is_a?(Array) && pair.length >= 2 } @@ -272,6 +287,12 @@ def self._port_variant_url(url, parsed) # Else: non-standard explicit port — only try as-is (nil). end + # @api private — whether the parsed URL's port is its scheme's default. `URI` + # always populates `port`, so this is how an implicit default is told apart + # from one the sender actually wrote — the signature covers the URL string as + # SENT, so both spellings have to be tried. + # + # @return [Boolean] def self._implicit_default_port?(parsed) parsed.respond_to?(:default_port) && parsed.port == parsed.default_port end @@ -301,6 +322,10 @@ def self._build_url(parsed, port:) "#{parsed.scheme}://#{userinfo}#{netloc_host}#{port_part}#{_build_url_rest(parsed)}" end + # @api private — the path, query and fragment portion of a reassembled URL, + # each appended only when present. + # + # @return [String] def self._build_url_rest(parsed) rest = +(parsed.path || '') rest << "?#{parsed.query}" if parsed.query diff --git a/lib/signalwire/skills/skill_base.rb b/lib/signalwire/skills/skill_base.rb index 5264d0b3..8d4919ea 100644 --- a/lib/signalwire/skills/skill_base.rb +++ b/lib/signalwire/skills/skill_base.rb @@ -23,12 +23,26 @@ class SkillBase # pulled out of ``params`` if provided attr_reader :params, :agent, :logger, :swaig_fields + # The name this skill is added under. Every subclass MUST override this — the + # base raises rather than inventing a name. + # + # @return [String] + # @raise [NotImplementedError] when a subclass has not overridden it def name = raise(NotImplementedError, "#{self.class}#name") + # Human-readable summary of what the skill does. Every subclass MUST override + # this — the base raises rather than inventing one. + # + # @return [String] + # @raise [NotImplementedError] when a subclass has not overridden it def description = raise(NotImplementedError, "#{self.class}#description") # This skill's own version, independent of the SDK's. # # @return [String] '1.0.0' def version = '1.0.0' + # The environment variables this skill needs set before it can run; checked by + # {#validate_env_vars}. Empty by default. + # + # @return [Array] def required_env_vars = [] # The gem names this skill needs loadable before it can run; # consumed by {#validate_packages}. diff --git a/lib/signalwire/swaig/parameter_schema.rb b/lib/signalwire/swaig/parameter_schema.rb index 9c5989fb..98e6a97a 100644 --- a/lib/signalwire/swaig/parameter_schema.rb +++ b/lib/signalwire/swaig/parameter_schema.rb @@ -91,6 +91,7 @@ def self.build(&block) builder.to_h end + # Create an empty builder: no properties and nothing required yet. def initialize @properties = {} @required = [] diff --git a/lib/signalwire/swml/document.rb b/lib/signalwire/swml/document.rb index a326e3af..d8e38218 100644 --- a/lib/signalwire/swml/document.rb +++ b/lib/signalwire/swml/document.rb @@ -6,9 +6,13 @@ module SignalWire # SWML — SWML document construction, rendering and serving. module SWML + # A SWML document under construction: a version and an ordered list of verbs + # per section. Mutations are mutex-guarded, so a document can be built from + # more than one thread. class Document attr_reader :version, :sections + # Create an empty document at SWML version 1.0.0 with one empty `main` section. def initialize @version = '1.0.0' @sections = { 'main' => [] } diff --git a/lib/signalwire/swml/schema.rb b/lib/signalwire/swml/schema.rb index 5621af75..60a40d05 100644 --- a/lib/signalwire/swml/schema.rb +++ b/lib/signalwire/swml/schema.rb @@ -6,9 +6,13 @@ module SignalWire # SWML — SWML document construction, rendering and serving. module SWML + # The SWML verb registry, loaded from the bundled `schema.json`. Backs the + # dynamic verb dispatch on {Service}: a method name is a verb exactly when this + # schema knows it. class Schema attr_reader :verbs + # Load the bundled schema and build the verb table. def initialize @verbs = {} load_schema @@ -36,6 +40,10 @@ def get_verb(name) private + # @api private — build the verb table by walking `$defs.SWMLMethod.anyOf`, the + # schema's registry of every verb. + # + # @raise [RuntimeError] when the bundled schema.json is missing def load_schema schema_path = File.join(__dir__, 'schema.json') raise "SWML schema.json not found at #{schema_path}" unless File.exist?(schema_path) diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 743ddce3..2788536c 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -44,6 +44,10 @@ class Service # Maximum request body size enforced on /swaig and the main route (1 MB). SWAIG_FN_NAME = /\A[a-zA-Z_][a-zA-Z0-9_]*\z/ + # @param schema_path [String, nil] path to a SWML schema.json; nil uses the bundled copy + # @param config_file [String, nil] explicit config path, or nil to auto-discover + # @param schema_validation [Boolean] validate each verb against the schema as it is added; + # false accepts any verb config unchecked def initialize(name:, route: '/', host: '0.0.0.0', port: nil, basic_auth: nil, schema_path: nil, config_file: nil, schema_validation: true) @name = name @@ -127,6 +131,11 @@ def has_function(name) # def-wrappers (not alias_method) so placement is independent of where # the get_* target is defined in the class body. def all_functions = get_all_functions + # The basic-auth pair plus where it came from (`"environment"` / + # `"auto-generated"` / `"provided"`). Bare-noun form of + # {#get_basic_auth_credentials_with_source}. + # + # @return [Array(String, String, String)] def basic_auth_credentials_with_source = get_basic_auth_credentials_with_source # Ruby `?`-predicate form of has_function. def function?(name) = has_function(name) @@ -203,6 +212,11 @@ def method_missing(method_name, *args, **kwargs) end end + # Report every SWML verb name as a callable method, so `respond_to?(:play)` is + # true and the dynamic verb dispatch in {#method_missing} is discoverable + # rather than a silent trap. + # + # @return [Boolean] def respond_to_missing?(method_name, include_private = false) SWML.schema.valid_verb?(method_name.to_s) || super end @@ -520,6 +534,10 @@ def render @document.render end + # The current SWML document as indented, human-readable JSON. Same content as + # {#render}, formatted for reading rather than the wire. + # + # @return [String] def render_pretty @document.render_pretty end @@ -821,6 +839,11 @@ def service_basic_auth_source(user, pass) end end + # @api private — true when the active credentials came from + # SWML_BASIC_AUTH_USER / SWML_BASIC_AUTH_PASSWORD: both must be set, + # non-empty, and equal to what the service is using. + # + # @return [Boolean] def service_auth_from_env?(user, pass) env_user = ENV.fetch('SWML_BASIC_AUTH_USER', nil) env_pass = ENV.fetch('SWML_BASIC_AUTH_PASSWORD', nil) @@ -937,6 +960,11 @@ def dispatch_request(request_data, callback_path, headers = {}) end end + # @api private — the Rack router: `/health` and `/ready` unauthenticated, and + # the service's own route behind the security-header and timing-safe basic-auth + # middlewares. + # + # @return [Rack::Builder] def build_rack_app main_route = @route authenticated = build_authenticated_app @@ -1069,10 +1097,15 @@ class SecurityHeadersMiddleware 'cache-control' => 'no-store, no-cache, must-revalidate' }.freeze + # @param app [#call] the next Rack app in the stack def initialize(app) @app = app end + # Call the wrapped app and stamp the fixed security headers onto its response. + # + # @param env [Hash] the Rack env + # @return [Array] the Rack response triple, with HEADERS applied def call(env) status, headers, body = @app.call(env) HEADERS.each { |k, v| headers[k] = v } @@ -1084,11 +1117,19 @@ def call(env) # Middleware: timing-safe Basic-Auth # ------------------------------------------------------------------ class TimingSafeBasicAuth + # @param app [#call] the next Rack app in the stack + # @param service [Service] the service whose credentials are the expected pair def initialize(app, service) @app = app @service = service end + # Require valid basic auth before passing the request on. A missing or + # non-Basic Authorization header, or a credential mismatch, gets the same 401 + # challenge — the response does not distinguish the two. + # + # @param env [Hash] the Rack env + # @return [Array] the Rack response triple def call(env) auth = Rack::Auth::Basic::Request.new(env) return unauthorized unless auth.provided? && auth.basic? @@ -1105,6 +1146,9 @@ def credentials_ok?(auth) secure_compare(user, input_user) && secure_compare(pass, input_pass) end + # @api private — the 401 challenge: a `Basic realm="SignalWire SWML Service"` + # www-authenticate header and a JSON `{"error":"Unauthorized"}` body, not + # plain text. def unauthorized # Python parity: a JSON {"error":"Unauthorized"} body (not plain text). [ diff --git a/lib/signalwire/utils/url_validator.rb b/lib/signalwire/utils/url_validator.rb index 5bddb07c..4c8ffc10 100644 --- a/lib/signalwire/utils/url_validator.rb +++ b/lib/signalwire/utils/url_validator.rb @@ -51,6 +51,8 @@ def self._resolver @_resolver end + # @api private — override the DNS resolver, so tests can drive + # {.validate_url} without real name resolution. Not part of the public surface. def self._resolver=(value) @_resolver = value end @@ -77,6 +79,10 @@ def self.validate_url(url, allow_private = false) false end + # @api private — only `http` and `https` are allowed. Rejecting everything else + # is what stops `file:`, `gopher:` and friends from reaching the fetcher. + # + # @return [Boolean] def self._valid_scheme?(parsed) scheme = (parsed.scheme || '').downcase return true if %w[http https].include?(scheme) @@ -114,6 +120,12 @@ def self._hostname_safe?(hostname) end private_class_method :_hostname_safe? + # @api private — whether a resolved IP falls in one of the BLOCKED_NETWORKS + # (loopback, link-local, private ranges). This is the SSRF check itself: it + # runs on the RESOLVED address, so a public hostname pointing at an internal + # IP is still rejected. + # + # @return [Boolean] def self._ip_blocked?(hostname, ip_str) ip = _parse_ip(ip_str) return false if ip.nil? @@ -127,6 +139,10 @@ def self._ip_blocked?(hostname, ip_str) end private_class_method :_ip_blocked? + # @api private — parse an address string, yielding nil rather than raising for + # an unparseable value. + # + # @return [IPAddr, nil] def self._parse_ip(ip_str) IPAddr.new(ip_str) rescue IPAddr::InvalidAddressError @@ -134,6 +150,10 @@ def self._parse_ip(ip_str) end private_class_method :_parse_ip + # @api private — whether `SWML_ALLOW_PRIVATE_URLS` is set to 1/true/yes, the + # explicit opt-out that lets a deployment reach private addresses. + # + # @return [Boolean] def self._env_allows_private? v = (ENV['SWML_ALLOW_PRIVATE_URLS'] || '').downcase %w[1 true yes].include?(v) From 60cb67f30a245a318e3df356c171dbad8b6484f1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 18:07:57 -0400 Subject: [PATCH 38/90] chore(doc-surface): pin the floor at 100.0% Ratchets the gate so any new undocumented public declaration in lib/**/*.rb turns DOC-SURFACE red. Co-Authored-By: Claude Opus 5 (1M context) --- .doc_surface_floor | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.doc_surface_floor b/.doc_surface_floor index 00394b32..997b0a01 100644 --- a/.doc_surface_floor +++ b/.doc_surface_floor @@ -1 +1 @@ -52.4 +100.0 From a19ffaaa54e92246d2583f55b05447bb3d550a77 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 19:11:38 -0400 Subject: [PATCH 39/90] ci(doc-surface): flip from report-only to BLOCKING and drop the fail-open guard MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The gate ran on every one of these ports and could never fail: it passed --report-only, so a doc regression printed a line and the run stayed green. That was correct at graduation, when the floor was well below 100 and the point was visibility. It is wrong now — the port is at 100.0% and .doc_surface_floor is pinned there, so a newly-undocumented public symbol is a real regression with a pinned number to prove it. ALSO REMOVED THE SKIP-WITH-PASS GUARD, which was a second fail-open and the more dangerous of the two. Each invocation was wrapped in if [ -f "$1/scripts/doc_surface.py" ]; then ...; else echo "not on porting-sdk main yet — skip-pass"; fi That existed because doc_surface.py once lived only on a porting-sdk plan branch. It is on the pinned PORTING_SDK_REF today, so the branch is dead — and its behaviour is wrong on principle: a MISSING gate script must fail the run, not pass it. A path typo or a bad checkout would have silently disabled the gate with a reassuring green message. The stale comment blocks went with them; they still described a report-only gate at a graduation-era floor ("51.8% today", "92.0% today") that no longer exists. Per-PR rather than nightly: a pure text scan with no build, free next to the language toolchain. Verified per port against its pinned floor, exit 0, plus `bash -n` on the modified script. Also verified the gate can FAIL — see porting-sdk 6712757, which fixes a tolerance that made a 100% floor unfailable. That fix is a prerequisite for this commit meaning anything. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- scripts/run-ci.sh | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index 10e4c953..275354c1 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -241,11 +241,12 @@ sched_gate SNIPPET-RUN tier=nightly defer=1 desc="dynamic-port doc snippets run sched_gate EXAMPLES-RUN tier=nightly defer=1 desc="shipped examples load/start against the mock (modulo EXAMPLES_RUN_ALLOW.md; STRICT-MOCKS: MOCK_RELAY_STRICT=1)" \ -- env MOCK_RELAY_STRICT=1 python3 "$PORTING_SDK_DIR/scripts/examples_run.py" --port ruby --repo "$PORT_ROOT" -# DOC-SURFACE (§6.3): public doc-comment (YARD `#`) coverage floor. Report-only -# for now (--report-only never fails the run); the floor in .doc_surface_floor -# ratchets up as coverage improves and never regresses. -sched_gate DOC-SURFACE desc="public YARD doc-comment coverage holds the .doc_surface_floor ratchet (report-only)" \ - -- python3 "$PORTING_SDK_DIR/scripts/doc_surface.py" --port ruby --repo "$PORT_ROOT" --report-only +# DOC-SURFACE (§6.3): public doc-comment (YARD `#`) coverage floor. +# BLOCKING. ruby is at 100.0% (2162/2162) as of the 2026-07-29 burn and .doc_surface_floor +# is pinned there, so the next undocumented public method is a real regression with a +# pinned number to prove it — it must red the run rather than print a line and pass. +sched_gate DOC-SURFACE desc="public YARD doc-comment coverage holds the .doc_surface_floor ratchet (100% — blocking)" \ + -- python3 "$PORTING_SDK_DIR/scripts/doc_surface.py" --port ruby --repo "$PORT_ROOT" # WIRED-MODES (Part 1.6 / D7): guard that this run-ci still exports the # load-bearing strict-mode lines declared in WIRED_MODES.md (MOCK_RELAY_STRICT + From c54fedeca476e84b978bdbacb2c25ad40f09fb85 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 20:19:08 -0400 Subject: [PATCH 40/90] =?UTF-8?q?fix(swml):=20validate=20post=5Fprompt=20s?= =?UTF-8?q?hape=20=E2=80=94=20the=20validator=20passed=20configs=20that=20?= =?UTF-8?q?ABORT=20the=20call?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ripple of signalwire-python 4371610 into ruby. AIVerbHandler#validate_config checked `prompt` four ways and `post_prompt` ZERO times, so a hand-assembled config the engine kills the call over was reported valid: validate_config({'prompt' => {'text' => 'hi'}, 'post_prompt' => 'Summarize.'}) -> [true, []] # engine: calling.error, fatal:true, call aborted THE ENGINE TREATS THEM IDENTICALLY. mod_openai/app_config.c checks !cJSON_IsObject(assistant_prompt) at :3193 and !cJSON_IsObject(post_prompt) at :3219 — same structure, same fatal:true calling.error, 26 lines apart. Both error payloads read "must be an object with 'text' or 'pom' field"; post_prompt's names the array case explicitly ("not an array"). Under the spine — the server is the spec — validating one and not the other is an inconsistency in the CHECK, not a contract difference. SCOPE. build_config has ALWAYS emitted the correct shape ({'text' => ...}), so no ruby code path produced bad wire and nothing about what this SDK emits changes. The hole was only reachable through validate_config, which is public surface taking a caller-supplied Hash. THAT BLIND SPOT IS NOT THEORETICAL — IT IS HOW go SHIPPED THE BUG. go's Service.AI hand-assembled cfg["post_prompt"] as a bare string (fixed in go 51934ec) and go's validator mirrors this one, so nothing flagged it. Ruby faithfully reproduced the reference's blind spot; it did not invent it. This is a deliberate TIGHTENING of a public validator: a config that returned [true, []] may now return [false, [...]]. That is the point — those configs abort the call. Error string matches the reference and the file's existing style exactly ("'post_prompt' must be an object"), so fleet messages stay identical. post_prompt is OPTIONAL: absence is not an error, only present-but-not-a-Hash. TDD-bidirectional, RED landing ON the assertion rather than upstream: before test_validate_config_bare_string_post_prompt_is_rejected tests/swml_handler_test.rb:146 Expected true to not be truthy. test_validate_config_array_post_prompt_is_rejected tests/swml_handler_test.rb:156 Expected true to not be truthy. (3 positive controls green throughout — object accepted, absent accepted, build_config round-trip valid — so the reds are the new rule, not a broken fixture) after 22 runs, 0 failures The three "optional key must be an object when present" checks (prompt.contexts / post_prompt / SWAIG) are now one private optional_object_errors helper. Adding a fifth inline check pushed validate_config past AbcSize 21.63/17, CyclomaticComplexity 9/7 and PerceivedComplexity 9/8; extracting the repeated shape fixes the cause rather than raising a threshold. RED was re-proven against the refactored code (helper commented out -> same two failures) so the helper is not silently accepting everything. The new tests live in their own SwmlHandlerPostPromptShapeTest class, mirroring the reference's dedicated test class and keeping SwmlHandlerTest under ClassLength. Verified on the full tree: scripts/run-tests.sh -> 2736 runs, 7692 assertions, 0 failures, 0 errors 2731 -> 2736 is exactly the 5 new tests scripts/run-lint.sh -> 1376 files inspected, no offenses detected scripts/run-format.sh --check -> 1376 files inspected, no offenses detected scripts/run-ci.sh -> ==> CI FAIL (gates: SURFACE ) The one red is SURFACE:DRIFT, PRE-EXISTING AS OF THE ORACLE REGEN (porting-sdk 2410c9e) and NOT caused by this change — proven by running DRIFT with this change stashed and getting the byte-identical single drift: signalwire.core.data_map.create_simple_api_tool: - param-mismatch: param[6] (error_keys): type 'optional>' vs 'optional>' The oracle dropped `body` from create_simple_api_tool (signalwire-python f171ce3, the #176 ruling), so ruby's still-8-param port_signatures.json mis-compares at index 6. That is a separate fleet-wide ripple of f171ce3 (go/php/typescript share it) and is deliberately NOT addressed here — not fixed, not allow-listed, no PORT_SIGNATURE_OMISSIONS entry. Every other gate passes. NO EXISTING TEST RELIED ON THE LOOSE BEHAVIOUR — nothing needed updating to accommodate this. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/swml/swml_handler.rb | 26 +++++++++-- tests/swml_handler_test.rb | 70 +++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+), 3 deletions(-) diff --git a/lib/signalwire/swml/swml_handler.rb b/lib/signalwire/swml/swml_handler.rb index f50ea186..7ba22dad 100644 --- a/lib/signalwire/swml/swml_handler.rb +++ b/lib/signalwire/swml/swml_handler.rb @@ -61,7 +61,8 @@ def get_verb_name # # Checks that +prompt+ is present and an object, contains exactly one of # +text+ / +pom+ (mutually exclusive), that +prompt.contexts+ (if present) - # is an object, and that +SWAIG+ (if present) is an object. + # is an object, that +post_prompt+ (if present) is an object, and that + # +SWAIG+ (if present) is an object. # # @param config [Hash] the AI verb configuration # @return [Array(Boolean, Array)] (is_valid, error_messages) @@ -72,8 +73,18 @@ def validate_config(config) return [false, ["'prompt' must be an object"]] unless prompt.is_a?(Hash) errors = validate_base_prompt(prompt) - errors << "'prompt.contexts' must be an object" if prompt.key?('contexts') && !prompt['contexts'].is_a?(Hash) - errors << "'SWAIG' must be an object" if config.key?('SWAIG') && !config['SWAIG'].is_a?(Hash) + errors.concat(optional_object_errors(prompt, 'contexts', "'prompt.contexts'")) + # post_prompt is OPTIONAL, but when present the engine holds it to the + # SAME contract as prompt: mod_openai/app_config.c checks + # !cJSON_IsObject(assistant_prompt) at :3193 and !cJSON_IsObject(post_prompt) + # at :3219 -- same structure, same fatal:true calling.error, and both error + # payloads read "must be an object with 'text' or 'pom' field". Validating + # one and not the other reported configs VALID that abort the call on the + # wire; build_config has always emitted the right shape, so the hole was + # only reachable by a caller hand-assembling a config -- which is exactly + # how signalwire-go shipped a bare-string post_prompt (go 51934ec). + errors.concat(optional_object_errors(config, 'post_prompt', "'post_prompt'")) + errors.concat(optional_object_errors(config, 'SWAIG', "'SWAIG'")) [errors.empty?, errors] end @@ -113,6 +124,15 @@ def build_config(prompt_text: nil, prompt_pom: nil, contexts: nil, private + # Errors for an OPTIONAL key that must be an object when present. + # Absence is never an error; present-but-not-a-Hash always is. + def optional_object_errors(container, key, label) + return [] unless container.key?(key) + return [] if container[key].is_a?(Hash) + + ["#{label} must be an object"] + end + # Base-prompt errors for validate_config (exactly one of text/pom required). def validate_base_prompt(prompt) count = [prompt.key?('text'), prompt.key?('pom')].count(true) diff --git a/tests/swml_handler_test.rb b/tests/swml_handler_test.rb index b701b5d2..42578409 100644 --- a/tests/swml_handler_test.rb +++ b/tests/swml_handler_test.rb @@ -122,6 +122,76 @@ def test_validate_config_bad_swaig end end +# +post_prompt+ must be validated the same way +prompt+ is. +# +# THE ENGINE TREATS THEM IDENTICALLY. +mod_openai/app_config.c+ checks +# +!cJSON_IsObject(assistant_prompt)+ at :3193 and +!cJSON_IsObject(post_prompt)+ +# at :3219 — same structure, same +fatal: true+ +calling.error+, and both error +# payloads read "must be an object with 'text' or 'pom' field". post_prompt's +# names the array case explicitly ("not an array"). +# +# +build_config+ has always emitted the right shape ({ 'text' => ... }), so no +# code path here produced bad wire. The hole was in +validate_config+, which is +# PUBLIC surface taking a caller-supplied Hash: it checked +prompt+ four ways +# and +post_prompt+ zero times, so a hand-assembled config that ABORTS THE CALL +# was reported valid. That blind spot is exactly how signalwire-go shipped a +# bare-string post_prompt (fixed in go 51934ec). +# Rippled from signalwire-python 4371610. +class SwmlHandlerPostPromptShapeTest < Minitest::Test + def setup + @handler = SignalWire::SWML::AIVerbHandler.new + end + + def test_validate_config_bare_string_post_prompt_is_rejected + valid, errors = @handler.validate_config( + { 'prompt' => { 'text' => 'You are helpful.' }, 'post_prompt' => 'Summarize.' } + ) + + refute valid + assert_includes errors, "'post_prompt' must be an object" + end + + # The array case the engine names by name in its error payload. + def test_validate_config_array_post_prompt_is_rejected + valid, errors = @handler.validate_config( + { 'prompt' => { 'text' => 'hi' }, 'post_prompt' => [{ 'say' => 'x' }] } + ) + + refute valid + assert_includes errors, "'post_prompt' must be an object" + end + + # The shape build_config emits must stay valid. + def test_validate_config_object_post_prompt_is_accepted + valid, errors = @handler.validate_config( + { 'prompt' => { 'text' => 'hi' }, 'post_prompt' => { 'text' => 'Summarize.' } } + ) + + assert valid + assert_empty errors + end + + # post_prompt is OPTIONAL — absence must not become an error. + def test_validate_config_absent_post_prompt_is_accepted + valid, errors = @handler.validate_config({ 'prompt' => { 'text' => 'hi' } }) + + assert valid + assert_empty errors + end + + # The builder and the validator must agree — round-trip guard. + def test_build_config_output_validates + config = @handler.build_config(prompt_text: 'You are helpful.', post_prompt: 'Summarize.') + + assert_equal({ 'text' => 'Summarize.' }, config['post_prompt']) + + valid, errors = @handler.validate_config(config) + + assert valid + assert_empty errors + end +end + # Tests for the SWMLVerbHandler base class and the VerbHandlerRegistry. class SwmlVerbHandlerRegistryTest < Minitest::Test def setup From 91c5ba3a013803def5ddf50e2abc7170cd37fcce Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 20:30:57 -0400 Subject: [PATCH 41/90] =?UTF-8?q?fix(datamap):=20drop=20`body`=20from=20cr?= =?UTF-8?q?eate=5Fsimple=5Fapi=5Ftool=20=E2=80=94=20the=20key=20is=20inval?= =?UTF-8?q?id,=20not=20merely=20ignored?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ripples signalwire-python f171ce3 into ruby. OWNER-RULED 2026-07-29: "if the server doesn't read them, remove them." THREE INDEPENDENT SOURCES AGREE THAT `body` ON A WEBHOOK IS WRONG: * THE SPEC FORBIDS IT. porting-sdk/schema.json $defs/Webhook declares exactly ten properties — error_keys, expressions, foreach, headers, input_args_as_params, method, output, params, require_args, url — under `unevaluatedProperties: {"not": {}}`. `body` is not among them, so emitting it is a SCHEMA VIOLATION, not a harmless extra. * THE ENGINE NEVER READS IT. mod_openai/actions.c:735-739 and bedrock.c:4920-4926 each read url, method, form_param, `params`, `headers` and nothing else; `grep -n '"body"'` across both files returns ZERO matches. * THE HELPER SILENTLY DISCARDED THE CALLER'S DATA. create_simple_api_tool accepted `body:` and forwarded it to DataMap#body, which wrote a key nothing consumes. REPRODUCED BEFORE FIXING, not inferred: DataMap.create_simple_api_tool(..., method: 'POST', body: { 'query' => 'Q' }) -> webhook KEYS: ["body", "method", "output", "url"] An invalid key on the wire carrying the caller's payload into a void. AFTER: KEYS: ["method", "output", "url"]; `body` is absent from the signature and passing `body:` raises ArgumentError (unknown keyword: :body). Byte-for-byte the same before/after keys the reference recorded. TESTS. `test_create_simple_api_tool_with_body` asserted the defect (`wh['body']` equals the caller's hash) and is deleted. Three tests replace it: * test_create_simple_api_tool_rejects_body — the keyword is gone (RED before the fix: "ArgumentError expected but nothing was raised"). * test_create_simple_api_tool_emits_no_body_key — the emitted webhook carries no `body`. * test_create_simple_api_tool_emits_only_schema_keys — every emitted key is one of the ten schema.json $defs/Webhook permits (WEBHOOK_SCHEMA_KEYS, shared in DataMapTestAliases). DOCS. api_reference.md drops `body:` from the signature line and the parameter list. Its "Search with Array Processing" example taught `.body(...)` on a POST webhook — switched to `.params(...)`, mirroring the reference's module-docstring correction. `#params` gains the docstring the reference wrote: it is NOT an alias for `#body`; the two write different keys and only `params` is in the webhook contract. SCOPE HELD DELIBERATELY: `DataMap#body` — the public BUILDER METHOD — is NOT removed. The ruling was about the helper's parameter. Removing the builder is a larger, separately- breaking change belonging to its own decision, and the reference deferred it for the same reason. As in the reference, the discard site deleted here was the builder's only internal caller; what remains in ruby is 2 tests and 2 doc sections. SEMVER-DIFF (report-only) NOW FLAGS THIS AS BREAKING — it was `[ok]` before this commit. `create_simple_api_tool` went 8 params -> 7, which the gate correctly classifies as a member retype requiring a MAJOR bump (ruby is 3.0.0; required = 4.0.0). This is the intended, correct signal: the fix IS a breaking API change and belongs in the coordinated 4.0 breaking wave alongside the other nine ports. Not suppressed, not allow-listed. Verification: BEFORE 2736 runs, 7692 assertions, 0 failures (baseline) AFTER 2738 runs, 7696 assertions, 0 failures, 0 errors, 0 skips drift.sh . -> exit 0, signatures match (1564 reference symbols, 2549 port symbols) run-lint.sh -> 1376 files inspected, no offenses detected run-format.sh --check -> 1376 files inspected, no offenses detected run-ci.sh -> ==> CI PASS (22 gates PASS, 0 FAIL) The DRIFT red this closes (param[6] error_keys 'optional>' vs 'optional>', from porting-sdk oracle 2410c9e picking up f171ce3) was the only thing between wave6/ctor-dunder-fold and a fully green run-ci. It is now green. Rubocop metrics: extracting the schema key list into DataMapTestAliases and splitting the emission assertions into two tests holds ClassLength/AbcSize/MethodLength without raising a threshold or adding a suppression. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- docs/api_reference.md | 5 ++- lib/signalwire/datamap/data_map.rb | 11 ++++-- port_signatures.json | 7 ---- tests/datamap_test.rb | 54 +++++++++++++++++++++++++----- 4 files changed, 55 insertions(+), 22 deletions(-) diff --git a/docs/api_reference.md b/docs/api_reference.md index f0d0f6be..98207758 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -2677,7 +2677,7 @@ search_tool = SignalWire::DataMap.new('search_knowledge') 'https://api.company.com/search', headers: { 'Authorization' => 'Bearer TOKEN' } ) - .body({ + .params({ 'query' => '${args.query}', 'category' => '${args.category}', 'limit' => 5 @@ -2743,7 +2743,7 @@ agent.register_swaig_function(swaig_function) The SDK provides helper class methods for common DataMap patterns: -##### `DataMap.create_simple_api_tool(name:, url:, response_template:, parameters: nil, method: "GET", headers: nil, body: nil, error_keys: nil) -> DataMap` +##### `DataMap.create_simple_api_tool(name:, url:, response_template:, parameters: nil, method: "GET", headers: nil, error_keys: nil) -> DataMap` Create a simple API integration tool. @@ -2754,7 +2754,6 @@ Create a simple API integration tool. - `parameters` (Hash, optional): Parameter definitions - `method` (String): HTTP method (default: "GET") - `headers` (Hash, optional): HTTP headers -- `body` (Hash, optional): Request body - `error_keys` (Array, optional): Error field names **Usage:** diff --git a/lib/signalwire/datamap/data_map.rb b/lib/signalwire/datamap/data_map.rb index f0da8669..4fbd1ee2 100644 --- a/lib/signalwire/datamap/data_map.rb +++ b/lib/signalwire/datamap/data_map.rb @@ -156,6 +156,13 @@ def body(data) end # Set request params for the most-recently-added webhook. + # + # This is NOT an alias for +body+: the two write different webhook keys + # (+params+ vs +body+), and only +params+ is part of the webhook contract — + # schema.json +$defs/Webhook+ lists +params+ among its ten permitted + # properties and forbids everything else, and the engine's webhook readers + # look up +params+ and never +body+. Use this method for POST/PUT request + # data. def params(data) raise ArgumentError, 'Must add webhook before setting params' if @webhooks.empty? @@ -237,15 +244,13 @@ def to_swaig_function # @param parameters [Hash, nil] name => { "type" => ..., "description" => ..., "required" => bool } # @param method [String] HTTP method (default GET) # @param headers [Hash, nil] - # @param body [Hash, nil] # @param error_keys [Array, nil] # @return [DataMap] def self.create_simple_api_tool(name:, url:, response_template:, parameters: nil, - method: 'GET', headers: nil, body: nil, error_keys: nil) + method: 'GET', headers: nil, error_keys: nil) dm = new(name) add_parameters(dm, parameters) dm.webhook(method, url, headers: headers) - dm.body(body) if body dm.error_keys(error_keys) if error_keys dm.output(Swaig::FunctionResult.new(response_template)) dm diff --git a/port_signatures.json b/port_signatures.json index 4505cc6a..8bfa1432 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -4218,13 +4218,6 @@ "required": false, "default": null }, - { - "name": "body", - "type": "optional>", - "kind": "keyword", - "required": false, - "default": null - }, { "name": "error_keys", "type": "optional>", diff --git a/tests/datamap_test.rb b/tests/datamap_test.rb index e28bec85..242ee6ea 100644 --- a/tests/datamap_test.rb +++ b/tests/datamap_test.rb @@ -9,6 +9,11 @@ module DataMapTestAliases FR = SignalWire::Swaig::FunctionResult DM = SignalWire::DataMap + + # The ten properties schema.json $defs/Webhook permits, under + # +unevaluatedProperties: {"not": {}}+ — everything else is forbidden. + WEBHOOK_SCHEMA_KEYS = %w[error_keys expressions foreach headers input_args_as_params + method output params require_args url].freeze end class DataMapTest < Minitest::Test @@ -398,19 +403,50 @@ def test_create_simple_api_tool assert_equal 'Weather: ${response.temp}', wh['output']['response'] end - def test_create_simple_api_tool_with_body - dm = DM.create_simple_api_tool( - name: 'post_data', - url: 'https://example.com/api', + # +create_simple_api_tool+ has no +body:+ keyword. + # + # +body+ is not a valid webhook key: porting-sdk/schema.json $defs/Webhook + # declares exactly ten properties (error_keys, expressions, foreach, headers, + # input_args_as_params, method, output, params, require_args, url) under + # +unevaluatedProperties: {"not": {}}+, and neither engine reader + # (mod_openai/actions.c parse_webhook, mod_openai/bedrock.c + # bedrock_parse_webhook) looks up "body". Accepting the argument and + # discarding it into an unread key silently lost the caller's data. + def test_create_simple_api_tool_rejects_body + assert_raises(ArgumentError) do + DM.create_simple_api_tool( + name: 'post_data', + url: 'https://example.com/api', + response_template: 'Done: ${response.id}', + method: 'POST', + body: { 'data' => '${args.payload}' } + ) + end + end + + # The webhook a POST-shaped +create_simple_api_tool+ emits. + def post_tool_webhook + DM.create_simple_api_tool( + name: 'post_data', url: 'https://example.com/api', response_template: 'Done: ${response.id}', - method: 'POST', - body: { 'data' => '${args.payload}' } - ) + parameters: { 'payload' => { 'type' => 'string', 'description' => 'Payload' } }, + method: 'POST', headers: { 'Authorization' => 'Bearer TOKEN' }, error_keys: %w[error] + ).to_swaig_function['data_map']['webhooks'].first + end - wh = dm.to_swaig_function['data_map']['webhooks'].first + # The EMITTED webhook payload carries no +body+ key. + def test_create_simple_api_tool_emits_no_body_key + wh = post_tool_webhook assert_equal 'POST', wh['method'] - assert_equal({ 'data' => '${args.payload}' }, wh['body']) + refute_includes wh.keys, 'body', "webhook carries a body key: #{wh.inspect}" + end + + # Every emitted webhook key is one schema.json $defs/Webhook permits. + def test_create_simple_api_tool_emits_only_schema_keys + extra = post_tool_webhook.keys - WEBHOOK_SCHEMA_KEYS + + assert_empty extra, "webhook has keys outside schema.json $defs/Webhook: #{extra.sort.inspect}" end def test_create_simple_api_tool_minimal From c42bb3d02d613771473fa950eedd50d57eca8028 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 21:18:03 -0400 Subject: [PATCH 42/90] =?UTF-8?q?feat(datamap)!:=20remove=20DataMap#body?= =?UTF-8?q?=20=E2=80=94=20the=20builder=20wrote=20a=20key=20nothing=20read?= =?UTF-8?q?s?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit BREAKING. Ripples signalwire-python 71eed0c into ruby. Owner-ruled 2026-07-29, extending the earlier ruling ("if the server doesn't read them, remove them") from create_simple_api_tool's PARAMETER (ruby 91c5ba3) to the public BUILDER METHOD. 91c5ba3 deliberately held this back as belonging to its own decision; this is that decision, taken as a hard delete rather than a deprecation shim. THE SAME THREE SOURCES CONDEMN THE BUILDER AND THE PARAMETER IDENTICALLY: * THE SPEC FORBIDS IT. porting-sdk/schema.json $defs/Webhook declares exactly ten properties — error_keys, expressions, foreach, headers, input_args_as_params, method, output, params, require_args, url — under `unevaluatedProperties: {"not": {}}`. `body` is not among them, so emitting it is a SCHEMA VIOLATION. * THE ENGINE NEVER READS IT. mod_openai/actions.c:735-739 and bedrock.c:4920-4926 read url, method, form_param, `params` and `headers` and nothing else; `grep -n '"body"'` across BOTH files returns ZERO matches. * SO ITS ONLY POSSIBLE EFFECT was producing an invalid document while silently discarding the caller's payload. A caller reaching for the obviously-named `body` for POST data got data loss with no error. `params` is the correct method: it writes the `params` key, which IS in the contract and IS read. REPRODUCED AT THE WIRE BEFORE FIXING, not inferred: BEFORE body() webhook KEYS ["body", "method", "output", "url"] params() webhook KEYS ["method", "output", "params", "url"] AFTER DataMap#body -> NoMethodError: undefined method `body' params() webhook KEYS ["method", "output", "params", "url"] Byte-for-byte the before/after keys the reference recorded. TDD-bidirectional, RED landing ON the assertion: RED DataMapBodyBuilderRemovedTest#test_body_method_is_gone [datamap_test.rb:548] Expected # to not respond to body. test_params_still_writes_the_contract_key — PASS throughout GREEN both PASS The positive control was green the whole time, so the red was the new rule and not a broken fixture. CALL SITES — FOUR in tests, ONE doc section. My own 91c5ba3 message estimated "2 tests and 2 doc sections"; that estimate was WRONG in both directions and re-measuring found: * test_webhook_body_and_params ASSERTED THE DEFECT — it read `wh['body']` back and checked its contents, pinning a schema-forbidden key as correct. REPLACED (not edited) by test_webhook_params, which asserts the contract key and `body`'s absence. * test_body_without_webhook_raises — deleted with the method it guarded. * search_tool_swaig (the to_swaig_function serialization fixture) — migrated to `.params`; it never asserted the key, so the migration is behavior-preserving. * fluent_calls — the [:body, {}] entry in the fluent-chaining table. This one would NOT have surfaced from a source-only grep, and Ruby resolves it at call time, so only a whole-repo sweep finds it. * docs/api_reference.md — the `body(data) -> DataMap` section deleted. The second doc site 91c5ba3 counted was already migrated to `.params` by that commit. `examples/` has ZERO DataMap `body` call sites (the reference had 7; ruby's examples never used the builder). POM's unrelated `body`/`add_body`/`append_body` concept is untouched. ARTIFACTS REGENERATED AND COMMITTED — BOTH, not just signatures: port_signatures.json -14 lines, exactly the DataMap.body node, nothing else port_surface.json -1 line, the "body" member (+ provenance) port_surface.json was the trap: the first post-removal run-ci went RED on SURFACE-FRESH because only signatures had been regenerated. SURFACE-FRESH snapshots `git show HEAD:port_surface.json` and diffs a fresh regen against it, so it catches an uncommitted regen; port_signatures.json has NO equivalent guard, which is why its committed blob was verified by hand. ruby has no port_surface_.json or port_additions_actual.json. port_signatures.baseline.json DELIBERATELY UNTOUCHED — it is the authoritative last- RELEASE snapshot SEMVER-DIFF diffs against (semver_diff.py:87,125-131). Editing it would erase the breaking-change signal this commit is supposed to produce. SEMVER-DIFF REPORTS THIS AS BREAKING — correct, and held report-only in-wave by the D5 hold (GATE_ENFORCEMENT_PLAN.md D5a/D5b, "version-line decision deferred to real release"). Not suppressed, not allow-listed, no version bump, no baseline edit. Verification: BEFORE 2738 runs, 7696 assertions, 0 failures, 0 errors, 0 skips (baseline) AFTER 2739 runs, 7699 assertions, 0 failures, 0 errors, 0 skips Delta +1 run = -1 (test_body_without_webhook_raises) -1 (test_webhook_body_and_params) +1 (test_webhook_params) +2 (the removal test class). No other movement. run-lint.sh -> 1376 files inspected, no offenses detected run-format.sh -> 1376 files inspected, no offenses detected run-ci.sh -> ==> CI PASS The pre-work run-ci baseline was ALREADY RED — `==> CI FAIL (gates: SURFACE)`, on DRIFT + SURFACE-DIFF, with the sole diagnostic being "+ signalwire.core.data_map.DataMap.body ... not in Python reference". That red was this task, caused by porting-sdk oracle 6bf50c4 regenerating for the reference removal. This commit closes it. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- docs/api_reference.md | 26 ------------ lib/signalwire/datamap/data_map.rb | 19 +++------ port_signatures.json | 14 ------- port_surface.json | 3 +- tests/datamap_test.rb | 63 +++++++++++++++++++++++------- 5 files changed, 55 insertions(+), 70 deletions(-) diff --git a/docs/api_reference.md b/docs/api_reference.md index 98207758..3a12126d 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -2393,32 +2393,6 @@ data_map.webhook( ) ``` -##### `body(data) -> DataMap` -Set the JSON body for POST/PUT requests. - -**Parameters:** -- `data` (Hash): JSON body data (supports `${variable}` substitution) - -**Usage:** -```ruby -# Static body with parameter substitution -data_map.body({ - 'query' => '${args.search_term}', - 'limit' => 5, - 'filters' => { - 'category' => '${args.category}', - 'active' => true - } -}) - -# Body with call-related data (NOT sensitive info) -data_map.body({ - 'customer_id' => '${global_data.customer_id}', - 'request_id' => '${meta_data.call_id}', - 'search' => '${args.query}' -}) -``` - ##### `params(data) -> DataMap` Set URL query parameters. diff --git a/lib/signalwire/datamap/data_map.rb b/lib/signalwire/datamap/data_map.rb index 4fbd1ee2..d61da11b 100644 --- a/lib/signalwire/datamap/data_map.rb +++ b/lib/signalwire/datamap/data_map.rb @@ -147,22 +147,13 @@ def webhook_expressions(expressions) self end - # Set the request body for the most-recently-added webhook (POST / PUT). - def body(data) - raise ArgumentError, 'Must add webhook before setting body' if @webhooks.empty? - - @webhooks.last['body'] = data - self - end - # Set request params for the most-recently-added webhook. # - # This is NOT an alias for +body+: the two write different webhook keys - # (+params+ vs +body+), and only +params+ is part of the webhook contract — - # schema.json +$defs/Webhook+ lists +params+ among its ten permitted - # properties and forbids everything else, and the engine's webhook readers - # look up +params+ and never +body+. Use this method for POST/PUT request - # data. + # This is the method for POST/PUT request data. It writes the +params+ + # webhook key, which schema.json +$defs/Webhook+ lists among its ten + # permitted properties and which the engine's webhook readers look up. The + # former +body+ builder wrote a +body+ key that the schema forbids and no + # engine reader consumes — it was removed 2026-07-29; use this instead. def params(data) raise ArgumentError, 'Must add webhook before setting params' if @webhooks.empty? diff --git a/port_signatures.json b/port_signatures.json index 8bfa1432..0b881093 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -3875,20 +3875,6 @@ ], "returns": "void" }, - "body": { - "params": [ - { - "name": "self", - "kind": "self" - }, - { - "name": "data", - "type": "dict", - "required": true - } - ], - "returns": "any" - }, "description": { "params": [ { diff --git a/port_surface.json b/port_surface.json index 62d07035..9ea6f8dd 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 3245faec9432e7d397c8d63000254a6ff7e9d0c8", + "generated_from": "signalwire-ruby @ 91c5ba3a013803def5ddf50e2abc7170cd37fcce", "modules": { "signalwire": { "classes": {}, @@ -334,7 +334,6 @@ "classes": { "DataMap": [ "__init__", - "body", "description", "error_keys", "expression", diff --git a/tests/datamap_test.rb b/tests/datamap_test.rb index 242ee6ea..cfb85202 100644 --- a/tests/datamap_test.rb +++ b/tests/datamap_test.rb @@ -130,31 +130,28 @@ def test_webhook_configuration end # ---------------------------------------------------------------- - # Webhook body and params + # Webhook params # ---------------------------------------------------------------- - def test_webhook_body_and_params + # Was +test_webhook_body_and_params+, which called +body+ AND +params+ and then + # asserted +wh['body']+ — pinning a schema-forbidden key as correct. It now + # asserts only the contract key and that +body+ is absent. + def test_webhook_params dm = DM.new('func') .webhook('POST', 'https://example.com') - .body({ 'query' => '${args.q}' }) - .params({ 'limit' => 10 }) + .params({ 'query' => '${args.q}', 'limit' => 10 }) .output(FR.new('ok')) wh = dm.to_swaig_function['data_map']['webhooks'].first - assert_equal({ 'query' => '${args.q}' }, wh['body']) - assert_equal({ 'limit' => 10 }, wh['params']) + assert_equal({ 'query' => '${args.q}', 'limit' => 10 }, wh['params']) + refute wh.key?('body') end # ---------------------------------------------------------------- - # body/params/output/foreach without webhook raises + # params/output/foreach without webhook raises # ---------------------------------------------------------------- - def test_body_without_webhook_raises - dm = DM.new('func') - assert_raises(ArgumentError) { dm.body({}) } - end - def test_params_without_webhook_raises dm = DM.new('func') assert_raises(ArgumentError) { dm.params({}) } @@ -245,7 +242,7 @@ def search_tool_swaig .parameter('limit', 'number', 'Max results') .webhook('POST', 'https://api.docs.com/search', headers: { 'Authorization' => 'Bearer TOKEN' }) - .body({ 'query' => '${query}', 'limit' => 3 }) + .params({ 'query' => '${query}', 'limit' => 3 }) .output(FR.new('Found: ${response.results[0].title}')) .to_swaig_function end @@ -511,7 +508,7 @@ def fluent_calls [ [:purpose, 'test'], [:description, 'test'], [:parameter, 'x', 'string', 'desc'], [:expression, '${x}', 'pat', FR.new('y')], [:webhook, 'GET', 'https://example.com'], - [:body, {}], [:params, {}], + [:params, {}], [:foreach, { 'input_key' => 'a', 'output_key' => 'b', 'append' => 'c' }], [:output, FR.new('ok')], [:fallback_output, FR.new('fail')], [:error_keys, %w[e]], [:global_error_keys, %w[e]], [:webhook_expressions, []] @@ -526,3 +523,41 @@ def test_fluent_chaining_returns_self end end end + +# +DataMap#body+ is GONE — the key it wrote is invalid, not merely ignored. +# +# Owner-ruled 2026-07-29, extending the earlier ruling ("if the server doesn't +# read them, remove them") from the +create_simple_api_tool+ PARAMETER to the +# public BUILDER METHOD. The same three sources condemn both: +# +# * +porting-sdk/schema.json+ +$defs/Webhook+ declares exactly ten properties +# under +unevaluatedProperties: {"not": {}}+ — +body+ is not among them, so +# emitting it is a SCHEMA VIOLATION. +# * +mod_openai/actions.c:735-739+ and +bedrock.c:4920-4926+ read url, method, +# form_param, +params+ and +headers+ and nothing else; +grep -n '"body"'+ +# across both returns ZERO matches. +# * So the method's only possible effect was producing an invalid document while +# silently discarding the caller's payload. +# +# +params+ is the correct method for POST/PUT request data — it writes the +# +params+ key, which IS in the contract and IS read. +class DataMapBodyBuilderRemovedTest < Minitest::Test + include DataMapTestAliases + + def test_body_method_is_gone + refute_respond_to DM.new('t'), :body, + 'DataMap#body must be removed — it writes a schema-forbidden key ' \ + 'that no engine reader consumes; use params instead' + end + + # The replacement must keep working — this is the positive control. + def test_params_still_writes_the_contract_key + wh = DM.new('t') + .webhook('POST', 'https://x.test') + .params({ 'q' => '${query}' }) + .to_swaig_function['data_map']['webhooks'].first + + assert_equal({ 'q' => '${query}' }, wh['params']) + refute wh.key?('body') + end +end From 3a86acc921b044cbc5bd59c5472dd5cfaf72c018 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 22:00:19 -0400 Subject: [PATCH 43/90] =?UTF-8?q?fix(swml):=20`play`=20has=20no=20`text`?= =?UTF-8?q?=20key=20=E2=80=94=20emit=20`say:`=20URL=20through=20the=20vali?= =?UTF-8?q?dator?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `render_function_response_swml` emitted `{"play": {"text": }}`. The SWML `play` verb has no `text` key: its config is PlayWithURL/PlayWithURLS and spoken text goes through the `say:` URL scheme. The document we produced was rejected by the very schema this SDK ships. Two defects, one call site (lib/signalwire/swml/swml_renderer.rb:93): 1. WRONG KEY. Reference emits `service.add_verb("play", {"url": f"say:{text}"})` (signalwire/core/swml_renderer.py:177). 2. WRONG ROUTING. We called `service.document.add_verb` — the RAW document entry point — which bypasses the schema validator entirely. That is what let the invalid key ship silently. The action loop had the same bypass. Before: EMITTED: [{"play"=>{"text"=>"All done"}}] validating add_verb play{text} => RAISES SchemaValidationError ("value at /sections/main/0/play matches `not` schema") validating add_verb play{url:say:} => true After: EMITTED: [{"play"=>{"url"=>"say:All done"}}] Both verbs now route through the validating `Service#add_verb`, matching the reference, so a config the schema rejects fails loudly instead of shipping. Two existing tests ASSERTED the defect (`{'play' => {'text' => ...}}`); they are replaced, not edited to pass. Routing through the validator also exposed a schema-invalid test fixture: `hangup{reason: 'done'}` — `reason` is a closed enum of hangup|busy|decline. Fixture corrected to `busy`; the raw path had been hiding that too. Tests: 2739 -> 2741 runs (+2: the say:-URL shape, and a validator-survival probe; plus one asserting an invalid action config now raises). 0 failures. `SwmlRendererTest` was split into a second class for the function-response tests to stay under Metrics/ClassLength rather than raising the threshold. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/swml/swml_renderer.rb | 12 ++++-- tests/swml_renderer_test.rb | 57 +++++++++++++++++++++++----- 2 files changed, 57 insertions(+), 12 deletions(-) diff --git a/lib/signalwire/swml/swml_renderer.rb b/lib/signalwire/swml/swml_renderer.rb index 6b084d7c..6a834776 100644 --- a/lib/signalwire/swml/swml_renderer.rb +++ b/lib/signalwire/swml/swml_renderer.rb @@ -83,14 +83,20 @@ def self.render_in(builder, format) # Generate a SWML document for a function response — a +play+ of the # response text followed by any provided actions. # + # The SWML +play+ verb has no +text+ key: its config is PlayWithURL / + # PlayWithURLS, and spoken text goes through the +say:+ URL scheme. Verbs + # are added through the validating Service#add_verb (not the raw document + # entry point), so a config the schema rejects fails loudly here rather + # than shipping an invalid document. + # # @param response_text [String] text response to include in the document # @param service [SignalWire::SWML::Service] service to build with # @param actions [Array, nil] optional list of actions to perform # @param format [String] output format ("json" or "yaml") # @return [String] SWML document as a string def self.render_function_response_swml(response_text:, service:, actions: nil, format: 'json') - service.document.reset - service.document.add_verb('play', { 'text' => response_text }) if response_text && !response_text.empty? + service.reset_document + service.add_verb('play', { 'url' => "say:#{response_text}" }) if response_text && !response_text.empty? (actions || []).each { |action| add_response_action(service, action) } format.to_s.downcase == 'yaml' ? render_yaml(service.document.to_h) : service.render @@ -99,7 +105,7 @@ def self.render_function_response_swml(response_text:, service:, actions: nil, f # Add the first recognised action verb from an action hash to the document. def self.add_response_action(service, action) verb = RESPONSE_ACTION_VERBS.find { |v| action.key?(v) } - service.document.add_verb(verb, action[verb]) if verb + service.add_verb(verb, action[verb]) if verb end # Build the SWAIG function list, prepending startup/hangup hooks and diff --git a/tests/swml_renderer_test.rb b/tests/swml_renderer_test.rb index 6312721d..dc7a71a4 100644 --- a/tests/swml_renderer_test.rb +++ b/tests/swml_renderer_test.rb @@ -6,9 +6,8 @@ require_relative '../lib/signalwire' -# Tests for SwmlRenderer.render_swml / render_function_response_swml — render a -# full SWML doc and assert its exact structure and wire keys. -class SwmlRendererTest < Minitest::Test +# Shared fixtures for the SwmlRenderer test classes. +module SwmlRendererFixtures def new_service(name = 'renderer-test') SignalWire::SWML::Service.new(name: name) end @@ -16,6 +15,12 @@ def new_service(name = 'renderer-test') def render_and_parse(**) JSON.parse(SignalWire::SWML::SwmlRenderer.render_swml(**)) end +end + +# Tests for SwmlRenderer.render_swml — render a full SWML doc and assert its +# exact structure and wire keys. +class SwmlRendererTest < Minitest::Test + include SwmlRendererFixtures def test_render_swml_basic_text_prompt doc = render_and_parse(prompt: 'you are helpful', service: new_service) @@ -103,30 +108,64 @@ def test_render_swml_yaml_format assert_equal 'ai', parsed['sections']['main'].first.keys.first end +end - # ---- render_function_response_swml ---- +# Tests for SwmlRenderer.render_function_response_swml — the function-response +# document (a +play+ of the response text plus any provided actions). +class SwmlRendererFunctionResponseTest < Minitest::Test + include SwmlRendererFixtures - def test_function_response_plays_text + # The SWML +play+ verb has NO +text+ key — its config is PlayWithURL/ + # PlayWithURLS and spoken text goes through the +say:+ URL scheme. Emitting + # {"text" => ...} produced a document the SWML schema rejects. + def test_function_response_plays_text_via_say_url out = SignalWire::SWML::SwmlRenderer.render_function_response_swml( response_text: 'All done', service: new_service ) main = JSON.parse(out)['sections']['main'] - assert_equal({ 'play' => { 'text' => 'All done' } }, main.first) + assert_equal({ 'play' => { 'url' => 'say:All done' } }, main.first) + end + + # The emitted play config must survive the schema validator — i.e. the + # renderer routes through the validating Service#add_verb, not the raw + # document entry point that bypasses it. + def test_function_response_play_config_passes_schema_validation + service = new_service + SignalWire::SWML::SwmlRenderer.render_function_response_swml( + response_text: 'All done', service: service + ) + + probe = new_service + probe.reset_document + + assert probe.add_verb('play', service.document.to_h['sections']['main'].first['play']) end def test_function_response_appends_actions out = SignalWire::SWML::SwmlRenderer.render_function_response_swml( response_text: 'bye', service: new_service, - actions: [{ 'hangup' => { 'reason' => 'done' } }, { 'transfer' => { 'dest' => 'sip:x@y' } }] + actions: [{ 'hangup' => { 'reason' => 'busy' } }, { 'transfer' => { 'dest' => 'sip:x@y' } }] ) main = JSON.parse(out)['sections']['main'] - assert_equal({ 'play' => { 'text' => 'bye' } }, main[0]) - assert_equal({ 'hangup' => { 'reason' => 'done' } }, main[1]) + assert_equal({ 'play' => { 'url' => 'say:bye' } }, main[0]) + assert_equal({ 'hangup' => { 'reason' => 'busy' } }, main[1]) assert_equal({ 'transfer' => { 'dest' => 'sip:x@y' } }, main[2]) end + # Actions route through the validating Service#add_verb too (matching the + # reference), so a schema-invalid action config raises instead of silently + # landing in the document. + def test_function_response_rejects_schema_invalid_action + assert_raises(SignalWire::Utils::SchemaValidationError) do + SignalWire::SWML::SwmlRenderer.render_function_response_swml( + response_text: 'bye', service: new_service, + actions: [{ 'hangup' => { 'reason' => 'not-a-valid-reason' } }] + ) + end + end + def test_function_response_empty_text_skips_play out = SignalWire::SWML::SwmlRenderer.render_function_response_swml( response_text: '', service: new_service, From 3809cf51a86ad9f824fa083fa20f86dc9a481c5f Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:03:50 -0400 Subject: [PATCH 44/90] =?UTF-8?q?fix(swml):=20honor=20`x-sdk-widen`=20?= =?UTF-8?q?=E2=80=94=20the=20validator=20was=20stricter=20than=20the=20pla?= =?UTF-8?q?tform?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `x-sdk-widen: true` declares that a property's enum/const union is only a HINT and the platform accepts any value of the base scalar type (porting-sdk REST_GENERATOR_RULES.md §5: "a schema enum/const is only a hint, so widen to the base scalar — e.g. `hangup.reason` const-union → `str`; the platform accepts any string"). NOTHING in this port read that marker: `grep -rn x-sdk-widen --include='*.rb'` returned zero consumers, while `$defs/Hangup.reason` carries it. So the full validator ran the raw const-union and REJECTED `hangup{reason: 'done'}` — a value the platform accepts. An SDK that refuses documents the server would have taken is a defect in the opposite direction from the usual one, and it is the kind that only surfaces when something finally routes through the validator. The widening is applied when the json_schemer validator is built, not to `@schema` itself, so code-gen callers still see the enum hint. Only the value-set keywords are stripped (anyOf/oneOf/enum/const/x-sdk-enum-literal); the base scalar type is recovered from the union's branches and retained, so `reason: 123` still fails and the verb stays closed to unknown keys. RED/GREEN: `hangup{reason:'done'}` raised SchemaValidationError before, passes after; `hangup{reason:123}` and `hangup{bogus_key:'x'}` still raise; `play{urls:['a.mp3']}` (no widen marker) still raises. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/utils/schema_utils.rb | 49 +++++++++++++++++++++++++++- tests/swml_test.rb | 47 ++++++++++++++++++++++++++ 2 files changed, 95 insertions(+), 1 deletion(-) diff --git a/lib/signalwire/utils/schema_utils.rb b/lib/signalwire/utils/schema_utils.rb index be1e4766..1aff8eaf 100644 --- a/lib/signalwire/utils/schema_utils.rb +++ b/lib/signalwire/utils/schema_utils.rb @@ -55,6 +55,11 @@ class SchemaUtils 'boolean' => 'bool', 'object' => 'Dict[str, Any]' }.freeze + # Keywords stripped from an `x-sdk-widen: true` property before the full + # validator is built — the ones that pin it to a fixed value set. See + # {#apply_sdk_widen}. + WIDEN_STRIPPED_KEYS = %w[anyOf oneOf enum const x-sdk-enum-literal].freeze + # @return [Hash{String=>Object}] parsed JSON Schema document attr_reader :schema @@ -351,12 +356,54 @@ def init_full_validator require 'json_schemer' @full_validator = JSONSchemer.schema( - @schema, meta_schema: 'https://json-schema.org/draft/2020-12/schema' + apply_sdk_widen(@schema), meta_schema: 'https://json-schema.org/draft/2020-12/schema' ) rescue LoadError, StandardError @full_validator = nil end + # `x-sdk-widen: true` declares that a property's `enum`/`const` union is + # only a HINT and the platform accepts any value of the base scalar type + # (porting-sdk REST_GENERATOR_RULES.md §5: "a schema enum/const is only a + # hint, so widen to the base scalar — e.g. `hangup.reason` const-union → + # `str`; the platform accepts any string"). Validating against the raw + # const-union would make this SDK reject documents the platform accepts, + # so drop the constraint on marked properties before building the + # validator. Returns a widened deep copy; @schema itself is untouched, so + # code-gen callers still see the enum hint. + # + # @return [Hash, Array, Object] + def apply_sdk_widen(node) + return node.map { |item| apply_sdk_widen(item) } if node.is_a?(Array) + return node unless node.is_a?(Hash) + return widened_scalar(node) if node['x-sdk-widen'] + + node.transform_values { |value| apply_sdk_widen(value) } + end + + # @api private — a widened copy of one marked property: the constraint + # keywords that pin it to a fixed value set are removed, leaving the base + # scalar type (recovered from the const-union's members when the property + # states no `type` of its own). + # + # @return [Hash] + def widened_scalar(node) + widened = node.except(*WIDEN_STRIPPED_KEYS) + widened['type'] ||= widen_base_type(node) + widened.compact + end + + # @api private — the base scalar type a const-union widens to: whatever + # `type` its branches agree on, or nil when they do not agree (leaving the + # property unconstrained rather than guessing). + # + # @return [String, nil] + def widen_base_type(node) + branches = node['anyOf'] || node['oneOf'] || [] + types = branches.grep(Hash).filter_map { |b| b['type'] }.uniq + types.length == 1 ? types.first : nil + end + # Full JSON Schema validation via json_schemer. Mirrors Python's # _validate_verb_full: wrap the verb in a minimal SWML document # ({version, sections:{main:[{verb: config}]}}) and validate the whole diff --git a/tests/swml_test.rb b/tests/swml_test.rb index ebbc2179..fc180a76 100644 --- a/tests/swml_test.rb +++ b/tests/swml_test.rb @@ -625,3 +625,50 @@ def test_secure_compare_works refute Rack::Utils.secure_compare('short', 'longer_string') end end + +# `x-sdk-widen: true` declares that a property's enum/const union is only a HINT +# and the platform accepts any value of the base scalar type. Validating against +# the raw union would make the SDK reject documents the platform accepts. +class SchemaWidenTest < Minitest::Test + def setup + @svc = SignalWire::SWML::Service.new(name: 'widen') + end + + # hangup.reason carries the marker: any string must pass, in-union or not. + def test_widened_enum_accepts_out_of_union_string + assert @svc.add_verb('hangup', { 'reason' => 'done' }) + assert @svc.add_verb('hangup', { 'reason' => 'busy' }) + end + + # Widening drops the value set, NOT the base type -- a non-string still fails. + def test_widened_enum_still_enforces_base_type + assert_raises(SignalWire::Utils::SchemaValidationError) do + @svc.add_verb('hangup', { 'reason' => 123 }) + end + end + + # Widening one property must not open the verb to unknown keys. + def test_widened_verb_still_rejects_unknown_keys + assert_raises(SignalWire::Utils::SchemaValidationError) do + @svc.add_verb('hangup', { 'bogus_key' => 'x' }) + end + end + + # A property WITHOUT the marker keeps its constraint: play.urls entries must + # be real play URLs, so a bare filename is still rejected. + def test_unwidened_property_keeps_its_constraint + assert_raises(SignalWire::Utils::SchemaValidationError) do + @svc.add_verb('play', { 'urls' => ['a.mp3'] }) + end + end + + # The marker is a VALIDATION-time widening only; the raw schema keeps the + # union so code-gen still sees the hint. + def test_raw_schema_keeps_the_enum_hint_for_codegen + reason = SignalWire::Utils::SchemaUtils.new.schema + .dig('$defs', 'Hangup', 'properties', 'hangup', 'properties', 'reason') + + assert reason['x-sdk-widen'], 'expected the widen marker on hangup.reason' + assert_equal(%w[hangup busy decline], reason['anyOf'].map { |b| b['const'] }) + end +end From 54b1494058b1c0c38aa6d3e410330a2bb1f66cc1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:03:51 -0400 Subject: [PATCH 45/90] fix(swml): vendored schema was missing `AIObject.multilingual` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `$defs/AIObject` is CLOSED (`unevaluatedProperties: {"not": {}}`), so a property the vendored copy lacks is not merely undocumented — it is REJECTED. The reference schema declares ten AIObject properties; this port's copy had nine, missing `multilingual`. The port emits `ai.multilingual` (agent_base.rb:2571), so every multilingual agent produced a document its own validator would refuse. That contradiction was invisible because the emission path bypassed the validator entirely; it only surfaced when the render was routed through it. The 83-line property block is copied verbatim from the reference; after this `$defs/AIObject` compares byte-equal to the reference's. Verified: python3 -c "... r['\$defs']['AIObject'] == b['\$defs']['AIObject']" -> True Every other difference between the two schema copies is either this port's own `x-sdk-*` markup or the intentional RingbackConfig refactor, and is left alone. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/swml/schema.json | 83 +++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/lib/signalwire/swml/schema.json b/lib/signalwire/swml/schema.json index 8785f89b..4ccdd348 100644 --- a/lib/signalwire/swml/schema.json +++ b/lib/signalwire/swml/schema.json @@ -2436,6 +2436,89 @@ }, "description": "An array of JSON objects defining supported languages in the conversation." }, + "multilingual": { + "type": "object", + "title": "Multilingual", + "description": "ASR-driven multilingual mode. The recognizer runs in code-switching mode and reports the language of each utterance; the agent answers in that language and swaps to the matching voice. Mutually exclusive with `languages` - when both are present the server uses `multilingual`.", + "properties": { + "languages": { + "type": "array", + "description": "Voice entries keyed by BCP-47 base code. Needs a `default` (or first) entry with a voice.", + "items": { + "type": "object", + "properties": { + "language": { + "type": "string" + }, + "voice": { + "type": "string" + }, + "engine": { + "type": "string" + }, + "model": { + "type": "string" + }, + "params": { + "type": "object" + } + } + } + }, + "engine": { + "type": "string", + "description": "ASR engine. Runs in `multi`. Default deepgram." + }, + "model": { + "type": "string", + "description": "ASR model. Default nova-3." + }, + "provider": { + "type": "string", + "description": "ASR provider (deepgram / gladia / grok)." + }, + "start_language": { + "type": "string", + "description": "BCP-47 base code the agent opens in. Default `en`." + }, + "allowed": { + "type": "array", + "items": { + "type": "string" + }, + "description": "BCP-47 base codes the agent may switch into." + }, + "min_switch_words": { + "type": "integer", + "description": "Minimum words in an utterance before a detected-language switch is trusted. Default 2." + }, + "fillers": { + "description": "Global speech fillers. Flat array = auto-translate; object = language-keyed map.", + "anyOf": [ + { + "type": "array" + }, + { + "type": "object" + } + ] + }, + "function_fillers": { + "description": "Global function-call fillers. Same shape as `fillers`.", + "anyOf": [ + { + "type": "array" + }, + { + "type": "object" + } + ] + } + }, + "required": [ + "languages" + ] + }, "params": { "$ref": "#/$defs/AIParams", "description": "A JSON object containing parameters as key-value pairs." From db8c136940b9d8f92a0f09b9120c7ae95870064d Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:03:57 -0400 Subject: [PATCH 46/90] fix(swml): route every verb emission through the validating add_verb MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ten sites wrote verbs straight into the Document, skipping the schema check that `Service#add_verb` performs. That bypass is why schema-invalid configs shipped silently — a prior fix moved swml_renderer.rb:99/:108 onto the validating path with a comment naming this exact bug, and left the rest behind. Sites moved onto `Service#add_verb`: swml_renderer.rb:66 record_call (left behind by the earlier fix) swml_builder.rb:45 answer swml_builder.rb:56 hangup swml_builder.rb:104 play swml_builder.rb:163 sleep (method_missing) swml_builder.rb:165 any auto-vivified verb (method_missing) swml_builder.rb:185 the private add_verb bridge (feeds :82 ai) service.rb:232/:234 execute_verb examples/swmlservice_ai_sidecar.rb:40 Every builder verb now funnels through the one private bridge, so there is a single place to audit rather than six. `Service#execute_verb` was RAW despite living on the Service, and it is the target of `method_missing` verb auto-vivification — so `service.play(...)` read like a validated call and was not. A caller cannot tell from the receiver which they got; it now validates. A THIRD PATH the sweep did not list: `agent_base.rb#build_main_section` hand-assembles `sections.main` touching neither Document nor Service, so the caller-supplied configs of add_pre_answer_verb / add_post_answer_verb / add_post_ai_verb reached the wire completely unchecked. The reference routes all of these through the validating `add_verb` (core/agent_base.py:1194-1216, 1367-1418). Each assembled entry is now validated in place, preserving the document's ordering. TWO LIVE WIRE DEFECTS the bypass had been hiding — both misplaced keys at the `ai` verb, whose schema is CLOSED over nine properties: * `contexts` was emitted at `ai.contexts`; it belongs at `ai.prompt.contexts` (reference core/swml_handler.py:191). This port's OWN AiVerbHandler (swml_handler.rb:160) already built it correctly — the code contradicted itself and nothing caught it. * `mcp_servers` was emitted at `ai.mcp_servers`; it belongs inside the SWAIG object (reference core/agent_base.py:1153). Both made every document carrying them invalid. FIXTURES THAT WENT RED, and the invalid values they carried: swml_builder_test.rb:66 play urls ['a.mp3','b.mp3'] — bare filenames; the schema requires play_url (http(s):/say:/ring:/silence:) swml_builder_test.rb:48 ai temperature: 0.4 at the ai top level — belongs under `params`; the reference REJECTS it identically swml_renderer_test.rb params {temperature} merged at the ai top level — same agent_test.rb, verb_test.rb, render_test.rb play url 'ring.mp3'/'welcome.mp3' — bare filenames, 8 occurrences swml_test.rb:357 play url 'a.mp3' — bare filename agent_test.rb, render_test.rb asserted ai.contexts (the misplaced key) mcp_test.rb:247 asserted ai.mcp_servers (the misplaced key) Each was verified against the REFERENCE validator, which rejects the identical configs — these are genuinely invalid wire shapes, not this port being strict. Also found: examples/basic_swml_service.rb emitted a `connect` with NO destination (no to/serial/parallel/serial_parallel) — a document that can never dial. Given a `to`. Suite: 2741 runs / 0 failures before, 2749 / 0 after (+8 = the new tests). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- examples/basic_swml_service.rb | 4 +++ examples/swmlservice_ai_sidecar.rb | 10 +++--- lib/signalwire/agent/agent_base.rb | 48 ++++++++++++++++++++++++---- lib/signalwire/swml/service.rb | 10 ++++-- lib/signalwire/swml/swml_builder.rb | 23 +++++++------ lib/signalwire/swml/swml_renderer.rb | 6 +++- tests/agent_test.rb | 17 ++++++---- tests/mcp_test.rb | 7 ++-- tests/render_test.rb | 9 ++++-- tests/swml_builder_test.rb | 16 +++++++--- tests/swml_renderer_test.rb | 13 ++++++-- tests/swml_test.rb | 4 +-- tests/verb_test.rb | 6 ++-- 13 files changed, 125 insertions(+), 48 deletions(-) diff --git a/examples/basic_swml_service.rb b/examples/basic_swml_service.rb index e7d37ca1..169b8061 100644 --- a/examples/basic_swml_service.rb +++ b/examples/basic_swml_service.rb @@ -68,7 +68,11 @@ transfer.answer transfer.play(url: "say:Thank you for calling. We'll connect you with the next available agent.") +# `connect` needs a destination -- one of `to` / `serial` / `parallel` / +# `serial_parallel`. Without one the document is schema-invalid and the call +# never dials anywhere. transfer.connect( + to: '+15559876543', from: '+15551234567', timeout: 30, answer_on_bridge: true diff --git a/examples/swmlservice_ai_sidecar.rb b/examples/swmlservice_ai_sidecar.rb index 3f98e027..ce548599 100644 --- a/examples/swmlservice_ai_sidecar.rb +++ b/examples/swmlservice_ai_sidecar.rb @@ -33,11 +33,13 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', port: port ) - # 1. Emit any SWML -- including ai_sidecar. Document#add_verb_to_section - # accepts arbitrary verb dicts, so new platform verbs work without - # an SDK release. + # 1. Emit any SWML -- including ai_sidecar. Service#add_verb_to_section + # validates the config against the SWML schema, so a typo'd key or an + # out-of-enum value fails here instead of shipping an invalid document. + # (Document#add_verb_to_section is the raw path and skips that check -- + # do not reach for it.) answer - document.add_verb_to_section( + add_verb_to_section( 'main', 'ai_sidecar', { diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index a3ca901c..f9982d35 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -2411,6 +2411,13 @@ def _render_swml_internal(call_id: nil) end # Assemble the ordered SWML "main" section entries. + # + # The reference routes every one of these through the validating + # ``SWMLService.add_verb`` (python core/agent_base.py:1194-1216, 1367-1418). + # This assembly builds the section directly, so each entry is put through + # the same schema validation here — otherwise the caller-supplied configs + # of #add_pre_answer_verb / #add_post_answer_verb / #add_post_ai_verb reach + # the wire completely unchecked. def build_main_section sections_main = [] sections_main.concat(verb_entries(@pre_answer_verbs)) # PHASE 1: pre-answer verbs @@ -2419,7 +2426,19 @@ def build_main_section sections_main.concat(verb_entries(@post_answer_verbs)) # PHASE 3b: post-answer verbs sections_main << { 'ai' => build_ai_config } # PHASE 4: AI verb sections_main.concat(verb_entries(@post_ai_verbs)) # PHASE 5: post-AI verbs - sections_main + sections_main.each { |entry| validate_section_entry(entry) } + end + + # Validate one assembled {verb_name => config} entry against the SWML + # schema, exactly as Service#add_verb would. Raises SchemaValidationError + # on an invalid config; a bare Integer +sleep+ is a valid direct value and + # is passed through, matching Service#add_verb's sleep handling. + def validate_section_entry(entry) + verb_name, config = entry.first + return entry if verb_name == 'sleep' && config.is_a?(Integer) + + __send__(:verb_config_valid!, verb_name, config) + entry end # Map a [[verb_name, config], ...] list into [{verb_name => config}, ...]. @@ -2484,7 +2503,6 @@ def build_ai_config add_ai_params(ai) ai['global_data'] = @global_data.dup unless @global_data.empty? add_ai_contexts(ai) - ai['mcp_servers'] = @mcp_servers.map(&:dup) unless @mcp_servers.empty? ai end @@ -2520,13 +2538,19 @@ def add_ai_post_prompt(config) # @api private — render the AI verb's `SWAIG` object: the default webhook URL, # plus `functions` / `native_functions` / `includes` / `internal_fillers` when # non-empty. The whole key is dropped when there is nothing but the defaults. + # `mcp_servers` lives INSIDE this SWAIG object, not at the ai verb's top + # level (reference core/agent_base.py:1150-1153 — `swaig_obj["mcp_servers"]`). + # The ai verb's schema is closed, so a top-level `mcp_servers` is a key the + # platform rejects; it only ever shipped because this assembly bypassed the + # validating add_verb. def add_ai_swaig(config) functions = build_functions_array swaig = { 'defaults' => { 'web_hook_url' => swaig_default_url } } - swaig['functions'] = functions unless functions.empty? - swaig['native_functions'] = @native_functions unless @native_functions.empty? - swaig['includes'] = @function_includes unless @function_includes.empty? - swaig['internal_fillers'] = @internal_fillers unless @internal_fillers.empty? + { 'functions' => functions, 'native_functions' => @native_functions, + 'includes' => @function_includes, 'internal_fillers' => @internal_fillers, + 'mcp_servers' => @mcp_servers.map(&:dup) }.each do |key, value| + swaig[key] = value unless value.empty? + end config['SWAIG'] = swaig unless swaig.keys == ['defaults'] && functions.empty? end @@ -2567,10 +2591,20 @@ def add_ai_params(config) # @api private — render the AI verb's `contexts` from the context builder. An # invalid context configuration is skipped rather than raised, so a broken # contexts block degrades to a context-free agent instead of failing the render. + # + # `contexts` belongs INSIDE the prompt object (`ai.prompt.contexts`), not at + # the ai verb's top level — the reference builds it that way + # (core/swml_handler.py:191 `prompt_config["contexts"]`) and this port's own + # AiVerbHandler#build_prompt_config already agrees. The ai verb's schema is + # closed, so a top-level `contexts` is a key the platform rejects; it only + # ever shipped because this assembly bypassed the validating add_verb. def add_ai_contexts(config) return unless @context_builder - config['contexts'] = @context_builder.to_h + prompt = config['prompt'] + return unless prompt.is_a?(Hash) + + prompt['contexts'] = @context_builder.to_h rescue ArgumentError # invalid context config — skip silently end diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 2788536c..1ac1ea45 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -225,13 +225,19 @@ def respond_to_missing?(method_name, include_private = false) # # For most verbs the config is a keyword-args Hash. # The +sleep+ verb is special: it also accepts a bare Integer. + # + # This is the target of the {#method_missing} verb auto-vivification + # (+service.play(url: ...)+), so it goes through the *validating* + # {#add_verb} rather than the raw document entry point — a caller + # reaching a method on the Service cannot tell which they got, and a + # raw one silently accepts configs the schema rejects. def execute_verb(verb_name, args = [], kwargs = {}) verb_name = verb_name.to_s if verb_name == 'sleep' - @document.add_verb(verb_name, sleep_duration(args, kwargs)) + add_verb(verb_name, sleep_duration(args, kwargs)) else - @document.add_verb(verb_name, SWML._verb_config(verb_name, args, kwargs)) + add_verb(verb_name, SWML._verb_config(verb_name, args, kwargs)) end end diff --git a/lib/signalwire/swml/swml_builder.rb b/lib/signalwire/swml/swml_builder.rb index ebb8740c..f2bb1455 100644 --- a/lib/signalwire/swml/swml_builder.rb +++ b/lib/signalwire/swml/swml_builder.rb @@ -42,8 +42,7 @@ def answer(max_duration: nil, codecs: nil) config = {} config['max_duration'] = max_duration unless max_duration.nil? config['codecs'] = codecs unless codecs.nil? - @service.document.add_verb('answer', config) - self + add_verb('answer', config) end # Add a 'hangup' verb to the main section. @@ -53,8 +52,7 @@ def answer(max_duration: nil, codecs: nil) def hangup(reason: nil) config = {} config['reason'] = reason unless reason.nil? - @service.document.add_verb('hangup', config) - self + add_verb('hangup', config) end # Add an 'ai' verb to the main section. @@ -101,8 +99,7 @@ def play(url: nil, urls: nil, volume: nil, say_voice: nil, config['say_gender'] = say_gender unless say_gender.nil? config['auto_answer'] = auto_answer unless auto_answer.nil? - @service.document.add_verb('play', config) - self + add_verb('play', config) end # Add a 'play' verb with a +say:+ prefix for text-to-speech. @@ -160,11 +157,10 @@ def method_missing(method_name, *args, **kwargs) return super unless SWML.schema.valid_verb?(verb) if verb == 'sleep' - @service.document.add_verb('sleep', sleep_duration(args, kwargs)) + add_verb('sleep', sleep_duration(args, kwargs)) else - @service.document.add_verb(verb, SWML._verb_config(verb, args, kwargs)) + add_verb(verb, SWML._verb_config(verb, args, kwargs)) end - self end # Report the auto-vivified verbs as respondable (Ruby analog of Python's @@ -181,8 +177,15 @@ def put(config, pairs) end # Add a verb to the underlying document and return self for chaining. + # + # Every builder verb funnels through here and through the *validating* + # Service#add_verb — never the raw Document entry point. The raw path + # writes whatever it is handed, which is how schema-invalid configs + # (a +play+ with a +text+ key, a +hangup+ with a reason outside the + # closed +hangup|busy|decline+ enum) shipped unnoticed. A rejected + # config now raises SchemaValidationError at build time. def add_verb(name, config) - @service.document.add_verb(name, config) + @service.add_verb(name, config) self end diff --git a/lib/signalwire/swml/swml_renderer.rb b/lib/signalwire/swml/swml_renderer.rb index 6a834776..5ab333ec 100644 --- a/lib/signalwire/swml/swml_renderer.rb +++ b/lib/signalwire/swml/swml_renderer.rb @@ -62,8 +62,12 @@ def self.render_swml(prompt:, service:, post_prompt: nil, post_prompt_url: nil, end # Add the record_call verb with its exact wire keys (format + stereo). + # + # Goes through the validating Service#add_verb rather than the raw + # document entry point, so a config the schema rejects fails loudly here + # instead of shipping an invalid document. def self.add_record_call(service, record_format, record_stereo) - service.document.add_verb('record_call', { 'format' => record_format, 'stereo' => record_stereo }) + service.add_verb('record_call', { 'format' => record_format, 'stereo' => record_stereo }) end # Emit the ai verb on the builder from the renderer's inputs. diff --git a/tests/agent_test.rb b/tests/agent_test.rb index b80defac..15c264dd 100644 --- a/tests/agent_test.rb +++ b/tests/agent_test.rb @@ -793,7 +793,7 @@ def test_pre_answer_verbs end def test_clear_pre_answer_verbs - @agent.add_pre_answer_verb('play', { 'url' => 'ring.mp3' }) + @agent.add_pre_answer_verb('play', { 'url' => 'https://example.com/ring.mp3' }) @agent.clear_pre_answer_verbs swml = @agent.render_swml main = swml['sections']['main'] @@ -802,7 +802,7 @@ def test_clear_pre_answer_verbs end def test_post_answer_verbs - @agent.add_post_answer_verb('play', { 'url' => 'welcome.mp3' }) + @agent.add_post_answer_verb('play', { 'url' => 'https://example.com/welcome.mp3' }) swml = @agent.render_swml main = swml['sections']['main'] # After answer, before AI @@ -873,11 +873,14 @@ def test_contexts_rendered_in_swml agent = SignalWire::AgentBase.new ctx = agent.define_contexts.add_context('default') ctx.add_step('greeting').set_text('Say hello') - swml = agent.render_swml - ai = swml['sections']['main'].find { |v| v.key?('ai') }['ai'] + main = agent.render_swml['sections']['main'] + # contexts lives inside the prompt object (reference + # core/swml_handler.py:191) -- the ai schema is closed and would reject a + # top-level key. + contexts = main.find { |v| v.key?('ai') }.dig('ai', 'prompt', 'contexts') - assert ai.key?('contexts'), 'Expected contexts in AI config' - assert ai['contexts'].key?('default') + refute_nil contexts, 'Expected contexts in the AI prompt config' + assert contexts.key?('default') end end @@ -1003,7 +1006,7 @@ def test_with_params def five_phase_agent agent = SignalWire::AgentBase.new(record_call: true) agent.add_pre_answer_verb('set', { 'x' => '1' }) - agent.add_post_answer_verb('play', { 'url' => 'welcome.mp3' }) + agent.add_post_answer_verb('play', { 'url' => 'https://example.com/welcome.mp3' }) agent.add_post_ai_verb('hangup', {}) agent end diff --git a/tests/mcp_test.rb b/tests/mcp_test.rb index 4349567b..c12fd5b2 100644 --- a/tests/mcp_test.rb +++ b/tests/mcp_test.rb @@ -242,9 +242,12 @@ def test_mcp_servers_in_swml ai_verb = agent.render_swml['sections']['main'].find { |v| v.key?('ai') } refute_nil ai_verb, 'expected ai verb' - servers = ai_verb['ai']['mcp_servers'] + # mcp_servers lives inside the SWAIG object, not at the ai verb's top level + # (reference core/agent_base.py:1153) -- the ai schema is closed and would + # reject a top-level key. + servers = ai_verb.dig('ai', 'SWAIG', 'mcp_servers') - refute_nil servers, 'expected mcp_servers in AI config' + refute_nil servers, 'expected mcp_servers in the SWAIG config' assert_equal 1, servers.length assert_equal 'https://mcp.example.com/tools', servers[0]['url'] end diff --git a/tests/render_test.rb b/tests/render_test.rb index dcd3f4b2..c271fc7a 100644 --- a/tests/render_test.rb +++ b/tests/render_test.rb @@ -103,7 +103,7 @@ class Render5PhaseOrderingTest < Minitest::Test def five_phase_agent agent = SignalWire::AgentBase.new(record_call: true) agent.add_pre_answer_verb('set', { 'x' => '1' }) - agent.add_post_answer_verb('play', { 'url' => 'welcome.mp3' }) + agent.add_post_answer_verb('play', { 'url' => 'https://example.com/welcome.mp3' }) agent.add_post_ai_verb('hangup', {}) agent end @@ -148,7 +148,10 @@ def test_contexts_rendered_in_swml swml = agent.render_swml ai = ai_section(swml) - assert ai.key?('contexts'), 'Expected contexts in AI config' - assert ai['contexts'].key?('default') + # contexts lives inside the prompt object (reference + # core/swml_handler.py:191) -- the ai schema is closed and would reject a + # top-level key. + assert ai['prompt'].key?('contexts'), 'Expected contexts in the AI prompt config' + assert ai['prompt']['contexts'].key?('default') end end diff --git a/tests/swml_builder_test.rb b/tests/swml_builder_test.rb index cdc3dbc7..109c0efb 100644 --- a/tests/swml_builder_test.rb +++ b/tests/swml_builder_test.rb @@ -45,15 +45,17 @@ def test_ai_text_prompt_wire_shape def test_ai_pom_post_prompt_swaig_and_kwargs pom = [{ 'title' => 'Role' }] + # kwargs merge at the ai verb's TOP level, so they must be keys the closed + # ai schema declares -- LLM knobs like `temperature` go under `params`. @builder.ai(prompt_pom: pom, post_prompt: 'summarize', post_prompt_url: 'https://ex.com/pp', - swaig: { 'functions' => [] }, temperature: 0.4) + swaig: { 'functions' => [] }, params: { 'temperature' => 0.4 }) cfg = main.first['ai'] assert_equal({ 'pom' => pom }, cfg['prompt']) assert_equal({ 'text' => 'summarize' }, cfg['post_prompt']) assert_equal 'https://ex.com/pp', cfg['post_prompt_url'] assert_equal({ 'functions' => [] }, cfg['SWAIG']) - assert_in_delta 0.4, cfg['temperature'] + assert_in_delta 0.4, cfg['params']['temperature'] end def test_play_url @@ -63,9 +65,12 @@ def test_play_url end def test_play_urls_list - @builder.play(urls: %w[a.mp3 b.mp3]) + # `urls` entries must be real play URLs (http(s):, say:, ring:, silence:) -- + # a bare filename is rejected by the SWML schema. + urls = %w[https://ex.com/a.mp3 say:and+now+this] + @builder.play(urls: urls) - assert_equal({ 'play' => { 'urls' => %w[a.mp3 b.mp3] } }, main.first) + assert_equal({ 'play' => { 'urls' => urls } }, main.first) end def test_play_requires_url_or_urls @@ -103,6 +108,9 @@ def test_render_is_json_string end def test_fluent_chaining_returns_self + # `reason` carries `x-sdk-widen: true`: the hangup|busy|decline union is a + # HINT and the platform accepts any string, so an out-of-union value like + # 'done' must still validate. result = @builder.reset.answer.say('hi').hangup(reason: 'done') assert_same @builder, result diff --git a/tests/swml_renderer_test.rb b/tests/swml_renderer_test.rb index dc7a71a4..8fdfc075 100644 --- a/tests/swml_renderer_test.rb +++ b/tests/swml_renderer_test.rb @@ -93,11 +93,14 @@ def test_render_swml_pom_prompt end def test_render_swml_params_merged_into_ai + # `params:` merges at the ai verb's TOP level (parity with the reference's + # `**(params or {})`), so its keys must be ones the closed ai schema + # declares -- LLM knobs like `temperature` belong under `ai.params`. doc = render_and_parse( - prompt: 'hi', service: new_service, params: { 'temperature' => 0.3 } + prompt: 'hi', service: new_service, params: { 'params' => { 'temperature' => 0.3 } } ) - assert_in_delta 0.3, doc['sections']['main'].first['ai']['temperature'] + assert_in_delta 0.3, doc['sections']['main'].first['ai']['params']['temperature'] end def test_render_swml_yaml_format @@ -157,11 +160,15 @@ def test_function_response_appends_actions # Actions route through the validating Service#add_verb too (matching the # reference), so a schema-invalid action config raises instead of silently # landing in the document. + # + # Note the example is an UNKNOWN KEY, not an out-of-enum `reason`: + # `hangup.reason` carries `x-sdk-widen: true`, so any string is accepted + # there and would NOT make a usable negative case. def test_function_response_rejects_schema_invalid_action assert_raises(SignalWire::Utils::SchemaValidationError) do SignalWire::SWML::SwmlRenderer.render_function_response_swml( response_text: 'bye', service: new_service, - actions: [{ 'hangup' => { 'reason' => 'not-a-valid-reason' } }] + actions: [{ 'hangup' => { 'not_a_hangup_key' => 'x' } }] ) end end diff --git a/tests/swml_test.rb b/tests/swml_test.rb index fc180a76..d58ee34c 100644 --- a/tests/swml_test.rb +++ b/tests/swml_test.rb @@ -354,10 +354,10 @@ def test_play_verb_with_positional_string_key_hash # A positional Hash and kwargs merge (kwargs win on a key collision). def test_verb_positional_hash_merges_with_kwargs svc = SignalWire::SWML::Service.new(name: 'test') - svc.play({ 'url' => 'a.mp3', 'volume' => 1 }, volume: 5) + svc.play({ 'url' => 'https://ex.com/a.mp3', 'volume' => 1 }, volume: 5) verbs = svc.document.get_verbs - assert_equal({ 'play' => { 'url' => 'a.mp3', 'volume' => 5 } }, verbs.first) + assert_equal({ 'play' => { 'url' => 'https://ex.com/a.mp3', 'volume' => 5 } }, verbs.first) end # A misshapen positional (a non-Hash, or more than one) must RAISE loudly, not diff --git a/tests/verb_test.rb b/tests/verb_test.rb index a80558e6..2076c2cc 100644 --- a/tests/verb_test.rb +++ b/tests/verb_test.rb @@ -22,7 +22,7 @@ def test_pre_answer_verbs end def test_clear_pre_answer_verbs - @agent.add_pre_answer_verb('play', { 'url' => 'ring.mp3' }) + @agent.add_pre_answer_verb('play', { 'url' => 'https://example.com/ring.mp3' }) @agent.clear_pre_answer_verbs swml = @agent.render_swml main = swml['sections']['main'] @@ -32,7 +32,7 @@ def test_clear_pre_answer_verbs def test_multiple_pre_answer_verbs @agent.add_pre_answer_verb('set', { 'x' => '1' }) - @agent.add_pre_answer_verb('play', { 'url' => 'ring.mp3' }) + @agent.add_pre_answer_verb('play', { 'url' => 'https://example.com/ring.mp3' }) swml = @agent.render_swml main = swml['sections']['main'] @@ -47,7 +47,7 @@ def setup end def test_post_answer_verbs - @agent.add_post_answer_verb('play', { 'url' => 'welcome.mp3' }) + @agent.add_post_answer_verb('play', { 'url' => 'https://example.com/welcome.mp3' }) swml = @agent.render_swml main = swml['sections']['main'] answer_idx = main.index { |v| v.key?('answer') } From 52f45037547199519e102e166df757055d152033 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:04:15 -0400 Subject: [PATCH 47/90] fix(bedrock): validate the post-render verb rewrite MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `BedrockAgent#_render_swml_internal` REWRITES the already-rendered document, swapping the `ai` verb for `amazon_bedrock` after the base render has validated `ai`. The substituted verb went to the wire with no schema check at all — a document-rewriting path is a bypass the "raw add_verb" sweep does not match, because it touches neither Document nor Service. The rewritten entry now goes through the same validation the assembly uses. It immediately caught a real defect: `voice_id` is a CLOSED enum of the five Bedrock voices (tiffany|matthew|amy|lupe|carlos) with no `x-sdk-widen` marker, and two tests configured Polly voices ('joanna', 'stephen') that Bedrock does not have. Both schema copies agree on the enum, so those renders were invalid. Checked and found CORRECT, recorded so it is not re-litigated: the fixed six-key allowlist in `build_bedrock_object` (prompt/SWAIG/params/global_data/ post_prompt/post_prompt_url) is byte-for-byte the reference's own list (agents/bedrock.py:111-137) AND exactly the key set `$defs/AmazonBedrock` declares. `hints`/`languages`/`pronounce` are dropped because the schema does not accept them there — the drop is the schema's doing, not silent data loss. `debug_webhook_url`/`debug_webhook_level` ride inside `params`, which IS copied, and survive the rewrite; a regression test now pins that. Also verified there is no OTHER post-render transform in the port: one match for a document-shaped rewrite across all of lib/, this one. Every other `render_*` method produces prompt text (POM/contexts), not a SWML document. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/agents/bedrock.rb | 11 ++++++- tests/bedrock_agent_test.rb | 56 +++++++++++++++++++++++++++++--- 2 files changed, 62 insertions(+), 5 deletions(-) diff --git a/lib/signalwire/agents/bedrock.rb b/lib/signalwire/agents/bedrock.rb index 8f1db80f..7059704f 100644 --- a/lib/signalwire/agents/bedrock.rb +++ b/lib/signalwire/agents/bedrock.rb @@ -75,7 +75,16 @@ def _render_swml_internal return swml unless main.is_a?(Array) idx = main.index { |verb| verb.is_a?(Hash) && verb.key?('ai') } - main[idx] = { 'amazon_bedrock' => build_bedrock_object(main[idx]['ai']) } if idx + if idx + entry = { 'amazon_bedrock' => build_bedrock_object(main[idx]['ai']) } + # This rewrite happens AFTER the base render has validated the `ai` + # verb, so the substituted verb would otherwise reach the wire with no + # schema check at all. `build_bedrock_object` copies a fixed key set, + # and a key the schema does not accept (or one it requires and the + # copy dropped) is exactly the class of defect that silence hides. + validate_section_entry(entry) + main[idx] = entry + end swml end diff --git a/tests/bedrock_agent_test.rb b/tests/bedrock_agent_test.rb index 2c83dbd3..736c63ae 100644 --- a/tests/bedrock_agent_test.rb +++ b/tests/bedrock_agent_test.rb @@ -34,12 +34,15 @@ def test_renders_amazon_bedrock_verb_not_ai refute(main.any? { |v| v.key?('ai') }, 'ai verb must be transformed away') end + # `voice_id` is a CLOSED enum of the five Bedrock voices + # (tiffany|matthew|amy|lupe|carlos) and carries no `x-sdk-widen` marker, so a + # Polly voice name is not a value the platform accepts here. def test_voice_and_inference_params_in_prompt - agent = SignalWire::Agents::BedrockAgent.new(voice_id: 'joanna', temperature: 0.3, top_p: 0.8) + agent = SignalWire::Agents::BedrockAgent.new(voice_id: 'amy', temperature: 0.3, top_p: 0.8) agent.set_prompt_text('Hi') prompt = bedrock_verb(agent)['prompt'] - assert_equal 'joanna', prompt['voice_id'] + assert_equal 'amy', prompt['voice_id'] assert_in_delta(0.3, prompt['temperature']) assert_in_delta(0.8, prompt['top_p']) end @@ -73,9 +76,9 @@ def test_nil_keys_dropped def test_set_voice agent = SignalWire::Agents::BedrockAgent.new agent.set_prompt_text('Hi') - agent.set_voice('stephen') + agent.set_voice('tiffany') - assert_equal 'stephen', bedrock_verb(agent)['prompt']['voice_id'] + assert_equal 'tiffany', bedrock_verb(agent)['prompt']['voice_id'] end def test_set_inference_params_partial_update @@ -140,3 +143,48 @@ def test_is_agent_base_subclass assert_kind_of SignalWire::AgentBase, agent end end + +# The bedrock render REWRITES the already-rendered document, swapping the `ai` +# verb for `amazon_bedrock` after the base render validated `ai`. The +# substituted verb must be validated too, or a post-render rewrite is a hole +# straight to the wire. +class BedrockRenderValidationTest < Minitest::Test + def test_rewritten_verb_goes_through_the_validator + agent = SignalWire::Agents::BedrockAgent.new(voice_id: 'lupe') + agent.set_prompt_text('Hi') + + # A valid agent renders cleanly... + verb = agent.render_swml['sections']['main'].find { |v| v.key?('amazon_bedrock') } + + refute_nil verb, 'expected an amazon_bedrock verb' + + # ...and an out-of-enum voice is REJECTED rather than silently shipped. + agent.set_voice('not-a-bedrock-voice') + assert_raises(SignalWire::Utils::SchemaValidationError) { agent.render_swml } + end + + # `build_bedrock_object` copies a FIXED key set; anything outside it is + # dropped. That set must be exactly what the amazon_bedrock schema allows, + # so the drop is the schema's doing and not a silent data loss. + def test_copied_key_set_matches_the_schema + allowed = %w[SWAIG global_data params post_prompt post_prompt_url prompt] + agent = SignalWire::Agents::BedrockAgent.new + agent.set_prompt_text('Hi') + agent.set_global_data({ 'k' => 'v' }) + verb = agent.render_swml['sections']['main'].find { |v| v.key?('amazon_bedrock') }['amazon_bedrock'] + + assert_empty verb.keys - allowed, 'emitted a key the amazon_bedrock schema does not declare' + end + + # debug_events ride inside `params`, which IS copied -- so enabling them on a + # Bedrock agent must not lose the webhook wiring. + def test_debug_webhook_survives_the_rewrite + agent = SignalWire::Agents::BedrockAgent.new + agent.set_prompt_text('Hi') + agent.enable_debug_events + verb = agent.render_swml['sections']['main'].find { |v| v.key?('amazon_bedrock') }['amazon_bedrock'] + + refute_nil verb.dig('params', 'debug_webhook_url'), 'debug_webhook_url lost in the bedrock rewrite' + refute_nil verb.dig('params', 'debug_webhook_level'), 'debug_webhook_level lost in the bedrock rewrite' + end +end From 8cf87e23f90643aceb889e984d9bc15572ddb8ee Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:23:35 -0400 Subject: [PATCH 48/90] fix: keep the new validation helper off the public surface; de-jargon its docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two gate failures from the preceding commits, both real: PUBLIC-JARGON — the widen helper's doc comments cited internal porting-project vocabulary (`x-sdk-`, `porting-sdk`) in SHIPPED source, where it reaches users' generated docs and IDE hover. Rewritten to describe the behavior in terms a consumer of this SDK can act on; the internal citation lives in the commit message, which is where it belongs. Field names the code actually reads are untouched — the gate scans doc comments, not code. SURFACE/DRIFT — `validate_section_entry` was public, so it registered as port surface the reference does not have (`missing-reference: in port, not in reference`). It is internal render plumbing, not agent-author API, so it is now private and BedrockAgent reaches it via __send__ (the same way it already reaches `verb_config_valid!`). Folding the visibility is the fix; an omission entry would have recorded invented surface as permanent. drift.sh . -> signatures match (1563 reference symbols, 2548 port symbols) public_jargon.py --port ruby -> clean (scanned 1209 source files) port_surface.json regenerated; the only content change is its provenance line. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/agent/agent_base.rb | 5 +++++ lib/signalwire/agents/bedrock.rb | 3 ++- lib/signalwire/utils/schema_utils.rb | 25 +++++++++++++------------ port_surface.json | 2 +- 4 files changed, 21 insertions(+), 14 deletions(-) diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index f9982d35..e73752b1 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -2433,6 +2433,10 @@ def build_main_section # schema, exactly as Service#add_verb would. Raises SchemaValidationError # on an invalid config; a bare Integer +sleep+ is a valid direct value and # is passed through, matching Service#add_verb's sleep handling. + # + # Private: this is internal render plumbing, not agent-author surface. A + # subclass that rewrites the rendered document (BedrockAgent) reaches it via + # __send__ to re-validate what it substitutes. def validate_section_entry(entry) verb_name, config = entry.first return entry if verb_name == 'sleep' && config.is_a?(Integer) @@ -2440,6 +2444,7 @@ def validate_section_entry(entry) __send__(:verb_config_valid!, verb_name, config) entry end + private :validate_section_entry # Map a [[verb_name, config], ...] list into [{verb_name => config}, ...]. def verb_entries(verbs) diff --git a/lib/signalwire/agents/bedrock.rb b/lib/signalwire/agents/bedrock.rb index 7059704f..bef8ec33 100644 --- a/lib/signalwire/agents/bedrock.rb +++ b/lib/signalwire/agents/bedrock.rb @@ -82,7 +82,8 @@ def _render_swml_internal # schema check at all. `build_bedrock_object` copies a fixed key set, # and a key the schema does not accept (or one it requires and the # copy dropped) is exactly the class of defect that silence hides. - validate_section_entry(entry) + # validate_section_entry is private render plumbing on the base class. + __send__(:validate_section_entry, entry) main[idx] = entry end diff --git a/lib/signalwire/utils/schema_utils.rb b/lib/signalwire/utils/schema_utils.rb index 1aff8eaf..40003f76 100644 --- a/lib/signalwire/utils/schema_utils.rb +++ b/lib/signalwire/utils/schema_utils.rb @@ -55,9 +55,9 @@ class SchemaUtils 'boolean' => 'bool', 'object' => 'Dict[str, Any]' }.freeze - # Keywords stripped from an `x-sdk-widen: true` property before the full - # validator is built — the ones that pin it to a fixed value set. See - # {#apply_sdk_widen}. + # Keywords stripped from a property whose value set is advisory, before + # the full validator is built — the ones that pin it to a fixed set of + # values. See {#apply_sdk_widen}. WIDEN_STRIPPED_KEYS = %w[anyOf oneOf enum const x-sdk-enum-literal].freeze # @return [Hash{String=>Object}] parsed JSON Schema document @@ -362,15 +362,16 @@ def init_full_validator @full_validator = nil end - # `x-sdk-widen: true` declares that a property's `enum`/`const` union is - # only a HINT and the platform accepts any value of the base scalar type - # (porting-sdk REST_GENERATOR_RULES.md §5: "a schema enum/const is only a - # hint, so widen to the base scalar — e.g. `hangup.reason` const-union → - # `str`; the platform accepts any string"). Validating against the raw - # const-union would make this SDK reject documents the platform accepts, - # so drop the constraint on marked properties before building the - # validator. Returns a widened deep copy; @schema itself is untouched, so - # code-gen callers still see the enum hint. + # Some schema properties mark their `enum`/`const` union as advisory: the + # listed values are the documented ones, but the platform accepts any + # value of the same base scalar type. `hangup.reason` is the standing + # example — the `hangup|busy|decline` union is a hint, and any string is + # valid on the wire. + # + # Validating against the raw union would make this SDK reject documents + # the platform accepts, so the constraint is dropped on marked properties + # before the validator is built. Returns a widened copy; the schema itself + # is untouched, so callers reading it still see the documented values. # # @return [Hash, Array, Object] def apply_sdk_widen(node) diff --git a/port_surface.json b/port_surface.json index 9ea6f8dd..eb6d585a 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 91c5ba3a013803def5ddf50e2abc7170cd37fcce", + "generated_from": "signalwire-ruby @ 52f45037547199519e102e166df757055d152033", "modules": { "signalwire": { "classes": {}, From ff40180c24ed9b28f3ae13e1adf299f2810cc961 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Wed, 29 Jul 2026 23:37:51 -0400 Subject: [PATCH 49/90] Revert "fix(swml): vendored schema was missing `AIObject.multilingual`" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 54b1494, and exempts the `ai` verb from render-time validation until the schema is regenerated from the engine. Owner directive: a new SWML spec is being vendored off the server code, and the vendored-schema gap is not to be worked around in the meantime. The reverted commit's PREMISE was wrong, not just its timing. I argued the port "emitted a key its own validator would refuse" and treated the vendored file's nine-key closure as the contract. It is not. The engine's ai-verb arg list (mod_infrastructure/swml_schema.c:1880) accepts FIFTEEN: agent, prompt, post_prompt, engine, voice, post_prompt_url, post_prompt_auth_user, post_prompt_auth_password, languages, multilingual, pronounce, global_data, SWAIG, params, hints The bundled copy declares nine and is a STRICT SUBSET — six missing, zero extras, verified by set-differencing the two lists. So `multilingual` was never a defect on either side: the SDK emits it because the platform takes it, and only the stale file disagreed. Editing that file to paper over the disagreement was the wrong repair; the file itself is what is behind. Consequence handled here: routing `build_main_section` through the validator (commit db8c136) is what first exposed this, because the assembly had never been validated before. With the schema reverted, validating `ai` against it would reject those six legitimate keys. `ai` is therefore exempted at `validate_section_entry`, with the engine's list recorded at the exemption so it can be lifted deliberately. Every OTHER verb stays validated — the ITEM 4 routing work is untouched. The misplacement fixes from db8c136 are unaffected and remain: they were verified against the reference's own emission, not inferred from a closure, and their tests assert the emitted shape rather than going through the validator. Re-verified on the reverted tree: contexts -> ai.prompt.contexts (not ai.contexts) mcp_servers -> ai.SWAIG.mcp_servers (not ai.mcp_servers) native_functions -> ai.SWAIG.native_functions temperature -> ai.prompt.temperature debug_webhook_url/_level -> ai.params Suite: 2749 runs, 0 failures, 0 errors. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/agent/agent_base.rb | 10 ++++ lib/signalwire/swml/schema.json | 83 ------------------------------ port_surface.json | 2 +- 3 files changed, 11 insertions(+), 84 deletions(-) diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index e73752b1..1c4c74a9 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -2437,9 +2437,19 @@ def build_main_section # Private: this is internal render plumbing, not agent-author surface. A # subclass that rewrites the rendered document (BedrockAgent) reaches it via # __send__ to re-validate what it substitutes. + # + # The `ai` verb is EXEMPT for now. The bundled schema's AIObject declares + # nine properties and is closed; the engine accepts fifteen + # (agent, prompt, post_prompt, engine, voice, post_prompt_url, + # post_prompt_auth_user, post_prompt_auth_password, languages, multilingual, + # pronounce, global_data, SWAIG, params, hints). The bundled copy is a + # strict subset with no extras, so validating `ai` against it would reject + # six keys the platform accepts — `multilingual` among them, which this SDK + # emits. Re-enable once the schema is regenerated from the engine. def validate_section_entry(entry) verb_name, config = entry.first return entry if verb_name == 'sleep' && config.is_a?(Integer) + return entry if verb_name == 'ai' __send__(:verb_config_valid!, verb_name, config) entry diff --git a/lib/signalwire/swml/schema.json b/lib/signalwire/swml/schema.json index 4ccdd348..8785f89b 100644 --- a/lib/signalwire/swml/schema.json +++ b/lib/signalwire/swml/schema.json @@ -2436,89 +2436,6 @@ }, "description": "An array of JSON objects defining supported languages in the conversation." }, - "multilingual": { - "type": "object", - "title": "Multilingual", - "description": "ASR-driven multilingual mode. The recognizer runs in code-switching mode and reports the language of each utterance; the agent answers in that language and swaps to the matching voice. Mutually exclusive with `languages` - when both are present the server uses `multilingual`.", - "properties": { - "languages": { - "type": "array", - "description": "Voice entries keyed by BCP-47 base code. Needs a `default` (or first) entry with a voice.", - "items": { - "type": "object", - "properties": { - "language": { - "type": "string" - }, - "voice": { - "type": "string" - }, - "engine": { - "type": "string" - }, - "model": { - "type": "string" - }, - "params": { - "type": "object" - } - } - } - }, - "engine": { - "type": "string", - "description": "ASR engine. Runs in `multi`. Default deepgram." - }, - "model": { - "type": "string", - "description": "ASR model. Default nova-3." - }, - "provider": { - "type": "string", - "description": "ASR provider (deepgram / gladia / grok)." - }, - "start_language": { - "type": "string", - "description": "BCP-47 base code the agent opens in. Default `en`." - }, - "allowed": { - "type": "array", - "items": { - "type": "string" - }, - "description": "BCP-47 base codes the agent may switch into." - }, - "min_switch_words": { - "type": "integer", - "description": "Minimum words in an utterance before a detected-language switch is trusted. Default 2." - }, - "fillers": { - "description": "Global speech fillers. Flat array = auto-translate; object = language-keyed map.", - "anyOf": [ - { - "type": "array" - }, - { - "type": "object" - } - ] - }, - "function_fillers": { - "description": "Global function-call fillers. Same shape as `fillers`.", - "anyOf": [ - { - "type": "array" - }, - { - "type": "object" - } - ] - } - }, - "required": [ - "languages" - ] - }, "params": { "$ref": "#/$defs/AIParams", "description": "A JSON object containing parameters as key-value pairs." diff --git a/port_surface.json b/port_surface.json index eb6d585a..45c74986 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 52f45037547199519e102e166df757055d152033", + "generated_from": "signalwire-ruby @ 8cf87e23f90643aceb889e984d9bc15572ddb8ee", "modules": { "signalwire": { "classes": {}, From e710b6c716ee50a44e5268513a0d54e2d5fdb613 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 00:50:21 -0400 Subject: [PATCH 50/90] docs(tools): de-jargon the SWAIG tool registry's public YARD docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The PUBLIC-JARGON gate stopped excluding `core/agent/tools/` as build scaffolding (porting-sdk d9a9674), so it now reads this file and finds three shipped doc comments that describe the API in porting-process terms rather than in terms a Ruby caller can use. Each rewrite keeps the behavioural fact and drops the cross-language framing: - `#initialize` / `#agent` — the back-reference is real and may be nil, so say that, and add the fact a caller actually needs: it is read-only, the registry never calls back into the agent (`@agent` is assigned once and never read here). - `#define_tool` — replace the restated Python signature with which keywords are required vs optional, and fold in the `parameters: {}` note that was stranded after `@return`. The defaults the old block listed are already visible in the Ruby signature and the `@param` tags. - `#register_swaig_function` — state the two rules directly: the dictionary must carry a `function` field, and a duplicate name is rejected rather than replaced. Also de-jargons the class-level doc, which named the Python module path and the TypeScript class. The "no dedicated value object" note is kept — the return type is a real fact for a caller — just stated without the comparison. Prose only; no behaviour change. Suite unchanged at 2749 runs, 0 failures. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/core/agent/tools/registry.rb | 44 +++++++++------------ 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/lib/signalwire/core/agent/tools/registry.rb b/lib/signalwire/core/agent/tools/registry.rb index 247e9bfa..fbda767a 100644 --- a/lib/signalwire/core/agent/tools/registry.rb +++ b/lib/signalwire/core/agent/tools/registry.rb @@ -16,30 +16,26 @@ module Agent module Tools # Manages SWAIG function registration. # - # Mirrors Python's - # ``signalwire.core.agent.tools.registry.ToolRegistry`` and the - # TypeScript ``ToolRegistry`` class. A registry holds SWAIG - # function definitions keyed by name. Two kinds of entries are - # supported: + # A registry holds SWAIG function definitions keyed by name. Two + # kinds of entries are supported: # # - definitions created via {#define_tool} (carry a +handler+), and # - raw SWAIG function dictionaries via {#register_swaig_function} # (e.g. from a DataMap's ``to_swaig_function``) which execute on # SignalWire's server and carry no handler. # - # Ruby has no dedicated ``SWAIGFunction`` value object (AgentBase - # stores plain Hashes on the wire), so the registry stores the - # built definition Hash with string keys, matching the wire shape. + # There is no dedicated value object for a function: entries are + # stored, and returned, as plain Hashes with String keys — the same + # shape that goes out on the wire. class ToolRegistry - # @return [Object, nil] the parent AgentBase back-reference this - # registry was constructed with. The reference exposes the same - # attribute (core/agent/tools/registry.py), so a caller that passes - # an agent can read it back. + # @return [Object, nil] the parent AgentBase this registry was + # constructed with, or nil if it was built standalone. Read-only: + # the registry itself never calls back into the agent. attr_reader :agent - # @param agent [Object, nil] optional parent AgentBase instance - # (kept as a back-reference for parity with the Python/TS - # registries; may be nil for standalone use). + # @param agent [Object, nil] optional parent AgentBase instance, + # kept as a back-reference and readable via {#agent}. Nil for + # standalone use — the registry never calls back into it. def initialize(agent = nil) @agent = agent @swaig_functions = {} # name => definition Hash (string keys) @@ -47,11 +43,11 @@ def initialize(agent = nil) # Define a SWAIG function that the AI can call. # - # Python parity: - # ``define_tool(name, description, parameters, handler, - # secure=True, fillers=None, wait_file=None, wait_file_loops=None, - # webhook_url=None, required=None, is_typed_handler=False, - # **swaig_fields)``. + # ``name:``, ``description:``, ``parameters:`` and ``handler:`` are + # all REQUIRED keywords; every other keyword is optional. A tool that + # takes no arguments must still state ``parameters: {}`` explicitly, + # and one that runs entirely on SignalWire's server passes + # ``handler: nil``. # # @param name [String] function name (must be unique) # @param description [String] LLM-facing description @@ -67,9 +63,6 @@ def initialize(agent = nil) # @param swaig_fields [Hash, nil] extra fields merged into the def # @raise [ArgumentError] if the tool name already exists # @return [Hash] the stored definition - # ``parameters:`` and ``handler:`` are REQUIRED, matching the reference - # (``define_tool(name, description, parameters, handler, ...)``). A tool - # with no parameters states ``parameters: {}`` explicitly. def define_tool(name:, description:, parameters:, handler:, secure: true, fillers: nil, wait_file: nil, wait_file_loops: nil, @@ -90,8 +83,9 @@ def define_tool(name:, description:, parameters:, handler:, # Register a raw SWAIG function dictionary (e.g. from a DataMap's # ``to_swaig_function``). # - # Python parity: ``register_swaig_function(function_dict)`` — - # requires a ``function`` field and rejects duplicates. + # The dictionary must carry a ``function`` field naming the tool; + # a name already present in the registry is rejected rather than + # replaced. # # @param function_dict [Hash] complete SWAIG function definition # @raise [ArgumentError] if the name is missing or already exists From 9da505f1a3abe440a9a3b2f582a046c69e40a3a3 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 00:52:02 -0400 Subject: [PATCH 51/90] docs(tools): drop "Mirrors Python's ..." from the type-inference docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sibling sweep of the same directory the widened PUBLIC-JARGON filter just unmasked (porting-sdk d9a9674). These three doc comments do not contain a banned token, so the gate is green either way — but they are the identical leak: a Ruby caller reading YARD hover learns nothing from a Python module path or function name, and the next expansion of the token list would red this file. In each case the "Mirrors Python's X" clause was bolted onto a sentence that otherwise states a real fact, so only the clause is removed: - module doc — keeps the reflection mechanism (`Method#parameters`), the :req/:opt/:key/:keyreq required-vs-optional rule, and the `types:` override. - `infer_schema` — keeps the actual behaviour, that a parameter named `:raw_data` is excluded from the schema (verified: line 73 rejects exactly that symbol). The old "(Ruby: `:raw_data`)" parenthetical existed only to contrast with Python's spelling. - `create_typed_handler_wrapper` — keeps the args-explosion and the conditional raw_data keyword. Prose only; no behaviour change. DOC-SURFACE stays 100% (2166/2166). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/core/agent/tools/type_inference.rb | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/lib/signalwire/core/agent/tools/type_inference.rb b/lib/signalwire/core/agent/tools/type_inference.rb index 46202bc3..b3aa466c 100644 --- a/lib/signalwire/core/agent/tools/type_inference.rb +++ b/lib/signalwire/core/agent/tools/type_inference.rb @@ -18,9 +18,6 @@ module Tools # callable's signature, and wrap a typed handler so it can be # invoked with the standard SWAIG calling convention. # - # Mirrors Python's - # ``signalwire.core.agent.tools.type_inference`` module-level - # functions ``infer_schema`` and ``create_typed_handler_wrapper``. # Ruby has no static type annotations, so the schema is inferred # from the callable's parameter list via reflection # (``Method#parameters`` / ``Proc#parameters``). Each keyword or @@ -47,9 +44,8 @@ module TypeInference # Inspect a callable's signature to infer a JSON Schema for # SWAIG tool parameters. # - # Mirrors Python's ``infer_schema`` return contract. The - # ``raw_data`` parameter (Ruby: ``:raw_data``) is treated as the - # SWAIG raw-payload channel and excluded from the schema. + # A parameter named ``:raw_data`` is treated as the SWAIG + # raw-payload channel and excluded from the schema. # # @param func [Method, Proc] the callable to inspect # @param types [Hash{Symbol,String => Class,String}, nil] @@ -82,10 +78,9 @@ def infer_schema(func, types: nil, descriptions: nil) # Wrap a typed handler so it can be invoked with the standard # SWAIG calling convention ``(args, raw_data)``. # - # Mirrors Python's ``create_typed_handler_wrapper``. The wrapper - # explodes the +args+ Hash into keyword arguments for the wrapped - # callable, passing +raw_data+ as a keyword only when the handler - # declared it. + # The wrapper explodes the +args+ Hash into keyword arguments for + # the wrapped callable, passing +raw_data+ as a keyword only when + # the handler declared it. # # @param func [Method, Proc] the typed handler # @param has_raw_data [Boolean] pass raw_data as a keyword From 2e637c17b3c81a56cdf334dd8f293d7c8a6f8100 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 02:47:48 -0400 Subject: [PATCH 52/90] fix(security)!: SWAIG `secure` tools failed OPEN on every transport A tool registered `secure: true` (define_tool's default) was not actually gated. Two independent defects, either alone sufficient to bypass: 1. WRONG FIELD. `secure_token_ok?` read the token from the POST BODY as `raw_data['meta_data_token']`. The SDK MINTS the credential into the rendered webhook's QUERY STRING as `__token` (agent_base.rb:2647), so the field it checked was never the field it emitted -- validation could only ever have passed by accident. 2. FAIL-OPEN. `return true unless call_id && token` ALLOWED the call when either was missing. Omitting the credential was strictly weaker than presenting a wrong one, which makes `secure` a flag that permits anonymous calls. A missing call_id was likewise a bypass rather than what it actually is: a token that cannot be validated against anything. Net effect: an untokened POST to a secure tool RAN the handler on HTTP, lambda, CGI, GCF and Azure alike. The fix mirrors the reference (signalwire-python e4f66b6): lift the security decision out of dispatch into a request-agnostic `swaig_validate_token(function_name, token, call_id)` -- three nullable strings in, a nullable refusal Hash out -- and call it from a new `swaig_pre_dispatch` override that pulls `__token` from the query string. `on_function_call` no longer validates anything; enforcement now happens strictly before dispatch, so it cannot be reached around. ONE hook covers BOTH transports because ruby's serverless adapters translate their invocation event into the same Rack env the HTTP path uses (`queryStringParameters` -> `QUERY_STRING`, lambda_handler.rb:150). The credential split is identical either way: token in the query string, call_id in the POST body. The refusal is a 200 + FunctionResult body, never an HTTP error status -- the engine (mod_openai) has no handling for a SWAIG refusal status, so the tool reports that it cannot execute and the model relays it. The response text is byte-identical to the reference's. Dispatch paths audited (ruby's method_missing / prepend / subclass-override analog of the reference's MRO trap): POST /swaig reaches `on_function_call` from exactly one call site, `Service#dispatch_swaig_call`, via the `swaig_pre_dispatch` hook -- and both `Service#handle_main_route` and `AgentBase#handle_main_request` route there. `Service#execute_verb` (the `method_missing` verb auto-vivifier) builds SWML documents and never dispatches SWAIG. `mcp_tools_call` deliberately bypasses the token, matching the reference (mcp_server_mixin.py:102 calls the handler directly). tests/swaig_token_enforcement_test.rb runs valid / forged / absent / no-call-id / wrong-call / wrong-function against the secure tool AND all four ungated cases against an insecure one, on BOTH transports -- 60 assertions. Pre-fix it went red on 5 assertions per transport; a fix that merely refused everything would fail the valid-token and insecure rows. Twelve existing tests asserted the fail-open behaviour by invoking a default-secure tool with no token. They exercise Rack routing, lambda envelope translation, serverless mode detection and CLI plumbing -- not security -- so their fixture tools are now declared `secure: false`, matching the reference's own convention for such tests (tests/unit/core/test_agent_base.py:1467). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- lib/signalwire/agent/agent_base.rb | 86 ++++++++-- tests/agent_test.rb | 12 +- tests/cli_test.rb | 6 +- tests/lambda_agent_test.rb | 7 +- tests/serverless_dispatch_test.rb | 6 +- tests/simulate_serverless_test.rb | 7 +- tests/swaig_token_enforcement_test.rb | 218 ++++++++++++++++++++++++++ 7 files changed, 327 insertions(+), 15 deletions(-) create mode 100644 tests/swaig_token_enforcement_test.rb diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index 1c4c74a9..2fe8b639 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -891,10 +891,13 @@ def validate_tool_token(function_name, token, call_id) end # Dispatch a function call to the registered handler. + # + # `secure` enforcement does NOT live here — it lives in + # {#swaig_validate_token}, invoked from {#swaig_pre_dispatch} before dispatch + # ever reaches this method, so every transport shares one decision. def on_function_call(name, args, raw_data = nil) tool = @tools[name] return { 'response' => "Function '#{name}' not found" } unless tool - return { 'response' => 'Invalid or expired token' } unless secure_token_ok?(name, tool, raw_data) coerce_function_result(name, tool[:handler].call(args, raw_data)) rescue StandardError => e @@ -902,15 +905,75 @@ def on_function_call(name, args, raw_data = nil) { 'response' => "Error executing '#{name}': #{e.message}" } end - # True unless this is a secure tool with a present-but-invalid token. - def secure_token_ok?(name, tool, raw_data) - return true unless tool[:secure] + # The refusal a `secure` SWAIG tool returns when its `__token` is absent, + # forged, or unvalidatable. A 200 + FunctionResult body, never an HTTP error + # status: the engine has no handling for a SWAIG refusal status, so the tool + # reports that it cannot execute and the model relays it. + SECURE_REFUSAL_RESPONSE = 'I\'m sorry, the security token for this function is invalid ' \ + 'or expired. I cannot execute this action.' + + # Enforce `secure: true` for one SWAIG call, independent of transport. + # + # A tool registered with `secure: true` (define_tool's default) REQUIRES a + # valid `__token`. An ABSENT token is refused exactly like a forged one -- + # omitting the credential must never be weaker than presenting a wrong one, + # or `secure` would be a flag that permits anonymous calls. A token can only + # be validated against a call_id, so a missing call_id is likewise treated as + # unvalidated rather than as a bypass. + # + # Three nullable strings in, a nullable Hash out: no framework types, so the + # HTTP handler and every serverless adapter share one decision. + # + # @param function_name [String] the SWAIG function being invoked + # @param token [String, nil] the `__token` credential from the query string + # @param call_id [String, nil] the call id from the POST body + # @return [Hash, nil] nil to proceed, or the refusal body to return instead + def swaig_validate_token(function_name, token, call_id) + tool = @tools[function_name] + return nil unless tool && tool[:secure] + + return nil if token && call_id && validate_tool_token(function_name, token, call_id) + + @logger.warn "secure_function_refused: function=#{function_name.inspect} token_present=#{!token.nil?}" + SignalWire::Swaig::FunctionResult.new(SECURE_REFUSAL_RESPONSE).to_h + end + + # Extension-point override: validate the per-call `__token` and apply + # ephemeral dynamic config before POST /swaig dispatch. + # + # The credential rides the QUERY STRING (`__token`) and the call_id rides the + # POST BODY (`call_id`) -- the same split on every transport, because the + # serverless adapters translate their invocation event into the same Rack env + # this hook reads. + # + # @return [Array(Object, Hash), Array(Object, nil)] `[target, short_circuit]` + def swaig_pre_dispatch(request_data, func_name, env) + call_id = swaig_call_id(request_data) + refusal = swaig_validate_token(func_name, swaig_request_token(env), call_id) + return [self, refusal] if refusal - call_id = raw_data && (raw_data['call_id'] || raw_data.dig('call', 'call_id')) - token = raw_data && raw_data['meta_data_token'] - return true unless call_id && token + target = @dynamic_config_callback ? apply_dynamic_config(request_data, Rack::Request.new(env)) : self + [target, nil] + end + + # @api private — the `__token` credential from a Rack env's query string. + # `token` is accepted as a legacy alias, matching the reference. + def swaig_request_token(env) + qs = env.is_a?(Hash) ? (env['QUERY_STRING'] || '') : '' + params = URI.decode_www_form(qs).to_h + t = params['__token'] || params['token'] + t unless t.nil? || t.empty? + rescue StandardError + nil + end + + # @api private — the call id a SWAIG POST body carries, accepting both the + # flat `call_id` and the nested `call.call_id` shape. + def swaig_call_id(request_data) + return nil unless request_data.is_a?(Hash) - @session_manager.validate_token(name, token, call_id) + cid = request_data['call_id'] || request_data.dig('call', 'call_id') + cid unless cid.nil? || cid.to_s.empty? end # Coerce a handler return into a wire Hash: Hash passes through, a @@ -3136,7 +3199,12 @@ def unauthorized private :matches_env_auth?, :mcp_input_schema, :mcp_tool_entry, :merge_skill_hints_and_data private :merge_skill_prompt_sections, :optional_tool_fields, :rack_env, :register_no_vowels_variation private :register_skill_tools, :sanitize_sip_username, :section_pom_kwargs - private :secure_token_ok?, :sym_or_str, :verb_entries, :warn_unexpected_function_result + # swaig_pre_dispatch / swaig_validate_token are PRIVATE, mirroring the + # reference's `_swaig_pre_dispatch` / `_swaig_validate_token` (both + # underscore-private). Service invokes the hook with an implicit receiver, so + # private visibility is sufficient and the override adds no public surface. + private :swaig_pre_dispatch, :swaig_validate_token, :swaig_request_token, :swaig_call_id + private :sym_or_str, :verb_entries, :warn_unexpected_function_result private :warn_unknown_filler_name, :warn_unknown_filler_names, :webrick_opts private :answer_entry, :record_call_entry, :webrick_handler private :valid_function_include?, :warn_dropped_function_include, :find_summary_in_post_data diff --git a/tests/agent_test.rb b/tests/agent_test.rb index 15c264dd..89dca067 100644 --- a/tests/agent_test.rb +++ b/tests/agent_test.rb @@ -1127,7 +1127,12 @@ class AgentRackTest < Minitest::Test def app @agent = SignalWire::AgentBase.new(basic_auth: %w[testuser testpass]) @agent.set_prompt_text('Hello') - @agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, handler: nil) do |args, _raw| + # secure: false — these cases exercise Rack ROUTING, not the `secure` token + # contract (which has its own suite in swaig_token_enforcement_test.rb). A + # secure tool would rightly refuse an untokened POST and mask the routing + # assertion. + @agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, + secure: false, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['msg']}") end @agent.on_summary(nil) do |summary, _raw| @@ -1646,7 +1651,10 @@ class AgentAsRouterTest < Minitest::Test def build_agent agent = SignalWire::AgentBase.new(basic_auth: %w[testuser testpass]) agent.set_prompt_text('Hello') - agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, handler: nil) do |args, _raw| + # secure: false — this fixture exercises the AgentServer router, not the + # `secure` token contract (see swaig_token_enforcement_test.rb). + agent.define_tool(name: 'echo', description: 'Echo', parameters: {}, + secure: false, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Echo: #{args['msg']}") end agent diff --git a/tests/cli_test.rb b/tests/cli_test.rb index aaf36de1..8467a2e5 100644 --- a/tests/cli_test.rb +++ b/tests/cli_test.rb @@ -208,11 +208,15 @@ def build_test_agent(port) agent end + # secure: false — the CLI cases assert swaig-test's --exec plumbing against a + # live agent, not the `secure` token contract (swaig_token_enforcement_test.rb). + # The CLI has no call in scope, so it cannot mint a token. def define_greet_tool(agent) agent.define_tool( name: 'greet', description: 'Greet someone by name', - parameters: { 'name' => { 'type' => 'string', 'description' => 'Person name' } }, handler: nil + parameters: { 'name' => { 'type' => 'string', 'description' => 'Person name' } }, + secure: false, handler: nil ) do |args, _raw| SignalWire::Swaig::FunctionResult.new("Hello, #{args['name']}!") end diff --git a/tests/lambda_agent_test.rb b/tests/lambda_agent_test.rb index d33bb910..159dfa5e 100644 --- a/tests/lambda_agent_test.rb +++ b/tests/lambda_agent_test.rb @@ -170,9 +170,14 @@ def setup @handler = SignalWire::Serverless::LambdaHandler.new(@agent.rack_app) end + # secure: false — the lambda-adapter cases assert the ENVELOPE translation + # (payload v1/v2, base64 bodies, header mapping), not the `secure` token + # contract, which has its own per-transport suite in + # swaig_token_enforcement_test.rb. def _define_echo_tool(agent) agent.define_tool(name: 'echo', description: 'Echo back a message', - parameters: { 'message' => { 'type' => 'string' } }, handler: nil) do |args, _raw| + parameters: { 'message' => { 'type' => 'string' } }, + secure: false, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("echo: #{args['message']}") end end diff --git a/tests/serverless_dispatch_test.rb b/tests/serverless_dispatch_test.rb index 1d5be3e6..fa044b2b 100644 --- a/tests/serverless_dispatch_test.rb +++ b/tests/serverless_dispatch_test.rb @@ -31,8 +31,12 @@ def teardown def build_agent agent = SignalWire::AgentBase.new(name: 'sless', route: '/', basic_auth: %w[u p]) agent.set_prompt_text('Hello from serverless') + # secure: false — these cases assert that each serverless MODE reaches the + # dispatcher at all; the `secure` token contract is covered per-transport in + # swaig_token_enforcement_test.rb. agent.define_tool(name: 'echo', description: 'echo', - parameters: { 'message' => { 'type' => 'string' } }, handler: nil) do |args, _raw| + parameters: { 'message' => { 'type' => 'string' } }, + secure: false, handler: nil) do |args, _raw| SignalWire::Swaig::FunctionResult.new("echo: #{args['message']}") end agent diff --git a/tests/simulate_serverless_test.rb b/tests/simulate_serverless_test.rb index e6843e05..f5901d7a 100644 --- a/tests/simulate_serverless_test.rb +++ b/tests/simulate_serverless_test.rb @@ -52,13 +52,18 @@ def agent_header_source(route, auth) RUBY end + # secure: false — these cases assert that --simulate-serverless reaches the + # dispatcher under each platform's ENV/event shape, not the `secure` token + # contract (covered per-transport in swaig_token_enforcement_test.rb). The + # simulator has no call in scope, so it cannot mint a token. def tool_source(tool) <<~RUBY AGENT.define_tool( name: #{tool[:name].inspect}, description: #{tool[:description].inspect}, - parameters: #{tool.fetch(:parameters, {}).inspect}, handler: nil + parameters: #{tool.fetch(:parameters, {}).inspect}, + secure: false, handler: nil ) do |args, raw| #{tool.fetch(:body, "SignalWire::Swaig::FunctionResult.new('ok')")} end diff --git a/tests/swaig_token_enforcement_test.rb b/tests/swaig_token_enforcement_test.rb new file mode 100644 index 00000000..9d7b1ba0 --- /dev/null +++ b/tests/swaig_token_enforcement_test.rb @@ -0,0 +1,218 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'base64' +require 'json' +require 'rack' + +ENV['SIGNALWIRE_LOG_MODE'] = 'off' + +require_relative '../lib/signalwire' + +# SWAIG `secure` enforcement — the transport-agnostic token contract. +# +# A tool registered with `secure: true` (define_tool's default) REQUIRES a valid +# per-call `__token`. Absent, forged, or unvalidatable => REFUSE. This holds on +# EVERY transport, not just HTTP: +# +# valid token -> handler RUNS, not refused, 200 +# forged token -> handler does NOT run, REFUSED, 200 + FunctionResult body +# absent token -> handler does NOT run, REFUSED (fail-CLOSED) +# call_id absent-> REFUSED (a token can only be validated against a call_id, +# so a missing one counts as unvalidated, never a bypass) +# insecure tool -> RUNS ungated in ALL of the above +# +# The refusal is a 200 + FunctionResult body, NOT an HTTP error status: the +# engine (mod_openai) has no handling for a SWAIG refusal status, so the tool +# reports it cannot execute and the model relays it. +# +# WHERE THE CREDENTIAL RIDES: the token rides the QUERY STRING (`__token`), the +# call_id rides the POST BODY (`call_id`). That split is identical on both +# transports -- ruby's serverless adapters translate the invocation event into a +# Rack env, so `queryStringParameters` becomes `QUERY_STRING` and the same +# `swaig_pre_dispatch` hook runs. + +# The fixture agent plus one driver per transport. Both drivers take the SAME +# (function, token, call_id) triple and return the same [status, parsed-body] +# pair, so every case below runs identically on HTTP and on serverless — a green +# HTTP suite proving nothing about serverless is exactly the hole this closes. +module SwaigTokenTransports + USER = 'user' + PASSWORD = 'pass' + CALL_ID = 'call-token-enforcement' + RAN = 'handler ran' + REFUSAL_MARK = 'security token' + + def build_agent + agent = SignalWire::AgentBase.new(name: 'tok', route: '/', basic_auth: [USER, PASSWORD]) + agent.define_tool(name: 'sec_tool', description: 'secure', parameters: {}, handler: nil) do |_a, _r| + SignalWire::Swaig::FunctionResult.new(RAN) + end + agent.define_tool(name: 'open_tool', description: 'insecure', parameters: {}, + secure: false, handler: nil) do |_a, _r| + SignalWire::Swaig::FunctionResult.new(RAN) + end + agent + end + + def basic_auth + "Basic #{Base64.strict_encode64("#{USER}:#{PASSWORD}")}" + end + + def swaig_body(func, call_id: CALL_ID) + body = { 'function' => func, 'argument' => { 'parsed' => [{}] } } + body['call_id'] = call_id if call_id + JSON.generate(body) + end + + # --- transport drivers ------------------------------------------------ + + # Rack env keys that do not vary between cases. + STATIC_ENV = { + 'REQUEST_METHOD' => 'POST', 'PATH_INFO' => '/swaig', 'SCRIPT_NAME' => '', + 'SERVER_NAME' => 'localhost', 'SERVER_PORT' => '3000', + 'SERVER_PROTOCOL' => 'HTTP/1.1', 'rack.url_scheme' => 'http', + 'CONTENT_TYPE' => 'application/json' + }.freeze + + # HTTP: drive the served Rack app directly (the path a real POST /swaig takes). + def http_call(agent, func, token: nil, call_id: CALL_ID) + body = swaig_body(func, call_id: call_id) + env = STATIC_ENV.merge( + 'QUERY_STRING' => token ? "__token=#{Rack::Utils.escape(token)}" : '', + 'CONTENT_LENGTH' => body.bytesize.to_s, 'HTTP_AUTHORIZATION' => basic_auth, + 'rack.input' => StringIO.new(body), 'rack.errors' => $stderr + ) + status, _headers, out = agent.rack_app.call(env) + [status, JSON.parse(Array(out).join)] + end + + # Serverless (lambda): drive the real lambda adapter, token in the parsed + # queryStringParameters map exactly as API Gateway delivers it. + def lambda_call(agent, func, token: nil, call_id: CALL_ID) + event = { + 'version' => '2.0', 'rawPath' => '/swaig', + 'headers' => { 'authorization' => basic_auth, 'content-type' => 'application/json' }, + 'requestContext' => { 'http' => { 'method' => 'POST' } }, + 'body' => swaig_body(func, call_id: call_id) + } + event['queryStringParameters'] = { '__token' => token } if token + resp = agent.handle_serverless_request(event: event, mode: 'lambda') + [resp['statusCode'], JSON.parse(resp['body'])] + end + + TRANSPORTS = { 'http' => :http_call, 'lambda' => :lambda_call }.freeze + + def each_transport(&) + TRANSPORTS.each(&) + end +end + +class SwaigTokenEnforcementTest < Minitest::Test + include SwaigTokenTransports + + def assert_ran(status, body, transport, why) + assert_equal 200, status, "#{transport}: #{why} — must be 200" + assert_equal RAN, body['response'], "#{transport}: #{why} — the handler MUST have run" + end + + def assert_refused(status, body, transport, why) + assert_equal 200, status, + "#{transport}: #{why} — a SWAIG refusal is a 200 + FunctionResult body, not an HTTP error" + refute_equal RAN, body['response'], "#{transport}: #{why} — the handler MUST NOT have run" + assert_includes body['response'].to_s, REFUSAL_MARK, + "#{transport}: #{why} — the refusal must be the security-token FunctionResult" + end + + # --- secure tool: the four token cases, per transport ----------------- + + def test_secure_tool_valid_token_runs + each_transport do |name, driver| + agent = build_agent + token = agent.create_tool_token('sec_tool', CALL_ID) + status, body = send(driver, agent, 'sec_tool', token: token) + + assert_ran(status, body, name, 'valid token') + end + end + + def test_secure_tool_forged_token_refused + each_transport do |name, driver| + agent = build_agent + status, body = send(driver, agent, 'sec_tool', token: 'not-a-real-token') + + assert_refused(status, body, name, 'forged token') + end + end + + def test_secure_tool_absent_token_refused + each_transport do |name, driver| + agent = build_agent + status, body = send(driver, agent, 'sec_tool', token: nil) + + assert_refused(status, body, name, 'absent token (must fail CLOSED)') + end + end + + def test_secure_tool_absent_call_id_refused + each_transport do |name, driver| + agent = build_agent + token = agent.create_tool_token('sec_tool', CALL_ID) + status, body = send(driver, agent, 'sec_tool', token: token, call_id: nil) + + assert_refused(status, body, name, 'valid token but NO call_id') + end + end + + # A token minted for a DIFFERENT call must not unlock this call. + def test_secure_tool_token_for_other_call_refused + each_transport do |name, driver| + agent = build_agent + token = agent.create_tool_token('sec_tool', 'some-other-call') + status, body = send(driver, agent, 'sec_tool', token: token) + + assert_refused(status, body, name, "another call's token") + end + end + + # A token minted for a DIFFERENT function must not unlock this function. + def test_secure_tool_token_for_other_function_refused + each_transport do |name, driver| + agent = build_agent + token = agent.create_tool_token('open_tool', CALL_ID) + status, body = send(driver, agent, 'sec_tool', token: token) + + assert_refused(status, body, name, "another function's token") + end + end + + # --- insecure tool: runs ungated in every case ------------------------ + + INSECURE_CASES = { + 'valid token' => :valid, 'forged token' => :forged, + 'absent token' => :absent, 'no call_id' => :no_call_id + }.freeze + + def test_insecure_tool_runs_ungated + each_transport do |name, driver| + INSECURE_CASES.each { |why, kind| assert_insecure_runs(name, driver, why, kind) } + end + end + + def assert_insecure_runs(name, driver, why, kind) + agent = build_agent + token, call_id = insecure_case_args(agent, kind) + status, body = send(driver, agent, 'open_tool', token: token, call_id: call_id) + + assert_ran(status, body, name, "insecure tool, #{why}") + end + + def insecure_case_args(agent, kind) + case kind + when :valid then [agent.create_tool_token('open_tool', CALL_ID), CALL_ID] + when :forged then ['not-a-real-token', CALL_ID] + when :absent then [nil, CALL_ID] + when :no_call_id then [nil, nil] + end + end +end From b6290e6004ba4479e25281e8bcc84e036cef5ad1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 02:49:54 -0400 Subject: [PATCH 53/90] test(http-dump): implement the pending serverless valid-token fixture `http_serverless_lambda_swaig_valid_token` (porting-sdk 5258778) had been registering as PENDING in ruby's dump, so the positive half of the serverless token contract was unproven here. Its negative sibling only shows that SOMETHING refuses; a port that refused everything without ever validating would have sailed through on that fixture alone. The case is identical to `http_serverless_lambda_swaig` in every respect except the lambda query string, which carries a genuinely minted `__token`. The token is HMAC-signed by the agent's own per-process SessionManager secret and expires, so it is minted from the SAME agent instance the case drives -- a corpus literal could never be valid. It rides `queryStringParameters`; the call_id rides the POST body. BEHAVIORAL-HTTP now runs 15 cases with none pending. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/http-dump | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/bin/http-dump b/bin/http-dump index cba87bb4..40303348 100755 --- a/bin/http-dump +++ b/bin/http-dump @@ -122,18 +122,39 @@ end # agent is built at route "/" so the event's root-relative "/swaig" path routes # correctly — matching Python's serverless dispatch, which treats rawPath as # agent-relative (the Go reference does the same). -def serverless_swaig +def serverless_swaig_agent a = SignalWire::AgentBase.new(name: 'demo', route: '/', basic_auth: [USER, PASSWORD]) a.define_tool(name: 'say_hello', description: 'greet', parameters: {}, handler: nil) do |_args, _raw| SignalWire::Swaig::FunctionResult.new('hello there') end - event = { + a +end + +def serverless_swaig_event + { 'version' => '2.0', 'rawPath' => '/swaig', 'headers' => { 'authorization' => basic_auth(USER, PASSWORD), 'content-type' => 'application/json' }, 'requestContext' => { 'http' => { 'method' => 'POST' } }, 'body' => '{"function":"say_hello","argument":{"parsed":[{}]},"call_id":"c1"}' } +end + +def serverless_swaig + a = serverless_swaig_agent + reduce_lambda(a.handle_serverless_request(event: serverless_swaig_event, mode: 'lambda')) +end + +# The POSITIVE half of the serverless token contract: identical to +# +serverless_swaig+ except that the lambda query string carries a GENUINELY +# MINTED __token, so the secure tool RUNS. The token is HMAC-signed by the +# agent's own per-process SessionManager secret and expires, so it can only be +# minted from the SAME agent instance the case drives — never a corpus literal. +# It rides the query string; the call_id rides the POST body. +def serverless_swaig_valid_token + a = serverless_swaig_agent + event = serverless_swaig_event + event['queryStringParameters'] = { '__token' => a.create_tool_token('say_hello', 'c1') } reduce_lambda(a.handle_serverless_request(event: event, mode: 'lambda')) end @@ -205,6 +226,7 @@ out['http_webhook_validate_twilio_alias'] = webhook_decision( # ---- serverless (lambda) ---- out['http_serverless_lambda_swaig'] = serverless_swaig +out['http_serverless_lambda_swaig_valid_token'] = serverless_swaig_valid_token out['http_serverless_lambda_noauth_401'] = serverless_noauth REAL_STDOUT.puts(JSON.generate(out)) From 2d9190dc225d05ce7f485ad56d0b4cd2c303a0a5 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 02:50:20 -0400 Subject: [PATCH 54/90] ci: wire the SIGNATURES-FRESH gate SURFACE-FRESH regenerates port_surface.json and fails on a stale committed blob. Nothing did the same for port_signatures.json -- and that file is DRIFT's INPUT, so a stale one leaves the parity gate comparing against a fiction and passing. Standalone `sched_gate` rather than a `_surface_commands.py` table entry: only 8 of the 10 run-ci scripts read that table, so a table entry is silently skipped in the two that do not. `res=surface` shares the mutex with SURFACE, which regenerates port_signatures.json in place and git-restores it. The gate is not vacuous here: it went RED on this branch the moment the SWAIG token fix added methods to AgentBase, naming each drifted param, and went FRESH once those methods were correctly declared private (matching the reference's underscore-private originals) so they added no surface. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- scripts/run-ci.sh | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index 275354c1..7a44efad 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -116,6 +116,17 @@ sched_gate TEST defer=1 desc="run-tests.sh (bundle exec rake test)" \ sched_gate SURFACE desc="surface parity suite (SIGNATURES/DRIFT/SURFACE-FRESH/SURFACE-DIFF/SEMVER-DIFF/GEN-TYPE-DEGENERACY/GEN-IDIOM)" \ -- python3 "$PORTING_SDK_DIR/scripts/suites/surface.py" --port ruby --repo "$PORT_ROOT" +# SIGNATURES-FRESH: the signatures analogue of SURFACE-FRESH. SURFACE-FRESH only +# guards port_surface.json; NOTHING guarded port_signatures.json — yet that file is +# DRIFT's INPUT, so a stale one makes the parity gate compare against a fiction and +# pass. Standalone sched_gate rather than a _surface_commands.py table entry: only 8 +# of 10 run-ci scripts read that table, so a table entry is silently skipped where it +# is not read. res=surface shares the mutex with SURFACE, which regenerates +# port_signatures.json in place and git-restores it. +sched_gate SIGNATURES-FRESH res=surface desc="committed port_signatures.json matches a fresh regen" \ + -- python3 "$PORTING_SDK_DIR/scripts/suites/_signatures_fresh.py" \ + --port ruby --repo "$PORT_ROOT" --porting-sdk "$PORTING_SDK_DIR" + # TYPE-EROSION: a port may not erase a type the reference DECLARES. compare_param treats # `any` on EITHER side as matching anything, so a port emitting `any` silently satisfies # every reference declaration — an unlimited opt-out. ConciergeAgent.hours_of_operation is From e8ce35be91a2f539e6a80c12e00c56d707c6295c Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 03:13:48 -0400 Subject: [PATCH 55/90] docs(generated): state what a generated DTO IS, not how it was ported MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ~3,000 generated REST/SWML/RELAY/SWAIG doc comments shipped internal porting vocabulary to Ruby developers: "the reference records this as a method-less type definition, so the surface enumerator surfaces the bare class name", "A zero-arg reader per field mirrors the reference's recorded accessors", "records [] like the reference", plus dangling `(§8)` / `§2` cross-references into porting-sdk's REST_GENERATOR_RULES.md that resolve to nothing in a published YARD page. None of that describes the code. Each template now states the fact plainly: - "the reference records this as a method-less type definition, so the surface enumerator surfaces the bare class name" -> "the class is a bare namespace for its FIELDS map, describing the wire shape rather than wrapping a payload." - "A zero-arg reader per field mirrors the reference's recorded accessors (dropped on the SURFACE by the enumerator ...)" -> "Each field also has a zero-arg reader, so a decoded payload can be accessed by name rather than by wire key." Six templates in scripts/generate_rest.py, regenerated in place. No generated file was hand-edited. `emit_methodless_class` turned out NOT to be REST-only: it is a shared helper imported as `GR.` by generate_relay_protocol.py, generate_swaig_payloads.py and generate_swml_verbs.py, and generate_rest.py never calls it itself. Editing that one template therefore required regenerating four trees, not one, which is why this commit spans lib/signalwire/core/** and lib/signalwire/relay/** as well as the REST namespaces. Regenerated: 779 REST files + 158 SWML-verb + 123 RELAY-protocol + 20 SWAIG-payload = 1080 files, all doc-only (filtering comment lines out of `git diff -U0` leaves nothing). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- .../core/post_prompt_generated/post_prompt.rb | 4 ++-- .../post_prompt_assistant_entry.rb | 4 ++-- .../post_prompt_generated/post_prompt_data.rb | 4 ++-- .../post_prompt_entity.rb | 4 ++-- .../post_prompt_generated/post_prompt_eot.rb | 4 ++-- .../post_prompt_stamps_us.rb | 4 ++-- .../post_prompt_swaig_log_entry.rb | 4 ++-- .../post_prompt_system_entry.rb | 4 ++-- .../post_prompt_system_log_entry.rb | 4 ++-- .../post_prompt_thinking_entry.rb | 4 ++-- .../post_prompt_times_entry.rb | 4 ++-- .../post_prompt_timing.rb | 4 ++-- .../post_prompt_tool_entry.rb | 4 ++-- .../post_prompt_user_entry.rb | 4 ++-- .../context_switch_action.rb | 4 ++-- .../swaig_actions_generated/hold_action.rb | 4 ++-- .../playback_bg_action.rb | 4 ++-- .../transfer_action.rb | 4 ++-- .../swaig_request_generated/swaig_argument.rb | 4 ++-- .../swaig_request_generated/swaig_request.rb | 4 ++-- .../core/swml_verbs_generated/a_i.rb | 4 ++-- .../core/swml_verbs_generated/a_i_object.rb | 4 ++-- .../core/swml_verbs_generated/a_i_params.rb | 4 ++-- .../a_i_post_prompt_pom.rb | 4 ++-- .../a_i_post_prompt_text.rb | 4 ++-- .../swml_verbs_generated/a_i_prompt_pom.rb | 4 ++-- .../swml_verbs_generated/a_i_prompt_text.rb | 4 ++-- .../core/swml_verbs_generated/ai_sidecar.rb | 4 ++-- .../swml_verbs_generated/ai_sidecar_config.rb | 4 ++-- .../swml_verbs_generated/all_of_property.rb | 4 ++-- .../swml_verbs_generated/amazon_bedrock.rb | 4 ++-- .../amazon_bedrock_object.rb | 4 ++-- .../core/swml_verbs_generated/answer.rb | 4 ++-- .../swml_verbs_generated/any_of_property.rb | 4 ++-- .../swml_verbs_generated/array_property.rb | 4 ++-- .../swml_verbs_generated/bedrock_params.rb | 4 ++-- .../swml_verbs_generated/bedrock_s_w_a_i_g.rb | 4 ++-- .../swml_verbs_generated/boolean_property.rb | 4 ++-- .../change_context_action.rb | 4 ++-- .../change_step_action.rb | 4 ++-- .../core/swml_verbs_generated/cond.rb | 4 ++-- .../core/swml_verbs_generated/cond_else.rb | 4 ++-- .../core/swml_verbs_generated/cond_reg.rb | 4 ++-- .../core/swml_verbs_generated/connect.rb | 4 ++-- .../swml_verbs_generated/connect_config.rb | 4 ++-- .../connect_device_parallel.rb | 4 ++-- .../connect_device_serial.rb | 4 ++-- .../connect_device_serial_parallel.rb | 4 ++-- .../connect_device_single.rb | 4 ++-- .../swml_verbs_generated/connect_headers.rb | 4 ++-- .../swml_verbs_generated/connect_switch.rb | 4 ++-- .../swml_verbs_generated/const_property.rb | 4 ++-- .../context_p_o_m_steps.rb | 4 ++-- .../context_switch_action.rb | 4 ++-- .../context_text_steps.rb | 4 ++-- .../core/swml_verbs_generated/contexts.rb | 4 ++-- .../contexts_p_o_m_object.rb | 4 ++-- .../contexts_text_object.rb | 4 ++-- .../conversation_message.rb | 4 ++-- .../core/swml_verbs_generated/data_map.rb | 4 ++-- .../core/swml_verbs_generated/denoise.rb | 4 ++-- .../swml_verbs_generated/detect_machine.rb | 4 ++-- .../detect_machine_config.rb | 4 ++-- .../core/swml_verbs_generated/enter_queue.rb | 4 ++-- .../enter_queue_object.rb | 4 ++-- .../core/swml_verbs_generated/execute.rb | 4 ++-- .../swml_verbs_generated/execute_config.rb | 4 ++-- .../swml_verbs_generated/execute_switch.rb | 4 ++-- .../core/swml_verbs_generated/expression.rb | 4 ++-- .../function_parameters.rb | 4 ++-- .../core/swml_verbs_generated/goto.rb | 4 ++-- .../core/swml_verbs_generated/goto_config.rb | 4 ++-- .../hang_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../core/swml_verbs_generated/hangup.rb | 4 ++-- .../swml_verbs_generated/hangup_action.rb | 4 ++-- .../core/swml_verbs_generated/hint.rb | 4 ++-- .../core/swml_verbs_generated/hold_action.rb | 4 ++-- .../swml_verbs_generated/inject_action.rb | 4 ++-- .../swml_verbs_generated/integer_property.rb | 4 ++-- .../swml_verbs_generated/join_conference.rb | 4 ++-- .../join_conference_object.rb | 4 ++-- .../core/swml_verbs_generated/join_room.rb | 4 ++-- .../swml_verbs_generated/join_room_config.rb | 4 ++-- .../core/swml_verbs_generated/label.rb | 4 ++-- .../swml_verbs_generated/language_params.rb | 4 ++-- .../languages_with_fillers.rb | 4 ++-- .../languages_with_solo_fillers.rb | 4 ++-- .../swml_verbs_generated/live_transcribe.rb | 4 ++-- .../live_transcribe_config.rb | 4 ++-- .../swml_verbs_generated/live_translate.rb | 4 ++-- .../live_translate_config.rb | 4 ++-- .../swml_verbs_generated/null_property.rb | 4 ++-- .../swml_verbs_generated/number_property.rb | 4 ++-- .../swml_verbs_generated/object_property.rb | 4 ++-- ...ck_post_pompt_text_omitted_prompt_props.rb | 4 ++-- ...ck_post_prompt_pom_omitted_prompt_props.rb | 4 ++-- ...bedrock_prompt_pom_omitted_prompt_props.rb | 4 ++-- ...edrock_prompt_text_omitted_prompt_props.rb | 4 ++-- .../swml_verbs_generated/one_of_property.rb | 4 ++-- .../core/swml_verbs_generated/output.rb | 4 ++-- .../core/swml_verbs_generated/pay.rb | 4 ++-- .../core/swml_verbs_generated/pay_config.rb | 4 ++-- .../swml_verbs_generated/pay_parameters.rb | 4 ++-- .../pay_prompt_play_action.rb | 4 ++-- .../pay_prompt_say_action.rb | 4 ++-- .../core/swml_verbs_generated/pay_prompts.rb | 4 ++-- ...unction_picked_s_w_a_i_g_function_props.rb | 4 ++-- ...unction_picked_s_w_a_i_g_function_props.rb | 4 ++-- ...unction_picked_s_w_a_i_g_function_props.rb | 4 ++-- ...unction_picked_s_w_a_i_g_function_props.rb | 4 ++-- .../core/swml_verbs_generated/play.rb | 4 ++-- .../swml_verbs_generated/play_with_u_r_l.rb | 4 ++-- .../swml_verbs_generated/play_with_u_r_l_s.rb | 4 ++-- .../playback_b_g_action.rb | 4 ++-- .../pom_section_body_content.rb | 4 ++-- .../pom_section_bullets_content.rb | 4 ++-- .../core/swml_verbs_generated/prompt.rb | 4 ++-- .../swml_verbs_generated/prompt_config.rb | 4 ++-- .../core/swml_verbs_generated/pronounce.rb | 4 ++-- .../core/swml_verbs_generated/receive_fax.rb | 4 ++-- .../receive_fax_config.rb | 4 ++-- .../core/swml_verbs_generated/record.rb | 4 ++-- .../core/swml_verbs_generated/record_call.rb | 4 ++-- .../record_call_config.rb | 4 ++-- .../swml_verbs_generated/record_config.rb | 4 ++-- .../core/swml_verbs_generated/request.rb | 4 ++-- .../swml_verbs_generated/request_config.rb | 4 ++-- .../core/swml_verbs_generated/return.rb | 4 ++-- .../swml_verbs_generated/ringback_config.rb | 4 ++-- .../core/swml_verbs_generated/s_i_p_refer.rb | 4 ++-- .../swml_verbs_generated/s_m_s_with_body.rb | 4 ++-- .../swml_verbs_generated/s_m_s_with_media.rb | 4 ++-- .../core/swml_verbs_generated/s_w_a_i_g.rb | 4 ++-- .../s_w_a_i_g_defaults.rb | 4 ++-- .../s_w_a_i_g_includes.rb | 4 ++-- .../s_w_a_i_g_internal_filler.rb | 4 ++-- .../swml_verbs_generated/s_w_m_l_action.rb | 4 ++-- .../core/swml_verbs_generated/say_action.rb | 4 ++-- .../core/swml_verbs_generated/section.rb | 4 ++-- .../core/swml_verbs_generated/send_digits.rb | 4 ++-- .../send_digits_config.rb | 4 ++-- .../core/swml_verbs_generated/send_fax.rb | 4 ++-- .../swml_verbs_generated/send_fax_config.rb | 4 ++-- .../core/swml_verbs_generated/send_s_m_s.rb | 4 ++-- .../core/swml_verbs_generated/set.rb | 4 ++-- .../set_global_data_action.rb | 4 ++-- .../set_meta_data_action.rb | 4 ++-- .../swml_verbs_generated/sip_refer_config.rb | 4 ++-- .../core/swml_verbs_generated/sleep.rb | 4 ++-- .../core/swml_verbs_generated/start_action.rb | 4 ++-- .../start_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../core/swml_verbs_generated/stop_action.rb | 4 ++-- .../core/swml_verbs_generated/stop_denoise.rb | 4 ++-- .../stop_playback_b_g_action.rb | 4 ++-- .../swml_verbs_generated/stop_record_call.rb | 4 ++-- .../stop_record_call_config.rb | 4 ++-- .../core/swml_verbs_generated/stop_tap.rb | 4 ++-- .../swml_verbs_generated/stop_tap_config.rb | 4 ++-- .../swml_verbs_generated/string_property.rb | 4 ++-- .../swml_verbs_generated/summarize_action.rb | 4 ++-- ...mmarize_conversation_s_w_a_i_g_function.rb | 4 ++-- .../core/swml_verbs_generated/switch.rb | 4 ++-- .../swml_verbs_generated/switch_config.rb | 4 ++-- .../core/swml_verbs_generated/tap.rb | 4 ++-- .../core/swml_verbs_generated/tap_config.rb | 4 ++-- .../toggle_functions_action.rb | 4 ++-- .../transcribe_start_action.rb | 4 ++-- .../transcribe_summarize_action.rb | 4 ++-- .../core/swml_verbs_generated/transfer.rb | 4 ++-- .../swml_verbs_generated/transfer_config.rb | 4 ++-- .../core/swml_verbs_generated/unset.rb | 4 ++-- .../unset_global_data_action.rb | 4 ++-- .../unset_meta_data_action.rb | 4 ++-- .../core/swml_verbs_generated/user_event.rb | 4 ++-- .../swml_verbs_generated/user_event_config.rb | 4 ++-- .../swml_verbs_generated/user_input_action.rb | 4 ++-- .../user_s_w_a_i_g_function.rb | 4 ++-- .../core/swml_verbs_generated/webhook.rb | 4 ++-- .../calling_ai_hold_params.rb | 4 ++-- .../calling_ai_hold_result.rb | 4 ++-- .../calling_ai_message_params.rb | 4 ++-- .../calling_ai_message_result.rb | 4 ++-- .../calling_ai_unhold_params.rb | 4 ++-- .../calling_ai_unhold_result.rb | 4 ++-- .../calling_amazon_bedrock_params.rb | 4 ++-- .../calling_amazon_bedrock_result.rb | 4 ++-- .../calling_answer_params.rb | 4 ++-- .../calling_answer_result.rb | 4 ++-- .../calling_begin_params.rb | 4 ++-- .../calling_begin_result.rb | 4 ++-- .../calling_bind_digit_params.rb | 4 ++-- .../calling_bind_digit_result.rb | 4 ++-- .../calling_clear_digit_bindings_params.rb | 4 ++-- .../calling_clear_digit_bindings_result.rb | 4 ++-- .../calling_collect_params.rb | 4 ++-- .../calling_collect_result.rb | 4 ++-- ...lling_collect_start_input_timers_params.rb | 4 ++-- ...lling_collect_start_input_timers_result.rb | 4 ++-- .../calling_collect_stop_params.rb | 4 ++-- .../calling_collect_stop_result.rb | 4 ++-- .../calling_connect_params.rb | 4 ++-- .../calling_connect_result.rb | 4 ++-- .../calling_denoise_params.rb | 4 ++-- .../calling_denoise_result.rb | 4 ++-- .../calling_denoise_stop_params.rb | 4 ++-- .../calling_denoise_stop_result.rb | 4 ++-- .../calling_detect_params.rb | 4 ++-- .../calling_detect_result.rb | 4 ++-- .../calling_detect_stop_params.rb | 4 ++-- .../calling_detect_stop_result.rb | 4 ++-- .../calling_dial_params.rb | 4 ++-- .../calling_dial_result.rb | 4 ++-- .../calling_disconnect_params.rb | 4 ++-- .../calling_disconnect_result.rb | 4 ++-- .../calling_echo_params.rb | 4 ++-- .../calling_echo_result.rb | 4 ++-- .../calling_end_params.rb | 4 ++-- .../calling_end_result.rb | 4 ++-- .../calling_join_conference_params.rb | 4 ++-- .../calling_join_conference_result.rb | 4 ++-- .../calling_join_room_params.rb | 4 ++-- .../calling_join_room_result.rb | 4 ++-- .../calling_leave_conference_params.rb | 4 ++-- .../calling_leave_conference_result.rb | 4 ++-- .../calling_leave_room_params.rb | 4 ++-- .../calling_leave_room_result.rb | 4 ++-- .../calling_live_transcribe_params.rb | 4 ++-- .../calling_live_transcribe_result.rb | 4 ++-- .../calling_live_translate_params.rb | 4 ++-- .../calling_live_translate_result.rb | 4 ++-- .../calling_pass_params.rb | 4 ++-- .../calling_pass_result.rb | 4 ++-- .../calling_pay_params.rb | 4 ++-- .../calling_pay_result.rb | 4 ++-- .../calling_pay_stop_params.rb | 4 ++-- .../calling_pay_stop_result.rb | 4 ++-- .../calling_play_and_collect_params.rb | 4 ++-- .../calling_play_and_collect_result.rb | 4 ++-- .../calling_play_and_collect_stop_params.rb | 4 ++-- .../calling_play_and_collect_stop_result.rb | 4 ++-- .../calling_play_and_collect_volume_params.rb | 4 ++-- .../calling_play_and_collect_volume_result.rb | 4 ++-- .../calling_play_params.rb | 4 ++-- .../calling_play_pause_params.rb | 4 ++-- .../calling_play_pause_result.rb | 4 ++-- .../calling_play_result.rb | 4 ++-- .../calling_play_resume_params.rb | 4 ++-- .../calling_play_resume_result.rb | 4 ++-- .../calling_play_stop_params.rb | 4 ++-- .../calling_play_stop_result.rb | 4 ++-- .../calling_play_volume_params.rb | 4 ++-- .../calling_play_volume_result.rb | 4 ++-- .../calling_queue_enter_params.rb | 4 ++-- .../calling_queue_enter_result.rb | 4 ++-- .../calling_queue_leave_params.rb | 4 ++-- .../calling_queue_leave_result.rb | 4 ++-- .../calling_receive_fax_params.rb | 4 ++-- .../calling_receive_fax_result.rb | 4 ++-- .../calling_receive_fax_stop_params.rb | 4 ++-- .../calling_receive_fax_stop_result.rb | 4 ++-- .../calling_receive_params.rb | 4 ++-- .../calling_receive_result.rb | 4 ++-- .../calling_record_params.rb | 4 ++-- .../calling_record_pause_params.rb | 4 ++-- .../calling_record_pause_result.rb | 4 ++-- .../calling_record_result.rb | 4 ++-- .../calling_record_resume_params.rb | 4 ++-- .../calling_record_resume_result.rb | 4 ++-- .../calling_record_stop_params.rb | 4 ++-- .../calling_record_stop_result.rb | 4 ++-- .../calling_refer_params.rb | 4 ++-- .../calling_refer_result.rb | 4 ++-- .../calling_send_digits_params.rb | 4 ++-- .../calling_send_digits_result.rb | 4 ++-- .../calling_send_fax_params.rb | 4 ++-- .../calling_send_fax_result.rb | 4 ++-- .../calling_send_fax_stop_params.rb | 4 ++-- .../calling_send_fax_stop_result.rb | 4 ++-- .../calling_stream_params.rb | 4 ++-- .../calling_stream_result.rb | 4 ++-- .../calling_stream_stop_params.rb | 4 ++-- .../calling_stream_stop_result.rb | 4 ++-- .../calling_tap_params.rb | 4 ++-- .../calling_tap_result.rb | 4 ++-- .../calling_tap_stop_params.rb | 4 ++-- .../calling_tap_stop_result.rb | 4 ++-- .../calling_transfer_params.rb | 4 ++-- .../calling_transfer_result.rb | 4 ++-- .../calling_user_event_params.rb | 4 ++-- .../calling_user_event_result.rb | 4 ++-- .../messaging_send_params.rb | 4 ++-- .../messaging_send_result.rb | 4 ++-- .../signalwire_connect_params.rb | 4 ++-- .../signalwire_connect_result.rb | 4 ++-- .../signalwire_disconnect_params.rb | 4 ++-- .../signalwire_execute_params.rb | 4 ++-- .../signalwire_execute_result.rb | 4 ++-- .../signalwire_ping_params.rb | 4 ++-- .../signalwire_ping_result.rb | 4 ++-- .../signalwire_reauthenticate_params.rb | 4 ++-- .../signalwire_reauthenticate_result.rb | 4 ++-- .../namespaces/generated/_fabric_bases.rb | 2 +- .../generated/datasphere_namespace.rb | 5 ++-- .../namespaces/generated/fabric_namespace.rb | 5 ++-- .../namespaces/generated/logs_namespace.rb | 5 ++-- .../namespaces/generated/project_namespace.rb | 5 ++-- .../generated/registry_namespace.rb | 5 ++-- .../namespaces/generated/resource_tree.rb | 2 +- .../namespaces/generated/types/calling/a_i.rb | 4 ++-- .../generated/types/calling/a_i_object.rb | 4 ++-- .../generated/types/calling/a_i_params.rb | 4 ++-- .../types/calling/a_i_post_prompt_pom.rb | 4 ++-- .../types/calling/a_i_post_prompt_text.rb | 4 ++-- .../generated/types/calling/a_i_prompt_pom.rb | 4 ++-- .../types/calling/a_i_prompt_text.rb | 4 ++-- .../types/calling/all_of_property.rb | 4 ++-- .../generated/types/calling/amazon_bedrock.rb | 4 ++-- .../types/calling/amazon_bedrock_object.rb | 4 ++-- .../generated/types/calling/answer.rb | 4 ++-- .../types/calling/any_of_property.rb | 4 ++-- .../generated/types/calling/array_property.rb | 4 ++-- .../generated/types/calling/bedrock_params.rb | 4 ++-- .../types/calling/bedrock_s_w_a_i_g.rb | 4 ++-- .../types/calling/boolean_property.rb | 4 ++-- .../types/calling/call_a_i_message_request.rb | 4 ++-- .../calling/call_a_i_message_reset_params.rb | 4 ++-- .../types/calling/call_a_i_stop_request.rb | 4 ++-- .../types/calling/call_collect_request.rb | 4 ++-- ...call_collect_start_input_timers_request.rb | 4 ++-- .../calling/call_collect_stop_request.rb | 4 ++-- .../types/calling/call_create422_error.rb | 4 ++-- .../calling/call_create_params_s_w_m_l.rb | 4 ++-- .../types/calling/call_create_params_u_r_l.rb | 4 ++-- .../types/calling/call_create_request.rb | 4 ++-- .../types/calling/call_denoise_request.rb | 4 ++-- .../calling/call_denoise_stop_request.rb | 4 ++-- .../types/calling/call_detect_request.rb | 4 ++-- .../types/calling/call_detect_stop_request.rb | 4 ++-- .../types/calling/call_disconnect_request.rb | 4 ++-- .../types/calling/call_hangup_request.rb | 4 ++-- .../types/calling/call_hold_request.rb | 4 ++-- .../generated/types/calling/call_leg.rb | 4 ++-- .../calling/call_live_transcribe_request.rb | 4 ++-- .../calling/call_live_translate_request.rb | 4 ++-- .../types/calling/call_play_pause_request.rb | 4 ++-- .../types/calling/call_play_request.rb | 4 ++-- .../types/calling/call_play_resume_request.rb | 4 ++-- .../types/calling/call_play_stop_request.rb | 4 ++-- .../types/calling/call_play_volume_request.rb | 4 ++-- .../calling/call_receive_fax_stop_request.rb | 4 ++-- .../calling/call_record_pause_request.rb | 4 ++-- .../types/calling/call_record_request.rb | 4 ++-- .../calling/call_record_resume_request.rb | 4 ++-- .../types/calling/call_record_stop_request.rb | 4 ++-- .../types/calling/call_refer_request.rb | 4 ++-- .../calling/call_send_fax_stop_request.rb | 4 ++-- .../types/calling/call_stream_request.rb | 4 ++-- .../types/calling/call_stream_stop_request.rb | 4 ++-- .../types/calling/call_tap_request.rb | 4 ++-- .../types/calling/call_tap_stop_request.rb | 4 ++-- .../types/calling/call_transcribe_request.rb | 4 ++-- .../calling/call_transcribe_stop_request.rb | 4 ++-- .../types/calling/call_transfer_request.rb | 4 ++-- .../types/calling/call_unhold_request.rb | 4 ++-- .../call_update_current_call_request.rb | 4 ++-- .../calling/call_update_params_s_w_m_l.rb | 4 ++-- .../types/calling/call_update_params_u_r_l.rb | 4 ++-- .../types/calling/call_user_event_request.rb | 4 ++-- .../types/calling/change_context_action.rb | 4 ++-- .../types/calling/change_step_action.rb | 4 ++-- .../generated/types/calling/charge_details.rb | 4 ++-- .../generated/types/calling/cond.rb | 4 ++-- .../generated/types/calling/cond_else.rb | 4 ++-- .../generated/types/calling/cond_reg.rb | 4 ++-- .../generated/types/calling/connect.rb | 4 ++-- .../types/calling/connect_device_parallel.rb | 4 ++-- .../types/calling/connect_device_serial.rb | 4 ++-- .../calling/connect_device_serial_parallel.rb | 4 ++-- .../types/calling/connect_device_single.rb | 4 ++-- .../types/calling/connect_headers.rb | 4 ++-- .../generated/types/calling/connect_switch.rb | 4 ++-- .../generated/types/calling/const_property.rb | 4 ++-- .../types/calling/context_p_o_m_steps.rb | 4 ++-- .../types/calling/context_switch_action.rb | 4 ++-- .../types/calling/context_text_steps.rb | 4 ++-- .../generated/types/calling/contexts.rb | 4 ++-- .../types/calling/contexts_p_o_m_object.rb | 4 ++-- .../types/calling/contexts_text_object.rb | 4 ++-- .../types/calling/conversation_message.rb | 4 ++-- .../generated/types/calling/data_map.rb | 4 ++-- .../generated/types/calling/denoise.rb | 4 ++-- .../generated/types/calling/detect_machine.rb | 4 ++-- .../generated/types/calling/enter_queue.rb | 4 ++-- .../types/calling/enter_queue_object.rb | 4 ++-- .../generated/types/calling/execute.rb | 4 ++-- .../generated/types/calling/execute_switch.rb | 4 ++-- .../generated/types/calling/expression.rb | 4 ++-- .../types/calling/fabric_device_leg.rb | 4 ++-- .../types/calling/function_parameters.rb | 4 ++-- .../generated/types/calling/goto.rb | 4 ++-- .../hang_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/calling/hangup.rb | 4 ++-- .../generated/types/calling/hangup_action.rb | 4 ++-- .../generated/types/calling/hint.rb | 4 ++-- .../generated/types/calling/hold_action.rb | 4 ++-- .../generated/types/calling/inject_action.rb | 4 ++-- .../types/calling/integer_property.rb | 4 ++-- .../types/calling/join_conference.rb | 4 ++-- .../types/calling/join_conference_object.rb | 4 ++-- .../generated/types/calling/join_room.rb | 4 ++-- .../generated/types/calling/label.rb | 4 ++-- .../types/calling/language_params.rb | 4 ++-- .../types/calling/languages_with_fillers.rb | 4 ++-- .../calling/languages_with_solo_fillers.rb | 4 ++-- .../types/calling/live_transcribe.rb | 4 ++-- .../calling/live_transcribe_start_action.rb | 4 ++-- .../live_transcribe_summarize_action.rb | 4 ++-- .../generated/types/calling/live_translate.rb | 4 ++-- .../calling/live_translate_inject_action.rb | 4 ++-- .../calling/live_translate_start_action.rb | 4 ++-- .../live_translate_summarize_action.rb | 4 ++-- .../generated/types/calling/null_property.rb | 4 ++-- .../types/calling/number_property.rb | 4 ++-- .../types/calling/object_property.rb | 4 ++-- .../types/calling/one_of_property.rb | 4 ++-- .../generated/types/calling/output.rb | 4 ++-- .../namespaces/generated/types/calling/pay.rb | 4 ++-- .../generated/types/calling/pay_parameters.rb | 4 ++-- .../types/calling/pay_prompt_play_action.rb | 4 ++-- .../types/calling/pay_prompt_say_action.rb | 4 ++-- .../generated/types/calling/pay_prompts.rb | 4 ++-- .../generated/types/calling/play.rb | 4 ++-- .../types/calling/play_with_u_r_l.rb | 4 ++-- .../types/calling/play_with_u_r_l_s.rb | 4 ++-- .../types/calling/playback_b_g_action.rb | 4 ++-- .../types/calling/pom_section_body_content.rb | 4 ++-- .../calling/pom_section_bullets_content.rb | 4 ++-- .../generated/types/calling/prompt.rb | 4 ++-- .../generated/types/calling/pronounce.rb | 4 ++-- .../generated/types/calling/receive_fax.rb | 4 ++-- .../generated/types/calling/record.rb | 4 ++-- .../generated/types/calling/record_call.rb | 4 ++-- .../generated/types/calling/request.rb | 4 ++-- .../generated/types/calling/return.rb | 4 ++-- .../generated/types/calling/s_i_p_refer.rb | 4 ++-- .../types/calling/s_m_s_with_body.rb | 4 ++-- .../types/calling/s_m_s_with_media.rb | 4 ++-- .../generated/types/calling/s_w_a_i_g.rb | 4 ++-- .../types/calling/s_w_a_i_g_defaults.rb | 4 ++-- .../types/calling/s_w_a_i_g_includes.rb | 4 ++-- .../calling/s_w_a_i_g_internal_filler.rb | 4 ++-- .../generated/types/calling/s_w_m_l_action.rb | 4 ++-- .../generated/types/calling/s_w_m_l_object.rb | 4 ++-- .../generated/types/calling/say_action.rb | 4 ++-- .../generated/types/calling/section.rb | 4 ++-- .../generated/types/calling/send_digits.rb | 4 ++-- .../generated/types/calling/send_fax.rb | 4 ++-- .../generated/types/calling/send_s_m_s.rb | 4 ++-- .../namespaces/generated/types/calling/set.rb | 4 ++-- .../types/calling/set_global_data_action.rb | 4 ++-- .../types/calling/set_meta_data_action.rb | 4 ++-- .../generated/types/calling/sleep.rb | 4 ++-- .../generated/types/calling/start_action.rb | 4 ++-- .../start_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/calling/stop_action.rb | 4 ++-- .../generated/types/calling/stop_denoise.rb | 4 ++-- .../types/calling/stop_playback_b_g_action.rb | 4 ++-- .../types/calling/stop_record_call.rb | 4 ++-- .../generated/types/calling/stop_tap.rb | 4 ++-- .../types/calling/string_property.rb | 4 ++-- .../types/calling/summarize_action.rb | 4 ++-- ...mmarize_conversation_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/calling/switch.rb | 4 ++-- .../namespaces/generated/types/calling/tap.rb | 4 ++-- .../types/calling/toggle_functions_action.rb | 4 ++-- .../types/calling/transcribe_start_action.rb | 4 ++-- .../calling/transcribe_summarize_action.rb | 4 ++-- .../generated/types/calling/transfer.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../generated/types/calling/unset.rb | 4 ++-- .../types/calling/unset_global_data_action.rb | 4 ++-- .../types/calling/unset_meta_data_action.rb | 4 ++-- .../generated/types/calling/user_event.rb | 4 ++-- .../types/calling/user_input_action.rb | 4 ++-- .../types/calling/user_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/calling/webhook.rb | 4 ++-- .../types/chat/chat_permission_with_read.rb | 4 ++-- .../types/chat/chat_permission_with_write.rb | 4 ++-- .../generated/types/chat/chat_token.rb | 4 ++-- .../types/chat/chat_token422_error.rb | 4 ++-- .../generated/types/chat/new_chat_token.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../chat/types_status_codes_status_code400.rb | 4 ++-- .../chat/types_status_codes_status_code401.rb | 4 ++-- .../generated/types/datasphere/chunk.rb | 4 ++-- .../types/datasphere/chunk_list_response.rb | 4 ++-- .../datasphere/chunk_pagination_response.rb | 4 ++-- .../types/datasphere/chunk_response.rb | 4 ++-- .../types/datasphere/create_status_code422.rb | 4 ++-- .../generated/types/datasphere/document.rb | 4 ++-- .../document_create_request_base.rb | 4 ++-- .../datasphere/document_list_response.rb | 4 ++-- .../datasphere/document_search_request.rb | 4 ++-- .../datasphere/document_update_request.rb | 4 ++-- .../types/datasphere/list_status_code422.rb | 4 ++-- .../types/datasphere/pagination_response.rb | 4 ++-- .../types/datasphere/search_response.rb | 4 ++-- .../types/datasphere/search_status_code422.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/datasphere/update_status_code422.rb | 4 ++-- .../namespaces/generated/types/fabric/a_i.rb | 4 ++-- .../fabric/a_i_address_pagination_response.rb | 4 ++-- .../generated/types/fabric/a_i_agent.rb | 4 ++-- .../fabric/a_i_agent_address_list_response.rb | 4 ++-- .../types/fabric/a_i_agent_create_request.rb | 4 ++-- .../fabric/a_i_agent_create_status_code422.rb | 4 ++-- .../types/fabric/a_i_agent_list_response.rb | 4 ++-- .../fabric/a_i_agent_pagination_response.rb | 4 ++-- .../types/fabric/a_i_agent_response.rb | 4 ++-- .../types/fabric/a_i_agent_update_request.rb | 4 ++-- .../fabric/a_i_agent_update_status_code422.rb | 4 ++-- .../generated/types/fabric/a_i_object.rb | 4 ++-- .../generated/types/fabric/a_i_params.rb | 4 ++-- .../types/fabric/a_i_post_prompt_pom.rb | 4 ++-- .../fabric/a_i_post_prompt_pom_update.rb | 4 ++-- .../types/fabric/a_i_post_prompt_text.rb | 4 ++-- .../fabric/a_i_post_prompt_text_update.rb | 4 ++-- .../generated/types/fabric/a_i_prompt_pom.rb | 4 ++-- .../types/fabric/a_i_prompt_pom_update.rb | 4 ++-- .../generated/types/fabric/a_i_prompt_text.rb | 4 ++-- .../types/fabric/a_i_prompt_text_update.rb | 4 ++-- .../generated/types/fabric/all_of_property.rb | 4 ++-- .../generated/types/fabric/amazon_bedrock.rb | 4 ++-- .../types/fabric/amazon_bedrock_object.rb | 4 ++-- .../generated/types/fabric/answer.rb | 4 ++-- .../generated/types/fabric/any_of_property.rb | 4 ++-- .../generated/types/fabric/array_property.rb | 4 ++-- .../generated/types/fabric/audio_channel.rb | 4 ++-- .../generated/types/fabric/bedrock_params.rb | 4 ++-- .../types/fabric/bedrock_s_w_a_i_g.rb | 4 ++-- .../types/fabric/boolean_property.rb | 4 ++-- .../generated/types/fabric/c_x_m_l_script.rb | 4 ++-- .../c_x_m_l_script_address_list_response.rb | 4 ++-- ..._m_l_script_address_pagination_response.rb | 4 ++-- .../fabric/c_x_m_l_script_create_request.rb | 4 ++-- .../c_x_m_l_script_create_status_code422.rb | 4 ++-- .../fabric/c_x_m_l_script_list_response.rb | 4 ++-- .../types/fabric/c_x_m_l_script_response.rb | 4 ++-- .../fabric/c_x_m_l_script_update_request.rb | 4 ++-- .../c_x_m_l_script_update_status_code422.rb | 4 ++-- .../generated/types/fabric/c_x_m_l_webhook.rb | 4 ++-- .../c_x_m_l_webhook_address_list_response.rb | 4 ++-- ...m_l_webhook_address_pagination_response.rb | 4 ++-- .../fabric/c_x_m_l_webhook_create_request.rb | 4 ++-- .../c_x_m_l_webhook_create_status_code422.rb | 4 ++-- .../fabric/c_x_m_l_webhook_list_response.rb | 4 ++-- .../c_x_m_l_webhook_pagination_response.rb | 4 ++-- .../types/fabric/c_x_m_l_webhook_response.rb | 4 ++-- .../fabric/c_x_m_l_webhook_update_request.rb | 4 ++-- .../c_x_m_l_webhook_update_status_code422.rb | 4 ++-- .../generated/types/fabric/call_flow.rb | 4 ++-- .../fabric/call_flow_address_list_response.rb | 4 ++-- .../call_flow_address_pagination_response.rb | 4 ++-- .../types/fabric/call_flow_create_request.rb | 4 ++-- .../fabric/call_flow_create_status_code422.rb | 4 ++-- .../types/fabric/call_flow_list_response.rb | 4 ++-- .../types/fabric/call_flow_response.rb | 4 ++-- .../types/fabric/call_flow_update_request.rb | 4 ++-- .../fabric/call_flow_update_status_code422.rb | 4 ++-- .../types/fabric/call_flow_version.rb | 4 ++-- ...flow_version_deploy_by_document_version.rb | 4 ++-- .../call_flow_version_deploy_by_version_id.rb | 4 ++-- .../call_flow_version_deploy_response.rb | 4 ++-- .../fabric/call_flow_version_list_response.rb | 4 ++-- .../call_flow_versions_pagination_response.rb | 4 ++-- .../types/fabric/change_context_action.rb | 4 ++-- .../types/fabric/change_step_action.rb | 4 ++-- .../namespaces/generated/types/fabric/cond.rb | 4 ++-- .../generated/types/fabric/cond_else.rb | 4 ++-- .../generated/types/fabric/cond_reg.rb | 4 ++-- .../generated/types/fabric/conference_room.rb | 4 ++-- .../conference_room_address_list_response.rb | 4 ++-- ...erence_room_address_pagination_response.rb | 4 ++-- .../fabric/conference_room_create_request.rb | 4 ++-- .../conference_room_create_status_code422.rb | 4 ++-- .../fabric/conference_room_list_response.rb | 4 ++-- .../types/fabric/conference_room_response.rb | 4 ++-- .../fabric/conference_room_update_request.rb | 4 ++-- .../conference_room_update_status_code422.rb | 4 ++-- .../generated/types/fabric/connect.rb | 4 ++-- .../types/fabric/connect_device_parallel.rb | 4 ++-- .../types/fabric/connect_device_serial.rb | 4 ++-- .../fabric/connect_device_serial_parallel.rb | 4 ++-- .../types/fabric/connect_device_single.rb | 4 ++-- .../generated/types/fabric/connect_headers.rb | 4 ++-- .../generated/types/fabric/connect_switch.rb | 4 ++-- .../generated/types/fabric/const_property.rb | 4 ++-- .../types/fabric/context_p_o_m_steps.rb | 4 ++-- .../types/fabric/context_switch_action.rb | 4 ++-- .../types/fabric/context_text_steps.rb | 4 ++-- .../generated/types/fabric/contexts.rb | 4 ++-- .../types/fabric/contexts_p_o_m_object.rb | 4 ++-- .../fabric/contexts_p_o_m_object_update.rb | 4 ++-- .../types/fabric/contexts_text_object.rb | 4 ++-- .../fabric/contexts_text_object_update.rb | 4 ++-- .../generated/types/fabric/contexts_update.rb | 4 ++-- .../types/fabric/conversation_message.rb | 4 ++-- .../types/fabric/cxml_application.rb | 4 ++-- .../cxml_application_address_list_response.rb | 4 ++-- ...application_address_pagination_response.rb | 4 ++-- .../fabric/cxml_application_list_response.rb | 4 ++-- .../cxml_application_pagination_response.rb | 4 ++-- .../types/fabric/cxml_application_response.rb | 4 ++-- .../fabric/cxml_application_update_request.rb | 4 ++-- .../cxml_application_update_status_code422.rb | 4 ++-- .../generated/types/fabric/data_map.rb | 4 ++-- .../generated/types/fabric/denoise.rb | 4 ++-- .../generated/types/fabric/detect_machine.rb | 4 ++-- .../fabric/dialog_flow_pagination_response.rb | 4 ++-- .../types/fabric/dialogflow_agent.rb | 4 ++-- .../dialogflow_agent_address_list_response.rb | 4 ++-- ...gflow_agent_address_pagination_response.rb | 4 ++-- .../fabric/dialogflow_agent_list_response.rb | 4 ++-- .../types/fabric/dialogflow_agent_response.rb | 4 ++-- .../fabric/dialogflow_agent_update_request.rb | 4 ++-- .../dialogflow_agent_update_status_code422.rb | 4 ++-- .../domain_application_assign_request.rb | 4 ++-- ...omain_application_create_status_code422.rb | 4 ++-- .../fabric/domain_application_response.rb | 4 ++-- .../embed_token_create_status_code422.rb | 4 ++-- .../types/fabric/embeds_tokens_request.rb | 4 ++-- .../types/fabric/embeds_tokens_response.rb | 4 ++-- .../generated/types/fabric/enter_queue.rb | 4 ++-- .../types/fabric/enter_queue_object.rb | 4 ++-- .../generated/types/fabric/execute.rb | 4 ++-- .../generated/types/fabric/execute_switch.rb | 4 ++-- .../generated/types/fabric/expression.rb | 4 ++-- .../generated/types/fabric/fabric_address.rb | 4 ++-- .../types/fabric/fabric_address_app.rb | 4 ++-- .../types/fabric/fabric_address_call.rb | 4 ++-- .../fabric_address_pagination_response.rb | 4 ++-- .../types/fabric/fabric_address_room.rb | 4 ++-- .../types/fabric/fabric_address_subscriber.rb | 4 ++-- .../types/fabric/fabric_addresses_response.rb | 4 ++-- ...freeswitch_conector_pagination_response.rb | 4 ++-- .../types/fabric/freeswitch_connector.rb | 4 ++-- ...eswitch_connector_address_list_response.rb | 4 ++-- ...h_connector_address_pagination_response.rb | 4 ++-- .../freeswitch_connector_create_request.rb | 4 ++-- ...eswitch_connector_create_status_code422.rb | 4 ++-- .../freeswitch_connector_list_response.rb | 4 ++-- .../fabric/freeswitch_connector_response.rb | 4 ++-- .../freeswitch_connector_update_request.rb | 4 ++-- ...eswitch_connector_update_status_code422.rb | 4 ++-- .../types/fabric/function_parameters.rb | 4 ++-- .../namespaces/generated/types/fabric/goto.rb | 4 ++-- .../guest_token_create_status_code422.rb | 4 ++-- .../fabric/hang_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/fabric/hangup.rb | 4 ++-- .../generated/types/fabric/hangup_action.rb | 4 ++-- .../namespaces/generated/types/fabric/hint.rb | 4 ++-- .../generated/types/fabric/hold_action.rb | 4 ++-- .../generated/types/fabric/inject_action.rb | 4 ++-- .../types/fabric/integer_property.rb | 4 ++-- .../invite_token_create_status_code422.rb | 4 ++-- .../generated/types/fabric/join_conference.rb | 4 ++-- .../types/fabric/join_conference_object.rb | 4 ++-- .../generated/types/fabric/join_room.rb | 4 ++-- .../generated/types/fabric/label.rb | 4 ++-- .../generated/types/fabric/language_params.rb | 4 ++-- .../types/fabric/languages_with_fillers.rb | 4 ++-- .../fabric/languages_with_solo_fillers.rb | 4 ++-- .../generated/types/fabric/live_transcribe.rb | 4 ++-- .../generated/types/fabric/live_translate.rb | 4 ++-- .../types/fabric/messaging_channel.rb | 4 ++-- .../generated/types/fabric/null_property.rb | 4 ++-- .../generated/types/fabric/number_property.rb | 4 ++-- .../generated/types/fabric/object_property.rb | 4 ++-- .../generated/types/fabric/one_of_property.rb | 4 ++-- .../generated/types/fabric/output.rb | 4 ++-- .../namespaces/generated/types/fabric/pay.rb | 4 ++-- .../generated/types/fabric/pay_parameters.rb | 4 ++-- .../types/fabric/pay_prompt_play_action.rb | 4 ++-- .../types/fabric/pay_prompt_say_action.rb | 4 ++-- .../generated/types/fabric/pay_prompts.rb | 4 ++-- .../fabric/phone_route_assign_request.rb | 4 ++-- .../phone_route_create_status_code422.rb | 4 ++-- .../types/fabric/phone_route_response.rb | 4 ++-- .../namespaces/generated/types/fabric/play.rb | 4 ++-- .../generated/types/fabric/play_with_u_r_l.rb | 4 ++-- .../types/fabric/play_with_u_r_l_s.rb | 4 ++-- .../types/fabric/playback_b_g_action.rb | 4 ++-- .../types/fabric/pom_section_body_content.rb | 4 ++-- .../fabric/pom_section_bullets_content.rb | 4 ++-- .../generated/types/fabric/prompt.rb | 4 ++-- .../generated/types/fabric/pronounce.rb | 4 ++-- .../generated/types/fabric/receive_fax.rb | 4 ++-- .../generated/types/fabric/record.rb | 4 ++-- .../generated/types/fabric/record_call.rb | 4 ++-- .../fabric/refresh_token_status_code422.rb | 4 ++-- .../types/fabric/relay_application.rb | 4 ++-- ...relay_application_address_list_response.rb | 4 ++-- ...application_address_pagination_response.rb | 4 ++-- .../relay_application_create_request.rb | 4 ++-- ...relay_application_create_status_code422.rb | 4 ++-- .../fabric/relay_application_list_response.rb | 4 ++-- .../fabric/relay_application_response.rb | 4 ++-- .../relay_application_update_request.rb | 4 ++-- ...relay_application_update_status_code422.rb | 4 ++-- .../generated/types/fabric/request.rb | 4 ++-- .../fabric/resource_address_list_response.rb | 4 ++-- .../resource_address_pagination_response.rb | 4 ++-- .../types/fabric/resource_list_response.rb | 4 ++-- .../fabric/resource_pagination_response.rb | 4 ++-- .../types/fabric/resource_response_a_i.rb | 4 ++-- .../resource_response_c_x_m_l_application.rb | 4 ++-- .../resource_response_c_x_m_l_script.rb | 4 ++-- .../resource_response_c_x_m_l_webhook.rb | 4 ++-- .../fabric/resource_response_call_flow.rb | 4 ++-- .../resource_response_conference_room.rb | 4 ++-- .../resource_response_dialog_flow_agent.rb | 4 ++-- .../fabric/resource_response_f_s_connector.rb | 4 ++-- .../fabric/resource_response_relay_app.rb | 4 ++-- .../resource_response_s_w_m_l_script.rb | 4 ++-- .../resource_response_s_w_m_l_webhook.rb | 4 ++-- .../fabric/resource_response_sip_endpoint.rb | 4 ++-- .../fabric/resource_response_sip_gateway.rb | 4 ++-- .../fabric/resource_response_subscriber.rb | 4 ++-- .../resource_sip_endpoint_assign_request.rb | 4 ++-- ...urce_sip_endpoint_create_status_code422.rb | 4 ++-- .../fabric/resource_sip_endpoint_response.rb | 4 ++-- ...urce_sip_endpoint_update_status_code422.rb | 4 ++-- ..._sub_sip_endpoint_create_status_code422.rb | 4 ++-- .../generated/types/fabric/return.rb | 4 ++-- .../generated/types/fabric/s_i_p_refer.rb | 4 ++-- .../generated/types/fabric/s_m_s_with_body.rb | 4 ++-- .../types/fabric/s_m_s_with_media.rb | 4 ++-- .../generated/types/fabric/s_w_a_i_g.rb | 4 ++-- .../types/fabric/s_w_a_i_g_defaults.rb | 4 ++-- .../types/fabric/s_w_a_i_g_includes.rb | 4 ++-- .../types/fabric/s_w_a_i_g_internal_filler.rb | 4 ++-- .../s_w_a_i_g_internal_filler_update.rb | 4 ++-- .../types/fabric/s_w_a_i_g_update.rb | 4 ++-- .../generated/types/fabric/s_w_m_l_action.rb | 4 ++-- .../generated/types/fabric/s_w_m_l_object.rb | 4 ++-- .../s_w_m_l_script_address_list_response.rb | 4 ++-- ..._m_l_script_address_pagination_response.rb | 4 ++-- .../generated/types/fabric/s_w_m_l_webhook.rb | 4 ++-- .../s_w_m_l_webhook_address_list_response.rb | 4 ++-- ...m_l_webhook_address_pagination_response.rb | 4 ++-- .../fabric/s_w_m_l_webhook_create_request.rb | 4 ++-- .../fabric/s_w_m_l_webhook_list_response.rb | 4 ++-- .../s_w_m_l_webhook_pagination_response.rb | 4 ++-- .../types/fabric/s_w_m_l_webhook_response.rb | 4 ++-- .../fabric/s_w_m_l_webhook_update_request.rb | 4 ++-- .../generated/types/fabric/say_action.rb | 4 ++-- .../generated/types/fabric/section.rb | 4 ++-- .../generated/types/fabric/send_digits.rb | 4 ++-- .../generated/types/fabric/send_fax.rb | 4 ++-- .../generated/types/fabric/send_s_m_s.rb | 4 ++-- .../namespaces/generated/types/fabric/set.rb | 4 ++-- .../types/fabric/set_global_data_action.rb | 4 ++-- .../types/fabric/set_meta_data_action.rb | 4 ++-- .../generated/types/fabric/sip_endpoint.rb | 4 ++-- .../sip_endpoint_address_list_response.rb | 4 ++-- ...ip_endpoint_address_pagination_response.rb | 4 ++-- .../fabric/sip_endpoint_create_request.rb | 4 ++-- .../sip_endpoint_create_status_code422.rb | 4 ++-- .../fabric/sip_endpoint_list_response.rb | 4 ++-- .../sip_endpoint_pagination_response.rb | 4 ++-- .../types/fabric/sip_endpoint_response.rb | 4 ++-- .../fabric/sip_endpoint_update_request.rb | 4 ++-- .../sip_endpoint_update_status_code422.rb | 4 ++-- .../generated/types/fabric/sip_gateway.rb | 4 ++-- .../sip_gateway_address_list_response.rb | 4 ++-- ...sip_gateway_address_pagination_response.rb | 4 ++-- .../sip_gateway_create_status_code422.rb | 4 ++-- .../types/fabric/sip_gateway_list_response.rb | 4 ++-- .../fabric/sip_gateway_pagination_response.rb | 4 ++-- .../types/fabric/sip_gateway_request.rb | 4 ++-- .../fabric/sip_gateway_request_update.rb | 4 ++-- .../types/fabric/sip_gateway_response.rb | 4 ++-- .../generated/types/fabric/sleep.rb | 4 ++-- .../generated/types/fabric/start_action.rb | 4 ++-- .../start_up_hook_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/fabric/stop_action.rb | 4 ++-- .../generated/types/fabric/stop_denoise.rb | 4 ++-- .../types/fabric/stop_playback_b_g_action.rb | 4 ++-- .../types/fabric/stop_record_call.rb | 4 ++-- .../generated/types/fabric/stop_tap.rb | 4 ++-- .../generated/types/fabric/string_property.rb | 4 ++-- .../generated/types/fabric/subscriber.rb | 4 ++-- .../subscriber_address_pagination_response.rb | 4 ++-- .../fabric/subscriber_addresses_response.rb | 4 ++-- .../subscriber_create_status_code422.rb | 4 ++-- .../subscriber_guest_token_create_request.rb | 4 ++-- .../subscriber_guest_token_create_response.rb | 4 ++-- .../subscriber_invite_token_create_request.rb | 4 ++-- ...subscriber_invite_token_create_response.rb | 4 ++-- .../types/fabric/subscriber_list_response.rb | 4 ++-- .../fabric/subscriber_pagination_response.rb | 4 ++-- .../subscriber_refresh_token_request.rb | 4 ++-- .../subscriber_refresh_token_response.rb | 4 ++-- .../types/fabric/subscriber_request.rb | 4 ++-- .../types/fabric/subscriber_response.rb | 4 ++-- .../types/fabric/subscriber_s_i_p_endpoint.rb | 4 ++-- .../subscriber_sip_endpoint_list_response.rb | 4 ++-- ...criber_sip_endpoint_pagination_response.rb | 4 ++-- .../fabric/subscriber_sip_endpoint_request.rb | 4 ++-- .../subscriber_sip_endpoint_request_update.rb | 4 ++-- .../types/fabric/subscriber_token_request.rb | 4 ++-- .../types/fabric/subscriber_token_response.rb | 4 ++-- .../fabric/subscriber_token_status_code422.rb | 4 ++-- .../subscriber_update_status_code422.rb | 4 ++-- .../types/fabric/summarize_action.rb | 4 ++-- ...mmarize_conversation_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/fabric/switch.rb | 4 ++-- .../generated/types/fabric/swml_script.rb | 4 ++-- .../fabric/swml_script_create_request.rb | 4 ++-- .../swml_script_create_status_code422.rb | 4 ++-- .../types/fabric/swml_script_list_response.rb | 4 ++-- .../fabric/swml_script_paginationresponse.rb | 4 ++-- .../types/fabric/swml_script_response.rb | 4 ++-- .../fabric/swml_script_update_request.rb | 4 ++-- .../swml_script_update_status_code422.rb | 4 ++-- .../swml_webhook_create_status_code422.rb | 4 ++-- .../swml_webhook_update_status_code422.rb | 4 ++-- .../namespaces/generated/types/fabric/tap.rb | 4 ++-- .../types/fabric/toggle_functions_action.rb | 4 ++-- .../types/fabric/transcribe_start_action.rb | 4 ++-- .../fabric/transcribe_summarize_action.rb | 4 ++-- .../generated/types/fabric/transfer.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code403.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code422.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../generated/types/fabric/unset.rb | 4 ++-- .../types/fabric/unset_global_data_action.rb | 4 ++-- .../types/fabric/unset_meta_data_action.rb | 4 ++-- .../generated/types/fabric/user_event.rb | 4 ++-- .../types/fabric/user_input_action.rb | 4 ++-- .../types/fabric/user_s_w_a_i_g_function.rb | 4 ++-- .../generated/types/fabric/video_channel.rb | 4 ++-- .../generated/types/fabric/webhook.rb | 4 ++-- .../generated/types/fax/charge_detail.rb | 4 ++-- .../namespaces/generated/types/fax/fax_log.rb | 4 ++-- .../types/fax/fax_log_show_status_code422.rb | 4 ++-- .../types/fax/fax_logs_list_status_code422.rb | 4 ++-- .../generated/types/fax/log_list_response.rb | 4 ++-- .../types/fax/log_pagination_response.rb | 4 ++-- .../generated/types/fax/log_response.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../fax/types_status_codes_status_code400.rb | 4 ++-- .../fax/types_status_codes_status_code401.rb | 4 ++-- .../fax/types_status_codes_status_code404.rb | 4 ++-- .../fax/types_status_codes_status_code500.rb | 4 ++-- .../generated/types/logs/charge_details.rb | 4 ++-- .../logs/conference_log_pagination_links.rb | 4 ++-- .../logs/conference_logs_status_code422.rb | 4 ++-- .../types/logs/conferences_response.rb | 4 ++-- .../generated/types/logs/cxml_conference.rb | 4 ++-- .../generated/types/logs/relay_conference.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../logs/types_status_codes_status_code401.rb | 4 ++-- .../logs/types_status_codes_status_code500.rb | 4 ++-- .../logs/video_room_session_conference.rb | 4 ++-- .../generated/types/message/charge_detail.rb | 4 ++-- .../types/message/log_list_response.rb | 4 ++-- .../types/message/log_pagination_response.rb | 4 ++-- .../types/message/log_retrieve_response.rb | 4 ++-- .../generated/types/message/message_log.rb | 4 ++-- .../message_log_show_status_code422.rb | 4 ++-- .../message_logs_list_status_code422.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/messages/create_message_request.rb | 4 ++-- .../generated/types/messages/message.rb | 4 ++-- .../messages_create_status_code422.rb | 4 ++-- .../messages_update_status_code422.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/messages/update_message_request.rb | 4 ++-- .../types/project/create_token_request.rb | 4 ++-- .../generated/types/project/token_response.rb | 4 ++-- .../types/project/token_status_code422.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/project/update_token_request.rb | 4 ++-- .../generated/types/projects/project.rb | 4 ++-- .../types/projects/project_create.rb | 4 ++-- .../generated/types/projects/project_list.rb | 4 ++-- .../types/projects/project_status_code422.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code403.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types/pubsub/new_pub_sub_token.rb | 4 ++-- .../pubsub/pub_sub_permission_with_read.rb | 4 ++-- .../pubsub/pub_sub_permission_with_write.rb | 4 ++-- .../generated/types/pubsub/pub_sub_token.rb | 4 ++-- .../types/pubsub/pub_sub_token422_error.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../add_number_group_membership_request.rb | 4 ++-- .../generated/types/relay_rest/address.rb | 4 ++-- .../types/relay_rest/address_list_response.rb | 4 ++-- .../types/relay_rest/address_response.rb | 4 ++-- .../types/relay_rest/assigned_number.rb | 4 ++-- .../assigned_number_list_response.rb | 4 ++-- .../types/relay_rest/assigned_phone_number.rb | 4 ++-- .../relay_rest/available_phone_number.rb | 4 ++-- .../available_phone_numbers_response.rb | 4 ++-- .../generated/types/relay_rest/brand.rb | 4 ++-- .../types/relay_rest/brand_list_response.rb | 4 ++-- .../types/relay_rest/brand_response.rb | 4 ++-- .../generated/types/relay_rest/campaign.rb | 4 ++-- .../relay_rest/campaign_list_response.rb | 4 ++-- .../types/relay_rest/campaign_response.rb | 4 ++-- .../types/relay_rest/carrier_lookup_info.rb | 4 ++-- .../generated/types/relay_rest/cnam_info.rb | 4 ++-- .../relay_rest/create_address_request.rb | 4 ++-- .../relay_rest/create_csp_brand_request.rb | 4 ++-- .../create_domain_application_request.rb | 4 ++-- .../create_managed_brand_request.rb | 4 ++-- .../create_managed_campaign_request.rb | 4 ++-- .../relay_rest/create_number_group_request.rb | 4 ++-- .../types/relay_rest/create_order_request.rb | 4 ++-- .../create_partner_campaign_request.rb | 4 ++-- .../types/relay_rest/create_queue_request.rb | 4 ++-- .../relay_rest/create_sip_endpoint_request.rb | 4 ++-- .../create_verified_caller_i_d_request.rb | 4 ++-- .../types/relay_rest/domain_application.rb | 4 ++-- .../domain_application_list_response.rb | 4 ++-- .../relay_rest/domain_application_response.rb | 4 ++-- .../relay_rest/import_phone_number_request.rb | 4 ++-- .../relay_rest/membership_phone_number.rb | 4 ++-- .../generated/types/relay_rest/mfa_request.rb | 4 ++-- .../types/relay_rest/mfa_response.rb | 4 ++-- .../types/relay_rest/mfa_verify_request.rb | 4 ++-- .../types/relay_rest/mfa_verify_response.rb | 4 ++-- .../types/relay_rest/number_group.rb | 4 ++-- .../relay_rest/number_group_list_response.rb | 4 ++-- .../relay_rest/number_group_membership.rb | 4 ++-- .../number_group_membership_list_response.rb | 4 ++-- .../number_group_membership_response.rb | 4 ++-- .../types/relay_rest/number_group_response.rb | 4 ++-- .../generated/types/relay_rest/order.rb | 4 ++-- .../types/relay_rest/order_list_response.rb | 4 ++-- .../types/relay_rest/order_response.rb | 4 ++-- .../types/relay_rest/pagination_links.rb | 4 ++-- .../types/relay_rest/phone_call_handler.rb | 2 +- .../types/relay_rest/phone_number.rb | 4 ++-- .../relay_rest/phone_number_capabilities.rb | 4 ++-- .../relay_rest/phone_number_list_response.rb | 4 ++-- .../phone_number_lookup_response.rb | 4 ++-- .../types/relay_rest/phone_number_response.rb | 4 ++-- .../types/relay_rest/pstn_recording.rb | 4 ++-- .../purchase_phone_number_request.rb | 4 ++-- .../generated/types/relay_rest/queue.rb | 4 ++-- .../types/relay_rest/queue_list_response.rb | 4 ++-- .../types/relay_rest/queue_member.rb | 4 ++-- .../relay_rest/queue_member_list_response.rb | 4 ++-- .../types/relay_rest/queue_member_response.rb | 4 ++-- .../types/relay_rest/queue_response.rb | 4 ++-- .../relay_rest/recording_list_response.rb | 4 ++-- .../generated/types/relay_rest/short_code.rb | 4 ++-- .../relay_rest/short_code_list_response.rb | 4 ++-- .../types/relay_rest/short_code_response.rb | 4 ++-- .../types/relay_rest/sip_endpoint.rb | 4 ++-- .../relay_rest/sip_endpoint_list_response.rb | 4 ++-- .../types/relay_rest/sip_endpoint_response.rb | 4 ++-- .../types/relay_rest/sip_profile_response.rb | 4 ++-- .../types/relay_rest/sip_recording.rb | 4 ++-- ...types_status_codes_space_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types_status_codes_validation_error.rb | 4 ++-- .../relay_rest/update_campaign_request.rb | 4 ++-- .../update_domain_application_request.rb | 4 ++-- .../relay_rest/update_number_group_request.rb | 4 ++-- .../relay_rest/update_phone_number_request.rb | 4 ++-- .../types/relay_rest/update_queue_request.rb | 4 ++-- .../relay_rest/update_short_code_request.rb | 4 ++-- .../relay_rest/update_sip_endpoint_request.rb | 4 ++-- .../relay_rest/update_sip_profile_request.rb | 4 ++-- .../update_verified_caller_i_d_request.rb | 4 ++-- .../types/relay_rest/verified_caller_i_d.rb | 4 ++-- .../verified_caller_i_d_list_response.rb | 4 ++-- .../verified_caller_i_d_response.rb | 4 ++-- .../relay_rest/verify_caller_i_d_request.rb | 4 ++-- .../types/relay_rest/web_rtc_recording.rb | 4 ++-- .../post_prompt_conversation_turn.rb | 4 ++-- .../types/swml_webhooks/post_prompt_data.rb | 4 ++-- .../post_prompt_function_call.rb | 4 ++-- .../types/swml_webhooks/post_prompt_params.rb | 4 ++-- .../swml_webhooks/signal_wire_error_body.rb | 4 ++-- .../types/swml_webhooks/swaig_argument.rb | 4 ++-- .../types/swml_webhooks/swaig_request_data.rb | 4 ++-- .../types/swml_webhooks/swml_request_call.rb | 4 ++-- .../types/swml_webhooks/swml_request_data.rb | 4 ++-- .../generated/types/video/active_session.rb | 4 ++-- .../generated/types/video/charge_detail.rb | 4 ++-- .../generated/types/video/conference.rb | 4 ++-- .../generated/types/video/conference_token.rb | 4 ++-- .../types/video/create_conference_request.rb | 4 ++-- .../types/video/create_room_request.rb | 4 ++-- .../types/video/create_room_token_request.rb | 4 ++-- .../types/video/create_stream_request.rb | 4 ++-- .../generated/types/video/discarded_log.rb | 4 ++-- .../video/list_conference_tokens_response.rb | 4 ++-- .../types/video/list_conferences_response.rb | 4 ++-- .../types/video/list_logs_response.rb | 4 ++-- .../list_room_recording_events_response.rb | 4 ++-- .../video/list_room_recordings_response.rb | 4 ++-- .../list_room_session_events_response.rb | 4 ++-- .../list_room_session_members_response.rb | 4 ++-- .../list_room_session_recordings_response.rb | 4 ++-- .../video/list_room_sessions_response.rb | 4 ++-- .../types/video/list_rooms_response.rb | 4 ++-- .../types/video/list_streams_response.rb | 4 ++-- .../namespaces/generated/types/video/log.rb | 4 ++-- .../generated/types/video/pagination_links.rb | 4 ++-- .../generated/types/video/room_recording.rb | 4 ++-- .../generated/types/video/room_response.rb | 4 ++-- .../generated/types/video/room_session.rb | 4 ++-- .../types/video/room_session_event.rb | 4 ++-- .../types/video/room_session_member.rb | 4 ++-- .../types/video/room_session_summary.rb | 4 ++-- .../types/video/room_token_response.rb | 4 ++-- .../generated/types/video/stream.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code403.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/video/update_conference_request.rb | 4 ++-- .../types/video/update_room_request.rb | 4 ++-- .../types/video/update_stream_request.rb | 4 ++-- .../types/video/video_status_code422.rb | 4 ++-- .../generated/types/voice/charge_detail.rb | 4 ++-- .../types/voice/dialogflow_voice_log.rb | 4 ++-- .../types/voice/discarded_voice_log.rb | 4 ++-- .../generated/types/voice/fabric_voice_log.rb | 4 ++-- .../generated/types/voice/log_event.rb | 4 ++-- .../types/voice/log_events_list_response.rb | 4 ++-- .../types/voice/log_list_response.rb | 4 ++-- .../types/voice/log_pagination_response.rb | 4 ++-- .../generated/types/voice/relay_voice_log.rb | 4 ++-- .../types_status_codes_rest_api_error_item.rb | 4 ++-- .../types_status_codes_status_code400.rb | 4 ++-- .../types_status_codes_status_code401.rb | 4 ++-- .../types_status_codes_status_code404.rb | 4 ++-- .../types_status_codes_status_code422.rb | 4 ++-- .../types_status_codes_status_code500.rb | 4 ++-- .../types/voice/video_room_voice_log.rb | 4 ++-- .../voice/voice_logs_list_status_code422.rb | 4 ++-- .../namespaces/generated/video_namespace.rb | 5 ++-- scripts/generate_rest.py | 23 ++++++++++--------- 1081 files changed, 2175 insertions(+), 2168 deletions(-) diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt.rb b/lib/signalwire/core/post_prompt_generated/post_prompt.rb index 1e26c4d4..b404c7be 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPrompt — generated read-side payload (post-prompt components/schemas 'PostPrompt'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPrompt FIELDS = { 'content_type' => :any, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb index d84e8917..f1904d3a 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_assistant_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptAssistantEntry — generated read-side payload (post-prompt components/schemas 'PostPromptAssistantEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptAssistantEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb index 5fe49f31..962d4cf9 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_data.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptData — generated read-side payload (post-prompt components/schemas 'PostPromptData'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptData FIELDS = { 'parsed' => :array, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb index 4d67a144..27154306 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_entity.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptEntity — generated read-side payload (post-prompt components/schemas 'PostPromptEntity'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptEntity FIELDS = { 'type' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb index f373f480..2ff6302f 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_eot.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptEot — generated read-side payload (post-prompt components/schemas 'PostPromptEot'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptEot FIELDS = { 'basis' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb index 2f0fae39..9fdd06dd 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_stamps_us.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptStampsUs — generated read-side payload (post-prompt components/schemas 'PostPromptStampsUs'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptStampsUs FIELDS = { 'speech_start' => :integer, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb index 9beb6340..9960dc5c 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_swaig_log_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptSwaigLogEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSwaigLogEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptSwaigLogEntry FIELDS = { 'command_name' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb index b27c713c..4e830956 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_system_entry.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptSystemEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSystemEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptSystemEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb index 4a38d57d..35e64ae0 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_system_log_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptSystemLogEntry — generated read-side payload (post-prompt components/schemas 'PostPromptSystemLogEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptSystemLogEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb index f3348aaa..86d8985f 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_thinking_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptThinkingEntry — generated read-side payload (post-prompt components/schemas 'PostPromptThinkingEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptThinkingEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb index 82a7edac..d00c194d 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_times_entry.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptTimesEntry — generated read-side payload (post-prompt components/schemas 'PostPromptTimesEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptTimesEntry FIELDS = { 'response' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb index 24692ad0..81ac2798 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_timing.rb @@ -16,8 +16,8 @@ module PostPromptGenerated # PostPromptTiming — generated read-side payload (post-prompt components/schemas 'PostPromptTiming'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptTiming FIELDS = { 'hold_ms' => :number, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb index aff67413..d165c87e 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_tool_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptToolEntry — generated read-side payload (post-prompt components/schemas 'PostPromptToolEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptToolEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb b/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb index a8f1a59c..3e96d619 100644 --- a/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb +++ b/lib/signalwire/core/post_prompt_generated/post_prompt_user_entry.rb @@ -17,8 +17,8 @@ module PostPromptGenerated # PostPromptUserEntry — generated read-side payload (post-prompt components/schemas 'PostPromptUserEntry'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PostPromptUserEntry FIELDS = { 'role' => :string, diff --git a/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb b/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb index 043a087f..fe2cf1ea 100644 --- a/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/context_switch_action.rb @@ -16,8 +16,8 @@ module SwaigActionsGenerated # ContextSwitchAction — generated data type (swaig-response action 'context_switch' value object). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class ContextSwitchAction FIELDS = { 'system_prompt' => :any, diff --git a/lib/signalwire/core/swaig_actions_generated/hold_action.rb b/lib/signalwire/core/swaig_actions_generated/hold_action.rb index 2868a570..9fded60d 100644 --- a/lib/signalwire/core/swaig_actions_generated/hold_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/hold_action.rb @@ -16,8 +16,8 @@ module SwaigActionsGenerated # HoldAction — generated data type (swaig-response action 'hold' value object). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class HoldAction FIELDS = { 'timeout' => :integer diff --git a/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb b/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb index 181efbe0..33e9b4b1 100644 --- a/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/playback_bg_action.rb @@ -16,8 +16,8 @@ module SwaigActionsGenerated # PlaybackBgAction — generated data type (swaig-response action 'playback_bg' value object). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class PlaybackBgAction FIELDS = { 'file' => :any, diff --git a/lib/signalwire/core/swaig_actions_generated/transfer_action.rb b/lib/signalwire/core/swaig_actions_generated/transfer_action.rb index 63cff88d..c1604fc2 100644 --- a/lib/signalwire/core/swaig_actions_generated/transfer_action.rb +++ b/lib/signalwire/core/swaig_actions_generated/transfer_action.rb @@ -16,8 +16,8 @@ module SwaigActionsGenerated # TransferAction — generated data type (swaig-response action 'transfer' value object). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class TransferAction FIELDS = { 'dest' => :any, diff --git a/lib/signalwire/core/swaig_request_generated/swaig_argument.rb b/lib/signalwire/core/swaig_request_generated/swaig_argument.rb index 77c66a4f..3522dad6 100644 --- a/lib/signalwire/core/swaig_request_generated/swaig_argument.rb +++ b/lib/signalwire/core/swaig_request_generated/swaig_argument.rb @@ -16,8 +16,8 @@ module SwaigRequestGenerated # SwaigArgument — generated read-side payload (inline swaig-request `argument` object). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SwaigArgument FIELDS = { 'parsed' => :array, diff --git a/lib/signalwire/core/swaig_request_generated/swaig_request.rb b/lib/signalwire/core/swaig_request_generated/swaig_request.rb index 1492d5c7..a46a6d80 100644 --- a/lib/signalwire/core/swaig_request_generated/swaig_request.rb +++ b/lib/signalwire/core/swaig_request_generated/swaig_request.rb @@ -17,8 +17,8 @@ module SwaigRequestGenerated # SwaigRequest — generated read-side payload (swaig-request `SwaigRequest` schema). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SwaigRequest FIELDS = { 'ai_session_id' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i.rb b/lib/signalwire/core/swml_verbs_generated/a_i.rb index d14858a8..32f928ff 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # AI — generated read-side payload (schema.json $defs schema 'AI'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AI FIELDS = { 'ai' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_object.rb b/lib/signalwire/core/swml_verbs_generated/a_i_object.rb index 78be0761..46da3480 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_object.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AIObject — generated read-side payload (schema.json $defs schema 'AIObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_params.rb b/lib/signalwire/core/swml_verbs_generated/a_i_params.rb index d75335ee..1dc36c1b 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_params.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AIParams — generated read-side payload (schema.json $defs schema 'AIParams'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIParams FIELDS = { 'acknowledge_interruptions' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb index 8f196fe7..2fa8d995 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_pom.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # AIPostPromptPom — generated read-side payload (schema.json $defs schema 'AIPostPromptPom'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIPostPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb index 601f2bc2..8a0fc04c 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_post_prompt_text.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # AIPostPromptText — generated read-side payload (schema.json $defs schema 'AIPostPromptText'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIPostPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb index 387682ec..0f498540 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_pom.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AIPromptPom — generated read-side payload (schema.json $defs schema 'AIPromptPom'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb index 6ec4cf1b..6ab89fc6 100644 --- a/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb +++ b/lib/signalwire/core/swml_verbs_generated/a_i_prompt_text.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AIPromptText — generated read-side payload (schema.json $defs schema 'AIPromptText'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AIPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb b/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb index c662be45..ce116ba1 100644 --- a/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb +++ b/lib/signalwire/core/swml_verbs_generated/ai_sidecar.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # AiSidecar — generated read-side payload (schema.json $defs schema 'AiSidecar'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AiSidecar FIELDS = { 'ai_sidecar' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb b/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb index 25694fd4..1ccf8eca 100644 --- a/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/ai_sidecar_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AiSidecarConfig — generated read-side payload (flattened SWMLMethod verb 'ai_sidecar' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AiSidecarConfig FIELDS = { 'prompt' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/all_of_property.rb b/lib/signalwire/core/swml_verbs_generated/all_of_property.rb index ec969701..ae8ba962 100644 --- a/lib/signalwire/core/swml_verbs_generated/all_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/all_of_property.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AllOfProperty — generated read-side payload (schema.json $defs schema 'AllOfProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AllOfProperty FIELDS = { 'allOf' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb index 545a6195..6e3dd2e3 100644 --- a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb +++ b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # AmazonBedrock — generated read-side payload (schema.json $defs schema 'AmazonBedrock'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AmazonBedrock FIELDS = { 'amazon_bedrock' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb index 770b04af..46b9f2a5 100644 --- a/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/amazon_bedrock_object.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AmazonBedrockObject — generated read-side payload (schema.json $defs schema 'AmazonBedrockObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AmazonBedrockObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/answer.rb b/lib/signalwire/core/swml_verbs_generated/answer.rb index 7773e081..d841fe66 100644 --- a/lib/signalwire/core/swml_verbs_generated/answer.rb +++ b/lib/signalwire/core/swml_verbs_generated/answer.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Answer — generated read-side payload (schema.json $defs schema 'Answer'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Answer FIELDS = { 'answer' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/any_of_property.rb b/lib/signalwire/core/swml_verbs_generated/any_of_property.rb index 67485650..a8c3a463 100644 --- a/lib/signalwire/core/swml_verbs_generated/any_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/any_of_property.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # AnyOfProperty — generated read-side payload (schema.json $defs schema 'AnyOfProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class AnyOfProperty FIELDS = { 'anyOf' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/array_property.rb b/lib/signalwire/core/swml_verbs_generated/array_property.rb index 5a74cd35..a680ca88 100644 --- a/lib/signalwire/core/swml_verbs_generated/array_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/array_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ArrayProperty — generated read-side payload (schema.json $defs schema 'ArrayProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ArrayProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb b/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb index 0ef751f0..6cf96a59 100644 --- a/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/bedrock_params.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # BedrockParams — generated read-side payload (schema.json $defs schema 'BedrockParams'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class BedrockParams FIELDS = { 'attention_timeout' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb b/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb index 35f9c7e3..126abc84 100644 --- a/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb +++ b/lib/signalwire/core/swml_verbs_generated/bedrock_s_w_a_i_g.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # BedrockSWAIG — generated read-side payload (schema.json $defs schema 'BedrockSWAIG'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class BedrockSWAIG FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/core/swml_verbs_generated/boolean_property.rb b/lib/signalwire/core/swml_verbs_generated/boolean_property.rb index 6fd5a873..d1bc3e8b 100644 --- a/lib/signalwire/core/swml_verbs_generated/boolean_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/boolean_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # BooleanProperty — generated read-side payload (schema.json $defs schema 'BooleanProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class BooleanProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/change_context_action.rb b/lib/signalwire/core/swml_verbs_generated/change_context_action.rb index 6b6ce13a..55b82f6a 100644 --- a/lib/signalwire/core/swml_verbs_generated/change_context_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/change_context_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ChangeContextAction — generated read-side payload (schema.json $defs schema 'ChangeContextAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ChangeContextAction FIELDS = { 'change_context' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/change_step_action.rb b/lib/signalwire/core/swml_verbs_generated/change_step_action.rb index 840e928e..0ac35891 100644 --- a/lib/signalwire/core/swml_verbs_generated/change_step_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/change_step_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ChangeStepAction — generated read-side payload (schema.json $defs schema 'ChangeStepAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ChangeStepAction FIELDS = { 'change_step' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/cond.rb b/lib/signalwire/core/swml_verbs_generated/cond.rb index c1e229f5..b48b9944 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Cond — generated read-side payload (schema.json $defs schema 'Cond'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Cond FIELDS = { 'cond' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/cond_else.rb b/lib/signalwire/core/swml_verbs_generated/cond_else.rb index e26a8302..225f4c30 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond_else.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond_else.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # CondElse — generated read-side payload (schema.json $defs schema 'CondElse'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class CondElse FIELDS = { 'else' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/cond_reg.rb b/lib/signalwire/core/swml_verbs_generated/cond_reg.rb index 1f7f728f..2011216e 100644 --- a/lib/signalwire/core/swml_verbs_generated/cond_reg.rb +++ b/lib/signalwire/core/swml_verbs_generated/cond_reg.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # CondReg — generated read-side payload (schema.json $defs schema 'CondReg'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class CondReg FIELDS = { 'when' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect.rb b/lib/signalwire/core/swml_verbs_generated/connect.rb index eab7a5c0..cc267678 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Connect — generated read-side payload (schema.json $defs schema 'Connect'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Connect FIELDS = { 'connect' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/connect_config.rb b/lib/signalwire/core/swml_verbs_generated/connect_config.rb index 1f66f457..6305a6ab 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # ConnectConfig — generated read-side payload (flattened SWMLMethod verb 'connect' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectConfig FIELDS = { 'from' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb index a6b7516b..35bcb2a5 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_parallel.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # ConnectDeviceParallel — generated read-side payload (schema.json $defs schema 'ConnectDeviceParallel'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectDeviceParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb index 4e3166f2..4e584381 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_serial.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # ConnectDeviceSerial — generated read-side payload (schema.json $defs schema 'ConnectDeviceSerial'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectDeviceSerial FIELDS = { 'from' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb index 520a3384..5982a38b 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_serial_parallel.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # ConnectDeviceSerialParallel — generated read-side payload (schema.json $defs schema 'ConnectDeviceSerialParallel'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectDeviceSerialParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb b/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb index 2f13c209..ec4e41c3 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_device_single.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # ConnectDeviceSingle — generated read-side payload (schema.json $defs schema 'ConnectDeviceSingle'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectDeviceSingle FIELDS = { 'from' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_headers.rb b/lib/signalwire/core/swml_verbs_generated/connect_headers.rb index ece6db33..3c81bf9d 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_headers.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_headers.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ConnectHeaders — generated read-side payload (schema.json $defs schema 'ConnectHeaders'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectHeaders FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/connect_switch.rb b/lib/signalwire/core/swml_verbs_generated/connect_switch.rb index b6afe4a1..f0305ead 100644 --- a/lib/signalwire/core/swml_verbs_generated/connect_switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/connect_switch.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ConnectSwitch — generated read-side payload (schema.json $defs schema 'ConnectSwitch'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConnectSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/const_property.rb b/lib/signalwire/core/swml_verbs_generated/const_property.rb index a829ea00..59ca0701 100644 --- a/lib/signalwire/core/swml_verbs_generated/const_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/const_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ConstProperty — generated read-side payload (schema.json $defs schema 'ConstProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConstProperty FIELDS = { 'const' => :any diff --git a/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb b/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb index ca66c197..ff82ca97 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_p_o_m_steps.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ContextPOMSteps — generated read-side payload (schema.json $defs schema 'ContextPOMSteps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ContextPOMSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb b/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb index 9a33f598..b7858644 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_switch_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ContextSwitchAction — generated read-side payload (schema.json $defs schema 'ContextSwitchAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ContextSwitchAction FIELDS = { 'context_switch' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb b/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb index c5380cb9..ec4570ce 100644 --- a/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb +++ b/lib/signalwire/core/swml_verbs_generated/context_text_steps.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ContextTextSteps — generated read-side payload (schema.json $defs schema 'ContextTextSteps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ContextTextSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/contexts.rb b/lib/signalwire/core/swml_verbs_generated/contexts.rb index 65e609fb..9d431888 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Contexts — generated read-side payload (schema.json $defs schema 'Contexts'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Contexts FIELDS = { 'default' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb b/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb index e963ec9a..963e6bf6 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts_p_o_m_object.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ContextsPOMObject — generated read-side payload (schema.json $defs schema 'ContextsPOMObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ContextsPOMObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb b/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb index 506fe131..7cd15e72 100644 --- a/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/contexts_text_object.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ContextsTextObject — generated read-side payload (schema.json $defs schema 'ContextsTextObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ContextsTextObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/core/swml_verbs_generated/conversation_message.rb b/lib/signalwire/core/swml_verbs_generated/conversation_message.rb index adcd7168..82bf018b 100644 --- a/lib/signalwire/core/swml_verbs_generated/conversation_message.rb +++ b/lib/signalwire/core/swml_verbs_generated/conversation_message.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ConversationMessage — generated read-side payload (schema.json $defs schema 'ConversationMessage'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ConversationMessage FIELDS = { 'role' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/data_map.rb b/lib/signalwire/core/swml_verbs_generated/data_map.rb index 92d900ab..b7e3d2c4 100644 --- a/lib/signalwire/core/swml_verbs_generated/data_map.rb +++ b/lib/signalwire/core/swml_verbs_generated/data_map.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # DataMap — generated read-side payload (schema.json $defs schema 'DataMap'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class DataMap FIELDS = { 'output' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/denoise.rb b/lib/signalwire/core/swml_verbs_generated/denoise.rb index ea0cbe35..6a123956 100644 --- a/lib/signalwire/core/swml_verbs_generated/denoise.rb +++ b/lib/signalwire/core/swml_verbs_generated/denoise.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Denoise — generated read-side payload (schema.json $defs schema 'Denoise'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Denoise FIELDS = { 'denoise' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/detect_machine.rb b/lib/signalwire/core/swml_verbs_generated/detect_machine.rb index 3ea844ab..4fe46f0a 100644 --- a/lib/signalwire/core/swml_verbs_generated/detect_machine.rb +++ b/lib/signalwire/core/swml_verbs_generated/detect_machine.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # DetectMachine — generated read-side payload (schema.json $defs schema 'DetectMachine'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class DetectMachine FIELDS = { 'detect_machine' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb b/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb index 8fb012d3..5b305e8c 100644 --- a/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/detect_machine_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # DetectMachineConfig — generated read-side payload (flattened SWMLMethod verb 'detect_machine' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class DetectMachineConfig FIELDS = { 'detect_message_end' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/enter_queue.rb b/lib/signalwire/core/swml_verbs_generated/enter_queue.rb index ac0524b4..f65c9793 100644 --- a/lib/signalwire/core/swml_verbs_generated/enter_queue.rb +++ b/lib/signalwire/core/swml_verbs_generated/enter_queue.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # EnterQueue — generated read-side payload (schema.json $defs schema 'EnterQueue'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class EnterQueue FIELDS = { 'enter_queue' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb b/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb index a47893aa..af620b45 100644 --- a/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/enter_queue_object.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # EnterQueueObject — generated read-side payload (schema.json $defs schema 'EnterQueueObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class EnterQueueObject FIELDS = { 'queue_name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/execute.rb b/lib/signalwire/core/swml_verbs_generated/execute.rb index bdbbff5e..b677f530 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Execute — generated read-side payload (schema.json $defs schema 'Execute'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Execute FIELDS = { 'execute' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/execute_config.rb b/lib/signalwire/core/swml_verbs_generated/execute_config.rb index 54ec1d15..122db8e9 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ExecuteConfig — generated read-side payload (flattened SWMLMethod verb 'execute' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ExecuteConfig FIELDS = { 'dest' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/execute_switch.rb b/lib/signalwire/core/swml_verbs_generated/execute_switch.rb index 743af79b..fbcf9d48 100644 --- a/lib/signalwire/core/swml_verbs_generated/execute_switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/execute_switch.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ExecuteSwitch — generated read-side payload (schema.json $defs schema 'ExecuteSwitch'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ExecuteSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/expression.rb b/lib/signalwire/core/swml_verbs_generated/expression.rb index f0efde2e..fd436ae5 100644 --- a/lib/signalwire/core/swml_verbs_generated/expression.rb +++ b/lib/signalwire/core/swml_verbs_generated/expression.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Expression — generated read-side payload (schema.json $defs schema 'Expression'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Expression FIELDS = { 'string' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/function_parameters.rb b/lib/signalwire/core/swml_verbs_generated/function_parameters.rb index 7bcaa29f..3e98a930 100644 --- a/lib/signalwire/core/swml_verbs_generated/function_parameters.rb +++ b/lib/signalwire/core/swml_verbs_generated/function_parameters.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # FunctionParameters — generated read-side payload (schema.json $defs schema 'FunctionParameters'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class FunctionParameters FIELDS = { 'type' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/goto.rb b/lib/signalwire/core/swml_verbs_generated/goto.rb index eec851a1..6b80b0b6 100644 --- a/lib/signalwire/core/swml_verbs_generated/goto.rb +++ b/lib/signalwire/core/swml_verbs_generated/goto.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Goto — generated read-side payload (schema.json $defs schema 'Goto'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Goto FIELDS = { 'goto' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/goto_config.rb b/lib/signalwire/core/swml_verbs_generated/goto_config.rb index 0cb0de2d..d6018816 100644 --- a/lib/signalwire/core/swml_verbs_generated/goto_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/goto_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # GotoConfig — generated read-side payload (flattened SWMLMethod verb 'goto' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class GotoConfig FIELDS = { 'label' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb index b97906c2..155148d7 100644 --- a/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/hang_up_hook_s_w_a_i_g_function.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # HangUpHookSWAIGFunction — generated read-side payload (schema.json $defs schema 'HangUpHookSWAIGFunction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class HangUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/hangup.rb b/lib/signalwire/core/swml_verbs_generated/hangup.rb index 5727588e..13410809 100644 --- a/lib/signalwire/core/swml_verbs_generated/hangup.rb +++ b/lib/signalwire/core/swml_verbs_generated/hangup.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Hangup — generated read-side payload (schema.json $defs schema 'Hangup'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Hangup FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/hangup_action.rb b/lib/signalwire/core/swml_verbs_generated/hangup_action.rb index d3357491..4008a9be 100644 --- a/lib/signalwire/core/swml_verbs_generated/hangup_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/hangup_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # HangupAction — generated read-side payload (schema.json $defs schema 'HangupAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class HangupAction FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/hint.rb b/lib/signalwire/core/swml_verbs_generated/hint.rb index 7dda897a..07fc1047 100644 --- a/lib/signalwire/core/swml_verbs_generated/hint.rb +++ b/lib/signalwire/core/swml_verbs_generated/hint.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Hint — generated read-side payload (schema.json $defs schema 'Hint'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Hint FIELDS = { 'hint' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/hold_action.rb b/lib/signalwire/core/swml_verbs_generated/hold_action.rb index 9f7a1502..5f1d80c2 100644 --- a/lib/signalwire/core/swml_verbs_generated/hold_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/hold_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # HoldAction — generated read-side payload (schema.json $defs schema 'HoldAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class HoldAction FIELDS = { 'hold' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/inject_action.rb b/lib/signalwire/core/swml_verbs_generated/inject_action.rb index 73c0ae55..b1ee3848 100644 --- a/lib/signalwire/core/swml_verbs_generated/inject_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/inject_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # InjectAction — generated read-side payload (schema.json $defs schema 'InjectAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class InjectAction FIELDS = { 'inject' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/integer_property.rb b/lib/signalwire/core/swml_verbs_generated/integer_property.rb index 9019e161..9833853e 100644 --- a/lib/signalwire/core/swml_verbs_generated/integer_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/integer_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # IntegerProperty — generated read-side payload (schema.json $defs schema 'IntegerProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class IntegerProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/join_conference.rb b/lib/signalwire/core/swml_verbs_generated/join_conference.rb index 86ce4daa..4901bede 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_conference.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_conference.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # JoinConference — generated read-side payload (schema.json $defs schema 'JoinConference'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class JoinConference FIELDS = { 'join_conference' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb b/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb index 5ed4424b..e18761fc 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_conference_object.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # JoinConferenceObject — generated read-side payload (schema.json $defs schema 'JoinConferenceObject'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class JoinConferenceObject FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/join_room.rb b/lib/signalwire/core/swml_verbs_generated/join_room.rb index 91a111a1..c19d4d17 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_room.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_room.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # JoinRoom — generated read-side payload (schema.json $defs schema 'JoinRoom'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class JoinRoom FIELDS = { 'join_room' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/join_room_config.rb b/lib/signalwire/core/swml_verbs_generated/join_room_config.rb index 2d763957..b678d8c4 100644 --- a/lib/signalwire/core/swml_verbs_generated/join_room_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/join_room_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # JoinRoomConfig — generated read-side payload (flattened SWMLMethod verb 'join_room' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class JoinRoomConfig FIELDS = { 'name' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/label.rb b/lib/signalwire/core/swml_verbs_generated/label.rb index fb9e86c3..2346216f 100644 --- a/lib/signalwire/core/swml_verbs_generated/label.rb +++ b/lib/signalwire/core/swml_verbs_generated/label.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Label — generated read-side payload (schema.json $defs schema 'Label'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Label FIELDS = { 'label' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/language_params.rb b/lib/signalwire/core/swml_verbs_generated/language_params.rb index e67dffa3..3ffc3c31 100644 --- a/lib/signalwire/core/swml_verbs_generated/language_params.rb +++ b/lib/signalwire/core/swml_verbs_generated/language_params.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LanguageParams — generated read-side payload (schema.json $defs schema 'LanguageParams'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LanguageParams FIELDS = { 'stability' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb b/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb index 09221f97..933156bb 100644 --- a/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb +++ b/lib/signalwire/core/swml_verbs_generated/languages_with_fillers.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LanguagesWithFillers — generated read-side payload (schema.json $defs schema 'LanguagesWithFillers'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LanguagesWithFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb b/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb index 024b87a3..fc8b6006 100644 --- a/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb +++ b/lib/signalwire/core/swml_verbs_generated/languages_with_solo_fillers.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LanguagesWithSoloFillers — generated read-side payload (schema.json $defs schema 'LanguagesWithSoloFillers'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LanguagesWithSoloFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb b/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb index 1bbdd9a7..8bb39bbd 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_transcribe.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LiveTranscribe — generated read-side payload (schema.json $defs schema 'LiveTranscribe'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LiveTranscribe FIELDS = { 'live_transcribe' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb b/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb index 844c05fc..3a5eda6c 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_transcribe_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LiveTranscribeConfig — generated read-side payload (flattened SWMLMethod verb 'live_transcribe' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LiveTranscribeConfig FIELDS = { 'action' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/live_translate.rb b/lib/signalwire/core/swml_verbs_generated/live_translate.rb index ca475c92..a12c0402 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_translate.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_translate.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LiveTranslate — generated read-side payload (schema.json $defs schema 'LiveTranslate'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LiveTranslate FIELDS = { 'live_translate' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb b/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb index 7d22a020..2d01d2a4 100644 --- a/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/live_translate_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # LiveTranslateConfig — generated read-side payload (flattened SWMLMethod verb 'live_translate' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class LiveTranslateConfig FIELDS = { 'action' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/null_property.rb b/lib/signalwire/core/swml_verbs_generated/null_property.rb index 06772a13..669ad599 100644 --- a/lib/signalwire/core/swml_verbs_generated/null_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/null_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # NullProperty — generated read-side payload (schema.json $defs schema 'NullProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class NullProperty FIELDS = { 'type' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/number_property.rb b/lib/signalwire/core/swml_verbs_generated/number_property.rb index eada8161..b6ee904c 100644 --- a/lib/signalwire/core/swml_verbs_generated/number_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/number_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # NumberProperty — generated read-side payload (schema.json $defs schema 'NumberProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class NumberProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/object_property.rb b/lib/signalwire/core/swml_verbs_generated/object_property.rb index f1de2e38..c60d2402 100644 --- a/lib/signalwire/core/swml_verbs_generated/object_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/object_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ObjectProperty — generated read-side payload (schema.json $defs schema 'ObjectProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ObjectProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb index 5565fa0c..29d1915c 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_pompt_text_omitted_prompt_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # OmitPropertiesBedrockPostPomptTextOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPostPomptTextOmittedPromptProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class OmitPropertiesBedrockPostPomptTextOmittedPromptProps FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb index 793eebf3..ef8e8814 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_post_prompt_pom_omitted_prompt_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # OmitPropertiesBedrockPostPromptPomOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPostPromptPomOmittedPromptProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class OmitPropertiesBedrockPostPromptPomOmittedPromptProps FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb index bf88953a..de82fbfd 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_pom_omitted_prompt_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # OmitPropertiesBedrockPromptPomOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPromptPomOmittedPromptProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class OmitPropertiesBedrockPromptPomOmittedPromptProps FIELDS = { 'voice_id' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb index b8833262..1562a878 100644 --- a/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/omit_properties_bedrock_prompt_text_omitted_prompt_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # OmitPropertiesBedrockPromptTextOmittedPromptProps — generated read-side payload (schema.json $defs schema 'OmitPropertiesBedrockPromptTextOmittedPromptProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class OmitPropertiesBedrockPromptTextOmittedPromptProps FIELDS = { 'voice_id' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/one_of_property.rb b/lib/signalwire/core/swml_verbs_generated/one_of_property.rb index 667f6c2b..31d52913 100644 --- a/lib/signalwire/core/swml_verbs_generated/one_of_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/one_of_property.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # OneOfProperty — generated read-side payload (schema.json $defs schema 'OneOfProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class OneOfProperty FIELDS = { 'oneOf' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/output.rb b/lib/signalwire/core/swml_verbs_generated/output.rb index c5219d40..aa3a87c9 100644 --- a/lib/signalwire/core/swml_verbs_generated/output.rb +++ b/lib/signalwire/core/swml_verbs_generated/output.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Output — generated read-side payload (schema.json $defs schema 'Output'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Output FIELDS = { 'response' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pay.rb b/lib/signalwire/core/swml_verbs_generated/pay.rb index 7f0041bf..30420794 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Pay — generated read-side payload (schema.json $defs schema 'Pay'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Pay FIELDS = { 'pay' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/pay_config.rb b/lib/signalwire/core/swml_verbs_generated/pay_config.rb index a990a9b9..78cce2ae 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PayConfig — generated read-side payload (flattened SWMLMethod verb 'pay' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PayConfig FIELDS = { 'payment_connector_url' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb b/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb index 2e189bd4..c039579d 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_parameters.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PayParameters — generated read-side payload (schema.json $defs schema 'PayParameters'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PayParameters FIELDS = { 'name' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb index dec47ba3..ddbbf789 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompt_play_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PayPromptPlayAction — generated read-side payload (schema.json $defs schema 'PayPromptPlayAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PayPromptPlayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb index a39201b1..bcc624bf 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompt_say_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PayPromptSayAction — generated read-side payload (schema.json $defs schema 'PayPromptSayAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PayPromptSayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb b/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb index 15ffb696..00d5a545 100644 --- a/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb +++ b/lib/signalwire/core/swml_verbs_generated/pay_prompts.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PayPrompts — generated read-side payload (schema.json $defs schema 'PayPrompts'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PayPrompts FIELDS = { 'actions' => :array, diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index ab6457e2..c4206dfa 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_hang_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PickPropertiesHangUpHookSWAIGFunctionPickedSWAIGFunctionProps FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index 21d19b25..d9e174ae 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_start_up_hook_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PickPropertiesStartUpHookSWAIGFunctionPickedSWAIGFunctionProps FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index ae311dd7..5c832840 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_summarize_conversation_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PickPropertiesSummarizeConversationSWAIGFunctionPickedSWAIGFunctionProps FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb b/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb index 71d0cfd0..ae1b30c3 100644 --- a/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb +++ b/lib/signalwire/core/swml_verbs_generated/pick_properties_user_s_w_a_i_g_function_picked_s_w_a_i_g_function_props.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps — generated read-side payload (schema.json $defs schema 'PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PickPropertiesUserSWAIGFunctionPickedSWAIGFunctionProps FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/play.rb b/lib/signalwire/core/swml_verbs_generated/play.rb index 1b7373d3..27112587 100644 --- a/lib/signalwire/core/swml_verbs_generated/play.rb +++ b/lib/signalwire/core/swml_verbs_generated/play.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Play — generated read-side payload (schema.json $defs schema 'Play'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Play FIELDS = { 'play' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb index 0eb681e1..ed003dfa 100644 --- a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb +++ b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PlayWithURL — generated read-side payload (schema.json $defs schema 'PlayWithURL'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PlayWithURL FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb index 0039e7e8..013fc434 100644 --- a/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb +++ b/lib/signalwire/core/swml_verbs_generated/play_with_u_r_l_s.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PlayWithURLS — generated read-side payload (schema.json $defs schema 'PlayWithURLS'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PlayWithURLS FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb b/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb index 20477198..52b5a1b2 100644 --- a/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/playback_b_g_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # PlaybackBGAction — generated read-side payload (schema.json $defs schema 'PlaybackBGAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PlaybackBGAction FIELDS = { 'playback_bg' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb b/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb index cca5a0f8..dc8c643d 100644 --- a/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb +++ b/lib/signalwire/core/swml_verbs_generated/pom_section_body_content.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PomSectionBodyContent — generated read-side payload (schema.json $defs schema 'PomSectionBodyContent'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PomSectionBodyContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb b/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb index d284f98b..03f8b572 100644 --- a/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb +++ b/lib/signalwire/core/swml_verbs_generated/pom_section_bullets_content.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PomSectionBulletsContent — generated read-side payload (schema.json $defs schema 'PomSectionBulletsContent'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PomSectionBulletsContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/prompt.rb b/lib/signalwire/core/swml_verbs_generated/prompt.rb index d446ece6..f3c36eab 100644 --- a/lib/signalwire/core/swml_verbs_generated/prompt.rb +++ b/lib/signalwire/core/swml_verbs_generated/prompt.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Prompt — generated read-side payload (schema.json $defs schema 'Prompt'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Prompt FIELDS = { 'prompt' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/prompt_config.rb b/lib/signalwire/core/swml_verbs_generated/prompt_config.rb index b1a89233..5e2951f9 100644 --- a/lib/signalwire/core/swml_verbs_generated/prompt_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/prompt_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # PromptConfig — generated read-side payload (flattened SWMLMethod verb 'prompt' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class PromptConfig FIELDS = { 'play' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/pronounce.rb b/lib/signalwire/core/swml_verbs_generated/pronounce.rb index c5eac36c..4c0a84ce 100644 --- a/lib/signalwire/core/swml_verbs_generated/pronounce.rb +++ b/lib/signalwire/core/swml_verbs_generated/pronounce.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Pronounce — generated read-side payload (schema.json $defs schema 'Pronounce'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Pronounce FIELDS = { 'replace' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/receive_fax.rb b/lib/signalwire/core/swml_verbs_generated/receive_fax.rb index 11033071..813bb68e 100644 --- a/lib/signalwire/core/swml_verbs_generated/receive_fax.rb +++ b/lib/signalwire/core/swml_verbs_generated/receive_fax.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ReceiveFax — generated read-side payload (schema.json $defs schema 'ReceiveFax'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ReceiveFax FIELDS = { 'receive_fax' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb b/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb index 3c2705ab..e797ff15 100644 --- a/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/receive_fax_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ReceiveFaxConfig — generated read-side payload (flattened SWMLMethod verb 'receive_fax' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ReceiveFaxConfig FIELDS = { 'status_url' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/record.rb b/lib/signalwire/core/swml_verbs_generated/record.rb index cd84b8e7..1f42cd8b 100644 --- a/lib/signalwire/core/swml_verbs_generated/record.rb +++ b/lib/signalwire/core/swml_verbs_generated/record.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Record — generated read-side payload (schema.json $defs schema 'Record'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Record FIELDS = { 'record' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/record_call.rb b/lib/signalwire/core/swml_verbs_generated/record_call.rb index 56dfac95..3c6a061e 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_call.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_call.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # RecordCall — generated read-side payload (schema.json $defs schema 'RecordCall'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class RecordCall FIELDS = { 'record_call' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/record_call_config.rb b/lib/signalwire/core/swml_verbs_generated/record_call_config.rb index 50ecb0f9..60b44101 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_call_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_call_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # RecordCallConfig — generated read-side payload (flattened SWMLMethod verb 'record_call' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class RecordCallConfig FIELDS = { 'control_id' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/record_config.rb b/lib/signalwire/core/swml_verbs_generated/record_config.rb index 8397011a..0c433d6b 100644 --- a/lib/signalwire/core/swml_verbs_generated/record_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/record_config.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # RecordConfig — generated read-side payload (flattened SWMLMethod verb 'record' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class RecordConfig FIELDS = { 'stereo' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/request.rb b/lib/signalwire/core/swml_verbs_generated/request.rb index 794c6f89..06f54cad 100644 --- a/lib/signalwire/core/swml_verbs_generated/request.rb +++ b/lib/signalwire/core/swml_verbs_generated/request.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Request — generated read-side payload (schema.json $defs schema 'Request'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Request FIELDS = { 'request' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/request_config.rb b/lib/signalwire/core/swml_verbs_generated/request_config.rb index f11d5935..e1a88664 100644 --- a/lib/signalwire/core/swml_verbs_generated/request_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/request_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # RequestConfig — generated read-side payload (flattened SWMLMethod verb 'request' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class RequestConfig FIELDS = { 'url' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/return.rb b/lib/signalwire/core/swml_verbs_generated/return.rb index 9693cfa3..fbd26327 100644 --- a/lib/signalwire/core/swml_verbs_generated/return.rb +++ b/lib/signalwire/core/swml_verbs_generated/return.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Return — generated read-side payload (schema.json $defs schema 'Return'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Return FIELDS = { 'return' => :any diff --git a/lib/signalwire/core/swml_verbs_generated/ringback_config.rb b/lib/signalwire/core/swml_verbs_generated/ringback_config.rb index 626af242..c6d87ee6 100644 --- a/lib/signalwire/core/swml_verbs_generated/ringback_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/ringback_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # RingbackConfig — generated read-side payload (schema.json $defs schema 'RingbackConfig'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class RingbackConfig FIELDS = { 'url' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb b/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb index bda40631..b62ea855 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_i_p_refer.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SIPRefer — generated read-side payload (schema.json $defs schema 'SIPRefer'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SIPRefer FIELDS = { 'sip_refer' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb index 3d4d04aa..7a0a3c18 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_body.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SMSWithBody — generated read-side payload (schema.json $defs schema 'SMSWithBody'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SMSWithBody FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb index e07b9645..128fc6c8 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_m_s_with_media.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SMSWithMedia — generated read-side payload (schema.json $defs schema 'SMSWithMedia'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SMSWithMedia FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb index 4558a4de..26d16da1 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SWAIG — generated read-side payload (schema.json $defs schema 'SWAIG'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SWAIG FIELDS = { 'defaults' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb index c5a7820e..796d61e5 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_defaults.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SWAIGDefaults — generated read-side payload (schema.json $defs schema 'SWAIGDefaults'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SWAIGDefaults FIELDS = { 'web_hook_url' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb index cd5fd408..30ea4dbb 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_includes.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SWAIGIncludes — generated read-side payload (schema.json $defs schema 'SWAIGIncludes'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SWAIGIncludes FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb index b56f05e4..b3d54e77 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_a_i_g_internal_filler.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # SWAIGInternalFiller — generated read-side payload (schema.json $defs schema 'SWAIGInternalFiller'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SWAIGInternalFiller FIELDS = { 'hangup' => :object, diff --git a/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb b/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb index c96bc72b..1b88f549 100644 --- a/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/s_w_m_l_action.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # SWMLAction — generated read-side payload (schema.json $defs schema 'SWMLAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SWMLAction FIELDS = { 'SWML' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/say_action.rb b/lib/signalwire/core/swml_verbs_generated/say_action.rb index 0efa7178..67d998a2 100644 --- a/lib/signalwire/core/swml_verbs_generated/say_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/say_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SayAction — generated read-side payload (schema.json $defs schema 'SayAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SayAction FIELDS = { 'say' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/section.rb b/lib/signalwire/core/swml_verbs_generated/section.rb index b19bc960..0d693558 100644 --- a/lib/signalwire/core/swml_verbs_generated/section.rb +++ b/lib/signalwire/core/swml_verbs_generated/section.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Section — generated read-side payload (schema.json $defs schema 'Section'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Section FIELDS = { 'main' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/send_digits.rb b/lib/signalwire/core/swml_verbs_generated/send_digits.rb index 24dc3134..9da9c727 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_digits.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_digits.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SendDigits — generated read-side payload (schema.json $defs schema 'SendDigits'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SendDigits FIELDS = { 'send_digits' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb b/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb index 7eb7f441..7646bfc3 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_digits_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SendDigitsConfig — generated read-side payload (flattened SWMLMethod verb 'send_digits' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SendDigitsConfig FIELDS = { 'digits' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/send_fax.rb b/lib/signalwire/core/swml_verbs_generated/send_fax.rb index 8ea48273..37664495 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_fax.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_fax.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SendFax — generated read-side payload (schema.json $defs schema 'SendFax'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SendFax FIELDS = { 'send_fax' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb b/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb index 400667ba..79c17274 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_fax_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SendFaxConfig — generated read-side payload (flattened SWMLMethod verb 'send_fax' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SendFaxConfig FIELDS = { 'document' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb b/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb index 170e9b65..f013b5d8 100644 --- a/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb +++ b/lib/signalwire/core/swml_verbs_generated/send_s_m_s.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SendSMS — generated read-side payload (schema.json $defs schema 'SendSMS'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SendSMS FIELDS = { 'send_sms' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/set.rb b/lib/signalwire/core/swml_verbs_generated/set.rb index c42f2abb..cfe286ff 100644 --- a/lib/signalwire/core/swml_verbs_generated/set.rb +++ b/lib/signalwire/core/swml_verbs_generated/set.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Set — generated read-side payload (schema.json $defs schema 'Set'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Set FIELDS = { 'set' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb b/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb index 2112787a..71f16683 100644 --- a/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/set_global_data_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SetGlobalDataAction — generated read-side payload (schema.json $defs schema 'SetGlobalDataAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SetGlobalDataAction FIELDS = { 'set_global_data' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb b/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb index 2e1745ff..60563e5f 100644 --- a/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/set_meta_data_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SetMetaDataAction — generated read-side payload (schema.json $defs schema 'SetMetaDataAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SetMetaDataAction FIELDS = { 'set_meta_data' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb b/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb index f9cce9a8..9cc36bf3 100644 --- a/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/sip_refer_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SipReferConfig — generated read-side payload (flattened SWMLMethod verb 'sip_refer' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SipReferConfig FIELDS = { 'to_uri' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/sleep.rb b/lib/signalwire/core/swml_verbs_generated/sleep.rb index e2d8575b..167cd9a0 100644 --- a/lib/signalwire/core/swml_verbs_generated/sleep.rb +++ b/lib/signalwire/core/swml_verbs_generated/sleep.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Sleep — generated read-side payload (schema.json $defs schema 'Sleep'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Sleep FIELDS = { 'sleep' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/start_action.rb b/lib/signalwire/core/swml_verbs_generated/start_action.rb index 67a05947..f67f8a57 100644 --- a/lib/signalwire/core/swml_verbs_generated/start_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/start_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StartAction — generated read-side payload (schema.json $defs schema 'StartAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb index a4366f3f..4636b7ba 100644 --- a/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/start_up_hook_s_w_a_i_g_function.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # StartUpHookSWAIGFunction — generated read-side payload (schema.json $defs schema 'StartUpHookSWAIGFunction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StartUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/stop_action.rb b/lib/signalwire/core/swml_verbs_generated/stop_action.rb index 0b13958b..8711f950 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopAction — generated read-side payload (schema.json $defs schema 'StopAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopAction FIELDS = { 'stop' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb b/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb index c791bd7d..5d95bec2 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_denoise.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopDenoise — generated read-side payload (schema.json $defs schema 'StopDenoise'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopDenoise FIELDS = { 'stop_denoise' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb b/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb index 6399f85f..afd0053c 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_playback_b_g_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopPlaybackBGAction — generated read-side payload (schema.json $defs schema 'StopPlaybackBGAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopPlaybackBGAction FIELDS = { 'stop_playback_bg' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb b/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb index 2a4cb15a..d3efd16b 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_record_call.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopRecordCall — generated read-side payload (schema.json $defs schema 'StopRecordCall'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopRecordCall FIELDS = { 'stop_record_call' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb b/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb index 0a706017..23936721 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_record_call_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopRecordCallConfig — generated read-side payload (flattened SWMLMethod verb 'stop_record_call' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopRecordCallConfig FIELDS = { 'control_id' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/stop_tap.rb b/lib/signalwire/core/swml_verbs_generated/stop_tap.rb index d2f172b0..32c95324 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_tap.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_tap.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopTap — generated read-side payload (schema.json $defs schema 'StopTap'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopTap FIELDS = { 'stop_tap' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb b/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb index 2c465277..e9e772e0 100644 --- a/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/stop_tap_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StopTapConfig — generated read-side payload (flattened SWMLMethod verb 'stop_tap' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StopTapConfig FIELDS = { 'control_id' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/string_property.rb b/lib/signalwire/core/swml_verbs_generated/string_property.rb index d4b94a9c..db46156e 100644 --- a/lib/signalwire/core/swml_verbs_generated/string_property.rb +++ b/lib/signalwire/core/swml_verbs_generated/string_property.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # StringProperty — generated read-side payload (schema.json $defs schema 'StringProperty'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class StringProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/summarize_action.rb b/lib/signalwire/core/swml_verbs_generated/summarize_action.rb index 36147a78..c6209e6e 100644 --- a/lib/signalwire/core/swml_verbs_generated/summarize_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/summarize_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SummarizeAction — generated read-side payload (schema.json $defs schema 'SummarizeAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb index bec73f28..10bf59f9 100644 --- a/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/summarize_conversation_s_w_a_i_g_function.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # SummarizeConversationSWAIGFunction — generated read-side payload (schema.json $defs schema 'SummarizeConversationSWAIGFunction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SummarizeConversationSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/switch.rb b/lib/signalwire/core/swml_verbs_generated/switch.rb index 131ac577..c4592332 100644 --- a/lib/signalwire/core/swml_verbs_generated/switch.rb +++ b/lib/signalwire/core/swml_verbs_generated/switch.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Switch — generated read-side payload (schema.json $defs schema 'Switch'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Switch FIELDS = { 'switch' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/switch_config.rb b/lib/signalwire/core/swml_verbs_generated/switch_config.rb index b81b29e8..2b8b85b7 100644 --- a/lib/signalwire/core/swml_verbs_generated/switch_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/switch_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # SwitchConfig — generated read-side payload (flattened SWMLMethod verb 'switch' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class SwitchConfig FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/tap.rb b/lib/signalwire/core/swml_verbs_generated/tap.rb index c0392858..410027c5 100644 --- a/lib/signalwire/core/swml_verbs_generated/tap.rb +++ b/lib/signalwire/core/swml_verbs_generated/tap.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Tap — generated read-side payload (schema.json $defs schema 'Tap'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Tap FIELDS = { 'tap' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/tap_config.rb b/lib/signalwire/core/swml_verbs_generated/tap_config.rb index ea62425d..e1dd10e5 100644 --- a/lib/signalwire/core/swml_verbs_generated/tap_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/tap_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # TapConfig — generated read-side payload (flattened SWMLMethod verb 'tap' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class TapConfig FIELDS = { 'uri' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb b/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb index d1aa4f6e..e5d31345 100644 --- a/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/toggle_functions_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # ToggleFunctionsAction — generated read-side payload (schema.json $defs schema 'ToggleFunctionsAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class ToggleFunctionsAction FIELDS = { 'toggle_functions' => :array diff --git a/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb b/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb index 533f07f7..bcc149f6 100644 --- a/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/transcribe_start_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # TranscribeStartAction — generated read-side payload (schema.json $defs schema 'TranscribeStartAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class TranscribeStartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb b/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb index 8990cdab..c41111b2 100644 --- a/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/transcribe_summarize_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # TranscribeSummarizeAction — generated read-side payload (schema.json $defs schema 'TranscribeSummarizeAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class TranscribeSummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/transfer.rb b/lib/signalwire/core/swml_verbs_generated/transfer.rb index 641195c1..d655a633 100644 --- a/lib/signalwire/core/swml_verbs_generated/transfer.rb +++ b/lib/signalwire/core/swml_verbs_generated/transfer.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Transfer — generated read-side payload (schema.json $defs schema 'Transfer'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Transfer FIELDS = { 'transfer' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/transfer_config.rb b/lib/signalwire/core/swml_verbs_generated/transfer_config.rb index 194cb00a..a9f9d7b2 100644 --- a/lib/signalwire/core/swml_verbs_generated/transfer_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/transfer_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # TransferConfig — generated read-side payload (flattened SWMLMethod verb 'transfer' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class TransferConfig FIELDS = { 'dest' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/unset.rb b/lib/signalwire/core/swml_verbs_generated/unset.rb index d9639d23..8463d1d9 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # Unset — generated read-side payload (schema.json $defs schema 'Unset'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Unset FIELDS = { 'unset' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb b/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb index f81cd335..3c6f6cad 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset_global_data_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # UnsetGlobalDataAction — generated read-side payload (schema.json $defs schema 'UnsetGlobalDataAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UnsetGlobalDataAction FIELDS = { 'unset_global_data' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb b/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb index ea41eb74..92f4da93 100644 --- a/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/unset_meta_data_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # UnsetMetaDataAction — generated read-side payload (schema.json $defs schema 'UnsetMetaDataAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UnsetMetaDataAction FIELDS = { 'unset_meta_data' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/user_event.rb b/lib/signalwire/core/swml_verbs_generated/user_event.rb index 36727969..b1fa2d9a 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_event.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_event.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # UserEvent — generated read-side payload (schema.json $defs schema 'UserEvent'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UserEvent FIELDS = { 'user_event' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/user_event_config.rb b/lib/signalwire/core/swml_verbs_generated/user_event_config.rb index 7c5d1fc1..f62adf40 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_event_config.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_event_config.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # UserEventConfig — generated read-side payload (flattened SWMLMethod verb 'user_event' config). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UserEventConfig FIELDS = { 'event' => :object diff --git a/lib/signalwire/core/swml_verbs_generated/user_input_action.rb b/lib/signalwire/core/swml_verbs_generated/user_input_action.rb index a81ae67f..8101d5ea 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_input_action.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_input_action.rb @@ -16,8 +16,8 @@ module SwmlVerbsGenerated # UserInputAction — generated read-side payload (schema.json $defs schema 'UserInputAction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UserInputAction FIELDS = { 'user_input' => :string diff --git a/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb b/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb index 5ac3ed65..73739512 100644 --- a/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb +++ b/lib/signalwire/core/swml_verbs_generated/user_s_w_a_i_g_function.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # UserSWAIGFunction — generated read-side payload (schema.json $defs schema 'UserSWAIGFunction'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class UserSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/core/swml_verbs_generated/webhook.rb b/lib/signalwire/core/swml_verbs_generated/webhook.rb index b4ff484f..f1f41917 100644 --- a/lib/signalwire/core/swml_verbs_generated/webhook.rb +++ b/lib/signalwire/core/swml_verbs_generated/webhook.rb @@ -17,8 +17,8 @@ module SwmlVerbsGenerated # Webhook — generated read-side payload (schema.json $defs schema 'Webhook'). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # A zero-arg reader per field mirrors the reference's recorded - # accessors (dropped on the SURFACE by the enumerator — method-less there). + # Each field also has a zero-arg reader, so a decoded payload can be + # accessed by name rather than by wire key. class Webhook FIELDS = { 'expressions' => :array, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb index 124a140d..55801d7e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiHoldParams — generated data type (RELAY method 'calling.ai_hold', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiHoldParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb index a415e9de..e6aba779 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_hold_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiHoldResult — generated data type (RELAY method 'calling.ai_hold', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiHoldResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb index 4f834492..15c8f639 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiMessageParams — generated data type (RELAY method 'calling.ai_message', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiMessageParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb index 9eb6ce64..52bf9084 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_message_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiMessageResult — generated data type (RELAY method 'calling.ai_message', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiMessageResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb index d7e5831c..df6a7466 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiUnholdParams — generated data type (RELAY method 'calling.ai_unhold', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiUnholdParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb index 2fc3cbbb..310cb118 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_ai_unhold_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAiUnholdResult — generated data type (RELAY method 'calling.ai_unhold', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAiUnholdResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb index 0c2272fb..7e333a7c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAmazonBedrockParams — generated data type (RELAY method 'calling.amazon_bedrock', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAmazonBedrockParams FIELDS = { 'SWAIG' => :any, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb index df7ed381..f73fd4bf 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_amazon_bedrock_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAmazonBedrockResult — generated data type (RELAY method 'calling.amazon_bedrock', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAmazonBedrockResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb index 1b93c093..9544120c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_answer_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAnswerParams — generated data type (RELAY method 'calling.answer', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAnswerParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb index 0dedeb25..a680a2e6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_answer_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingAnswerResult — generated data type (RELAY method 'calling.answer', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingAnswerResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb index 73736179..b9a9357a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_begin_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingBeginParams — generated data type (RELAY method 'calling.begin', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingBeginParams FIELDS = { 'device' => :object, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb index e05160f1..fe5d4678 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_begin_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingBeginResult — generated data type (RELAY method 'calling.begin', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingBeginResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb index cd3235df..7c0e3529 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingBindDigitParams — generated data type (RELAY method 'calling.bind_digit', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingBindDigitParams FIELDS = { 'bind_method' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb index d2a1a4a4..e0a94401 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_bind_digit_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingBindDigitResult — generated data type (RELAY method 'calling.bind_digit', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingBindDigitResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb index 54ef1057..60c8eece 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingClearDigitBindingsParams — generated data type (RELAY method 'calling.clear_digit_bindings', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingClearDigitBindingsParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb index c0e2ce2c..0556d21a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_clear_digit_bindings_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingClearDigitBindingsResult — generated data type (RELAY method 'calling.clear_digit_bindings', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingClearDigitBindingsResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb index 9d5a0cc5..b96fc481 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingCollectParams — generated data type (RELAY method 'calling.collect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb index 45c9e51d..b9b717d9 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingCollectResult — generated data type (RELAY method 'calling.collect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb index 233e853f..4567f489 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_params.rb @@ -17,8 +17,8 @@ module ProtocolTypesGenerated # CallingCollectStartInputTimersParams — generated data type (RELAY method 'calling.collect.start_input_timers', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectStartInputTimersParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb index bbdf48d6..a1e95cc6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_start_input_timers_result.rb @@ -17,8 +17,8 @@ module ProtocolTypesGenerated # CallingCollectStartInputTimersResult — generated data type (RELAY method 'calling.collect.start_input_timers', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectStartInputTimersResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb index bd402ae4..4a347370 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingCollectStopParams — generated data type (RELAY method 'calling.collect.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb index 0e25039a..ebf44098 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_collect_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingCollectStopResult — generated data type (RELAY method 'calling.collect.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingCollectStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb index 76fd726f..32b1bdd7 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_connect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingConnectParams — generated data type (RELAY method 'calling.connect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingConnectParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb index 46867a7e..c8b5ea42 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_connect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingConnectResult — generated data type (RELAY method 'calling.connect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingConnectResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb index 556e2026..34704ef7 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDenoiseParams — generated data type (RELAY method 'calling.denoise', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDenoiseParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb index 77aeeebd..10307a67 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDenoiseResult — generated data type (RELAY method 'calling.denoise', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDenoiseResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb index b7cde6df..f6787838 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDenoiseStopParams — generated data type (RELAY method 'calling.denoise.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDenoiseStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb index 58a2aa54..b96fdb1c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_denoise_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDenoiseStopResult — generated data type (RELAY method 'calling.denoise.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDenoiseStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb index 6d3f3b0e..54961d45 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDetectParams — generated data type (RELAY method 'calling.detect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDetectParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb index 13d50184..1c0ffee2 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDetectResult — generated data type (RELAY method 'calling.detect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDetectResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb index f3854fc9..0b42c0f7 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDetectStopParams — generated data type (RELAY method 'calling.detect.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDetectStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb index 6287d23f..a4b5b2ca 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_detect_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDetectStopResult — generated data type (RELAY method 'calling.detect.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDetectStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb index a638085d..65caed05 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_dial_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDialParams — generated data type (RELAY method 'calling.dial', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDialParams FIELDS = { 'devices' => :array, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb index 7055273b..1e549212 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_dial_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDialResult — generated data type (RELAY method 'calling.dial', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDialResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb index 71ebc6e6..b47584b6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDisconnectParams — generated data type (RELAY method 'calling.disconnect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDisconnectParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb index 299ff72f..672b97db 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_disconnect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingDisconnectResult — generated data type (RELAY method 'calling.disconnect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingDisconnectResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb index a3551b8f..aae21a5a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_echo_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingEchoParams — generated data type (RELAY method 'calling.echo', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingEchoParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb index 87d9ac0a..314427d3 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_echo_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingEchoResult — generated data type (RELAY method 'calling.echo', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingEchoResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb index 4bd11d07..0ac379db 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_end_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingEndParams — generated data type (RELAY method 'calling.end', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingEndParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb index 32d44048..b2c577e7 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_end_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingEndResult — generated data type (RELAY method 'calling.end', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingEndResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb index 3fe914a9..d9c38eae 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingJoinConferenceParams — generated data type (RELAY method 'calling.join_conference', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingJoinConferenceParams FIELDS = { 'acl' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb index c95e7839..9855ecc1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_conference_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingJoinConferenceResult — generated data type (RELAY method 'calling.join_conference', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingJoinConferenceResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb index 37df1961..131d23ad 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_room_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingJoinRoomParams — generated data type (RELAY method 'calling.join_room', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingJoinRoomParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb index 9bb5368f..d4f47f5d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_join_room_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingJoinRoomResult — generated data type (RELAY method 'calling.join_room', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingJoinRoomResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb index 9472a5ea..387a3016 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLeaveConferenceParams — generated data type (RELAY method 'calling.leave_conference', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLeaveConferenceParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb index a8f28e12..9a1db535 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_conference_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLeaveConferenceResult — generated data type (RELAY method 'calling.leave_conference', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLeaveConferenceResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb index 21296b49..61be0852 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLeaveRoomParams — generated data type (RELAY method 'calling.leave_room', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLeaveRoomParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb index 8e0da883..d87cf270 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_leave_room_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLeaveRoomResult — generated data type (RELAY method 'calling.leave_room', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLeaveRoomResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb index 2da636ce..026aaf5e 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLiveTranscribeParams — generated data type (RELAY method 'calling.live_transcribe', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLiveTranscribeParams FIELDS = { 'action' => :any, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb index 29743c88..48d45a61 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_transcribe_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLiveTranscribeResult — generated data type (RELAY method 'calling.live_transcribe', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLiveTranscribeResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb index 9c9f84f1..f6e19ee8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLiveTranslateParams — generated data type (RELAY method 'calling.live_translate', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLiveTranslateParams FIELDS = { 'action' => :any, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb index 7d8f0a84..a48fa937 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_live_translate_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingLiveTranslateResult — generated data type (RELAY method 'calling.live_translate', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingLiveTranslateResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb index 8751e566..99b2418d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pass_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPassParams — generated data type (RELAY method 'calling.pass', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPassParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb index e3a4fef8..177d1030 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pass_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPassResult — generated data type (RELAY method 'calling.pass', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPassResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb index 67fbd81c..c7c693fb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPayParams — generated data type (RELAY method 'calling.pay', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPayParams FIELDS = { 'bank_account_type' => :any, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb index 51dabe1e..6889d606 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPayResult — generated data type (RELAY method 'calling.pay', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPayResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb index a78d08f2..b4f67e3a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPayStopParams — generated data type (RELAY method 'calling.pay.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPayStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb index ad325754..95c68a78 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_pay_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPayStopResult — generated data type (RELAY method 'calling.pay.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPayStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb index 4246077b..527a4128 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectParams — generated data type (RELAY method 'calling.play_and_collect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb index 066a56c9..259738c5 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectResult — generated data type (RELAY method 'calling.play_and_collect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb index 5e650a5d..dff1a7bc 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectStopParams — generated data type (RELAY method 'calling.play_and_collect.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb index 9e9c4ff0..d0571d23 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectStopResult — generated data type (RELAY method 'calling.play_and_collect.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb index 45c84f11..d2a4a90d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_params.rb @@ -17,8 +17,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectVolumeParams — generated data type (RELAY method 'calling.play_and_collect.volume', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectVolumeParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb index 66094839..9cce851f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_and_collect_volume_result.rb @@ -17,8 +17,8 @@ module ProtocolTypesGenerated # CallingPlayAndCollectVolumeResult — generated data type (RELAY method 'calling.play_and_collect.volume', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayAndCollectVolumeResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb index 96d1b88a..47d2eaf4 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayParams — generated data type (RELAY method 'calling.play', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb index 494b656a..38d87708 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayPauseParams — generated data type (RELAY method 'calling.play.pause', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayPauseParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb index cec8489a..65695c8f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_pause_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayPauseResult — generated data type (RELAY method 'calling.play.pause', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayPauseResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb index 92a0f7de..90b5c2de 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayResult — generated data type (RELAY method 'calling.play', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb index 485b410a..598cd477 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayResumeParams — generated data type (RELAY method 'calling.play.resume', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayResumeParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb index f8f5de1b..3c816a29 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_resume_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayResumeResult — generated data type (RELAY method 'calling.play.resume', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayResumeResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb index 4d505229..869cabb4 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayStopParams — generated data type (RELAY method 'calling.play.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb index 7d52bfbb..8d6d70d1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayStopResult — generated data type (RELAY method 'calling.play.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb index a027a93e..a4e1cc51 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayVolumeParams — generated data type (RELAY method 'calling.play.volume', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayVolumeParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb index 178c97a6..366b3d31 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_play_volume_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingPlayVolumeResult — generated data type (RELAY method 'calling.play.volume', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingPlayVolumeResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb index 2f7a8d07..79dbcc40 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingQueueEnterParams — generated data type (RELAY method 'calling.queue.enter', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingQueueEnterParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb index df8008b6..3fbad0f6 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_enter_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingQueueEnterResult — generated data type (RELAY method 'calling.queue.enter', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingQueueEnterResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb index 739dd5e5..b6f576e0 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingQueueLeaveParams — generated data type (RELAY method 'calling.queue.leave', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingQueueLeaveParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb index 8b3fe2b8..a5e6bb76 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_queue_leave_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingQueueLeaveResult — generated data type (RELAY method 'calling.queue.leave', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingQueueLeaveResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb index d3f3e862..e227bd45 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveFaxParams — generated data type (RELAY method 'calling.receive_fax', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveFaxParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb index 8e0069a5..87d2cc16 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveFaxResult — generated data type (RELAY method 'calling.receive_fax', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveFaxResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb index 8a0e5f2e..289402a8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveFaxStopParams — generated data type (RELAY method 'calling.receive_fax.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveFaxStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb index 7776f7d4..5d75001a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_fax_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveFaxStopResult — generated data type (RELAY method 'calling.receive_fax.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveFaxStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb index b96b8239..fb3d1257 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveParams — generated data type (RELAY method 'calling.receive', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveParams FIELDS = { 'context' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb index d34d6187..0ef86672 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_receive_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReceiveResult — generated data type (RELAY method 'calling.receive', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReceiveResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb index 2c5a0358..f781ee11 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordParams — generated data type (RELAY method 'calling.record', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb index 6657b20d..2938c74a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordPauseParams — generated data type (RELAY method 'calling.record.pause', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordPauseParams FIELDS = { 'behavior' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb index b5411eb3..6c903664 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_pause_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordPauseResult — generated data type (RELAY method 'calling.record.pause', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordPauseResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb index 256e014e..3d59a4e8 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordResult — generated data type (RELAY method 'calling.record', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb index e5179e7d..b0242d17 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordResumeParams — generated data type (RELAY method 'calling.record.resume', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordResumeParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb index 60ae3254..2d2dc296 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_resume_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordResumeResult — generated data type (RELAY method 'calling.record.resume', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordResumeResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb index 8d786cf3..07d92497 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordStopParams — generated data type (RELAY method 'calling.record.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb index 375f8f8a..f774bea9 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_record_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingRecordStopResult — generated data type (RELAY method 'calling.record.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingRecordStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb index bcf164ab..57bf2867 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_refer_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReferParams — generated data type (RELAY method 'calling.refer', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReferParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb index 466e19fc..c70f8b85 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_refer_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingReferResult — generated data type (RELAY method 'calling.refer', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingReferResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb index c9774cc8..ca5edb71 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendDigitsParams — generated data type (RELAY method 'calling.send_digits', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendDigitsParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb index 93dff018..4130de5d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_digits_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendDigitsResult — generated data type (RELAY method 'calling.send_digits', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendDigitsResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb index 14b3401d..0a535a2a 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendFaxParams — generated data type (RELAY method 'calling.send_fax', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendFaxParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb index a217a3d8..fd00ba12 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendFaxResult — generated data type (RELAY method 'calling.send_fax', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendFaxResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb index 6773ed2d..bcb059bb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendFaxStopParams — generated data type (RELAY method 'calling.send_fax.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendFaxStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb index 4efbcdd6..91b38f20 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_send_fax_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingSendFaxStopResult — generated data type (RELAY method 'calling.send_fax.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingSendFaxStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb index 77bf14c1..d9a67f22 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingStreamParams — generated data type (RELAY method 'calling.stream', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingStreamParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb index e66c374c..50f8c80b 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingStreamResult — generated data type (RELAY method 'calling.stream', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingStreamResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb index 1a767cc3..30bbd19d 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingStreamStopParams — generated data type (RELAY method 'calling.stream.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingStreamStopParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb index a197562e..29012f13 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_stream_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingStreamStopResult — generated data type (RELAY method 'calling.stream.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingStreamStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb index a860d8c7..63c93d57 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTapParams — generated data type (RELAY method 'calling.tap', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTapParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb index ef69b9ce..066df7b1 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTapResult — generated data type (RELAY method 'calling.tap', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTapResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb index 8c2c6fdf..2d0de500 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTapStopParams — generated data type (RELAY method 'calling.tap.stop', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTapStopParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb index 9abb33fa..ede6b120 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_tap_stop_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTapStopResult — generated data type (RELAY method 'calling.tap.stop', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTapStopResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb index 8c972201..fd915b7c 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_transfer_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTransferParams — generated data type (RELAY method 'calling.transfer', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTransferParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb index a525304d..7a1e2d7f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_transfer_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingTransferResult — generated data type (RELAY method 'calling.transfer', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingTransferResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb b/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb index 0a17a0e8..c92c37cb 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_user_event_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingUserEventParams — generated data type (RELAY method 'calling.user_event', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingUserEventParams FIELDS = { 'async' => :boolean, diff --git a/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb b/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb index 686add29..dc9e284f 100644 --- a/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/calling_user_event_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # CallingUserEventResult — generated data type (RELAY method 'calling.user_event', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class CallingUserEventResult FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb b/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb index 3e0926e0..3bf93a5d 100644 --- a/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/messaging_send_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # MessagingSendParams — generated data type (RELAY method 'messaging.send', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class MessagingSendParams FIELDS = { 'body' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb b/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb index 9af6aec0..89c4a7ef 100644 --- a/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/messaging_send_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # MessagingSendResult — generated data type (RELAY method 'messaging.send', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class MessagingSendResult FIELDS = { 'code' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb index fee3b2fe..050243cd 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireConnectParams — generated data type (RELAY method 'signalwire.connect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireConnectParams FIELDS = { 'agent' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb index 78b8a4e7..4909f4ec 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_connect_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireConnectResult — generated data type (RELAY method 'signalwire.connect', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireConnectResult FIELDS = { 'accesses' => :array, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb index 779c3db7..a72cf20c 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_disconnect_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireDisconnectParams — generated data type (RELAY method 'signalwire.disconnect', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireDisconnectParams FIELDS = { 'restart' => :boolean diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb index 93134d8f..51651345 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireExecuteParams — generated data type (RELAY method 'signalwire.execute', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireExecuteParams FIELDS = { 'attempted' => :array, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb index 1effd423..73412e07 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_execute_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireExecuteResult — generated data type (RELAY method 'signalwire.execute', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireExecuteResult FIELDS = { 'requester_nodeid' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb index eb9844a8..1476b8f5 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwirePingParams — generated data type (RELAY method 'signalwire.ping', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwirePingParams FIELDS = { 'payload' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb index e864ebdb..26d6f6a1 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_ping_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwirePingResult — generated data type (RELAY method 'signalwire.ping', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwirePingResult FIELDS = { 'payload' => :string, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb index 62e3e547..459a05f2 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_params.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireReauthenticateParams — generated data type (RELAY method 'signalwire.reauthenticate', params). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireReauthenticateParams FIELDS = { 'authentication' => :object, diff --git a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb index 92351bfd..367bd54e 100644 --- a/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb +++ b/lib/signalwire/relay/protocol_types_generated/signalwire_reauthenticate_result.rb @@ -16,8 +16,8 @@ module ProtocolTypesGenerated # SignalwireReauthenticateResult — generated data type (RELAY method 'signalwire.reauthenticate', result). # # Frozen FIELDS maps each snake wire key to its JSON type symbol. - # No reader/writer methods and no initialize — a method-less type the - # reference records method-less on both surface and signatures. + # No reader/writer methods and no initialize — the class is a bare + # namespace for its FIELDS map, describing the wire shape only. class SignalwireReauthenticateResult FIELDS = { 'authentication' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/_fabric_bases.rb b/lib/signalwire/rest/namespaces/generated/_fabric_bases.rb index 38b1cc33..88aa237e 100644 --- a/lib/signalwire/rest/namespaces/generated/_fabric_bases.rb +++ b/lib/signalwire/rest/namespaces/generated/_fabric_bases.rb @@ -10,7 +10,7 @@ # python3 scripts/generate_rest.py # # Generated Fabric base classes: CRUD + list_addresses (the FabricResource -# method-set, §2), differing only by the update HTTP verb (PATCH vs PUT). +# method-set), differing only by the update HTTP verb (PATCH vs PUT). module SignalWire module REST diff --git a/lib/signalwire/rest/namespaces/generated/datasphere_namespace.rb b/lib/signalwire/rest/namespaces/generated/datasphere_namespace.rb index d1c75469..b8cc6adf 100644 --- a/lib/signalwire/rest/namespaces/generated/datasphere_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/datasphere_namespace.rb @@ -9,13 +9,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the datasphere namespace (§8). +# Generated REST client container for the datasphere namespace. module SignalWire module REST module Namespaces module Generated - # DatasphereNamespace — generated container grouping the datasphere namespace resources (§8). + # DatasphereNamespace — groups the datasphere namespace resources; each is exposed + # as a memoized reader on this container. class DatasphereNamespace attr_reader :documents diff --git a/lib/signalwire/rest/namespaces/generated/fabric_namespace.rb b/lib/signalwire/rest/namespaces/generated/fabric_namespace.rb index 62e7cb5f..404de526 100644 --- a/lib/signalwire/rest/namespaces/generated/fabric_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/fabric_namespace.rb @@ -10,13 +10,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the fabric namespace (§8). +# Generated REST client container for the fabric namespace. module SignalWire module REST module Namespaces module Generated - # FabricNamespace — generated container grouping the fabric namespace resources (§8). + # FabricNamespace — groups the fabric namespace resources; each is exposed + # as a memoized reader on this container. class FabricNamespace attr_reader :addresses, :resources, :ai_agents, :call_flows, :conference_rooms, :cxml_applications, :cxml_scripts, :cxml_webhooks, :freeswitch_connectors, :relay_applications, :sip_endpoints, :sip_gateways, :subscribers, :swml_scripts, :swml_webhooks, :tokens diff --git a/lib/signalwire/rest/namespaces/generated/logs_namespace.rb b/lib/signalwire/rest/namespaces/generated/logs_namespace.rb index bce2892f..2e0f1e5d 100644 --- a/lib/signalwire/rest/namespaces/generated/logs_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/logs_namespace.rb @@ -9,13 +9,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the logs namespace (§8). +# Generated REST client container for the logs namespace. module SignalWire module REST module Namespaces module Generated - # LogsNamespace — generated container grouping the logs namespace resources (§8). + # LogsNamespace — groups the logs namespace resources; each is exposed + # as a memoized reader on this container. class LogsNamespace attr_reader :conferences, :messages, :voice, :fax diff --git a/lib/signalwire/rest/namespaces/generated/project_namespace.rb b/lib/signalwire/rest/namespaces/generated/project_namespace.rb index 051e730f..7efb87fd 100644 --- a/lib/signalwire/rest/namespaces/generated/project_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/project_namespace.rb @@ -9,13 +9,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the project namespace (§8). +# Generated REST client container for the project namespace. module SignalWire module REST module Namespaces module Generated - # ProjectNamespace — generated container grouping the project namespace resources (§8). + # ProjectNamespace — groups the project namespace resources; each is exposed + # as a memoized reader on this container. class ProjectNamespace attr_reader :tokens diff --git a/lib/signalwire/rest/namespaces/generated/registry_namespace.rb b/lib/signalwire/rest/namespaces/generated/registry_namespace.rb index 6dfbed1e..ce43ed8c 100644 --- a/lib/signalwire/rest/namespaces/generated/registry_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/registry_namespace.rb @@ -9,13 +9,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the registry namespace (§8). +# Generated REST client container for the registry namespace. module SignalWire module REST module Namespaces module Generated - # RegistryNamespace — generated container grouping the registry namespace resources (§8). + # RegistryNamespace — groups the registry namespace resources; each is exposed + # as a memoized reader on this container. class RegistryNamespace attr_reader :brands, :campaigns, :numbers, :orders diff --git a/lib/signalwire/rest/namespaces/generated/resource_tree.rb b/lib/signalwire/rest/namespaces/generated/resource_tree.rb index 77548b37..de234bb7 100644 --- a/lib/signalwire/rest/namespaces/generated/resource_tree.rb +++ b/lib/signalwire/rest/namespaces/generated/resource_tree.rb @@ -9,7 +9,7 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST resource tree module the hand RestClient includes (§8). +# Generated REST resource tree module that RestClient includes. module SignalWire module REST diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i.rb index ec634f30..e5b1fad8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AI FIELDS = { 'ai' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_object.rb index 9b7a7e6c..a20e4552 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_object.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_params.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_params.rb index 69d27969..9fb2496b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_params.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIParams FIELDS = { 'acknowledge_interruptions' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_pom.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_pom.rb index 0981e420..5603e9e1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_pom.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_pom.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_text.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_text.rb index 81a82228..266cf44b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_text.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_post_prompt_text.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_pom.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_pom.rb index 8633de0a..c3053a29 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_pom.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_pom.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_text.rb b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_text.rb index f7c80b70..e8088f7b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_text.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/a_i_prompt_text.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/all_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/all_of_property.rb index d9e585b8..1d95ebc1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/all_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/all_of_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AllOfProperty FIELDS = { 'allOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock.rb b/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock.rb index ea5820ea..4693a08b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AmazonBedrock FIELDS = { 'amazon_bedrock' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock_object.rb index 54c49b75..ab9075c3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/amazon_bedrock_object.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AmazonBedrockObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/answer.rb b/lib/signalwire/rest/namespaces/generated/types/calling/answer.rb index bb7459b9..74b823d5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/answer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/answer.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Answer FIELDS = { 'answer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/any_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/any_of_property.rb index f2e3fc7c..6cf55e68 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/any_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/any_of_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AnyOfProperty FIELDS = { 'anyOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/array_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/array_property.rb index 86abfd60..88459704 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/array_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/array_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ArrayProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_params.rb b/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_params.rb index 2dcc19cf..0f4fc955 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_params.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BedrockParams FIELDS = { 'attention_timeout' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_s_w_a_i_g.rb b/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_s_w_a_i_g.rb index d7f6983e..e3b7c3c5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_s_w_a_i_g.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/bedrock_s_w_a_i_g.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BedrockSWAIG FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/boolean_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/boolean_property.rb index 073e9eae..d81120b4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/boolean_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/boolean_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BooleanProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_request.rb index cf783140..2dd2cf25 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallAIMessageRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_reset_params.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_reset_params.rb index e01c4fdc..54608dfb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_reset_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_message_reset_params.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallAIMessageResetParams FIELDS = { 'full_reset' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_stop_request.rb index 983422c2..3e335ada 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_a_i_stop_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallAIStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_request.rb index b3b33c3a..638c9d0c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCollectRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_start_input_timers_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_start_input_timers_request.rb index dadbf907..ae5757b4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_start_input_timers_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_start_input_timers_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCollectStartInputTimersRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_stop_request.rb index 18e0b84c..3b6dc03e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_collect_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCollectStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_create422_error.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_create422_error.rb index fc49b0fc..16dea040 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_create422_error.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_create422_error.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCreate422Error FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_s_w_m_l.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_s_w_m_l.rb index ecdf6601..6483aab1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_s_w_m_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_s_w_m_l.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCreateParamsSWML FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_u_r_l.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_u_r_l.rb index 6a37738d..805ca64f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_u_r_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_params_u_r_l.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCreateParamsURL FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_request.rb index fb82f090..5169158c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_create_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallCreateRequest FIELDS = { 'command' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_request.rb index af724472..e619d3cf 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallDenoiseRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_stop_request.rb index 8e654db6..7548a15b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_denoise_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallDenoiseStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_request.rb index 21c1e2a1..f6ba8672 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallDetectRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_stop_request.rb index efce8b97..5af92049 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_detect_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallDetectStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_disconnect_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_disconnect_request.rb index e317dfaa..82f808a7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_disconnect_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_disconnect_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallDisconnectRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_hangup_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_hangup_request.rb index 9477365a..547d2845 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_hangup_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_hangup_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallHangupRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_hold_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_hold_request.rb index b5e43912..01ecd09f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_hold_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_hold_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallHoldRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_leg.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_leg.rb index 4b9ebbbf..680b9337 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_leg.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_leg.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallLeg FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_live_transcribe_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_live_transcribe_request.rb index 4c867272..1ea45a6f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_live_transcribe_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_live_transcribe_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallLiveTranscribeRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_live_translate_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_live_translate_request.rb index b37c347b..e52f2674 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_live_translate_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_live_translate_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallLiveTranslateRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_pause_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_pause_request.rb index 2450e1d2..67c69a2c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_pause_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_pause_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallPlayPauseRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_request.rb index a66e1f4f..69d08574 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallPlayRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_resume_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_resume_request.rb index b974351f..22645009 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_resume_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_resume_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallPlayResumeRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_stop_request.rb index 78ed1fb7..3f6fee86 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallPlayStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_volume_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_volume_request.rb index 0296bf14..8a2b3500 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_play_volume_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_play_volume_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallPlayVolumeRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_receive_fax_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_receive_fax_stop_request.rb index 8958ed12..87123d3c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_receive_fax_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_receive_fax_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallReceiveFaxStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_pause_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_pause_request.rb index bda9ddde..1b79d8f5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_pause_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_pause_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallRecordPauseRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_request.rb index a3d84072..cda5b7c5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallRecordRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_resume_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_resume_request.rb index b3484b71..d89803dc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_resume_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_resume_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallRecordResumeRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_stop_request.rb index e35a2a91..788a1695 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_record_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_record_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallRecordStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_refer_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_refer_request.rb index f1e92d39..b8801578 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_refer_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_refer_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallReferRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_send_fax_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_send_fax_stop_request.rb index e18acaca..252f6668 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_send_fax_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_send_fax_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallSendFaxStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_request.rb index d24d0e12..4bb36f9a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallStreamRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_stop_request.rb index 3c146f8a..8b2c74e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_stream_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallStreamStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_request.rb index f303c4e3..84ff4f3c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallTapRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_stop_request.rb index a5ea79e4..e260b2e2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_tap_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallTapStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_request.rb index 8e4e6004..3dbf08c4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallTranscribeRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_stop_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_stop_request.rb index fc542d93..b7108ffd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_stop_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_transcribe_stop_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallTranscribeStopRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_transfer_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_transfer_request.rb index afc062e0..d4f07ae6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_transfer_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_transfer_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallTransferRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_unhold_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_unhold_request.rb index e5a9850e..55bd4393 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_unhold_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_unhold_request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallUnholdRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_current_call_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_current_call_request.rb index 1cf4400d..173356b9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_current_call_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_current_call_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallUpdateCurrentCallRequest FIELDS = { 'command' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_s_w_m_l.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_s_w_m_l.rb index 22089b18..1ce07a86 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_s_w_m_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_s_w_m_l.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallUpdateParamsSWML FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_u_r_l.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_u_r_l.rb index ec97664c..dd5db4a6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_u_r_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_update_params_u_r_l.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallUpdateParamsURL FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/call_user_event_request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/call_user_event_request.rb index e4d16a2e..741800b1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/call_user_event_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/call_user_event_request.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallUserEventRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/change_context_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/change_context_action.rb index 54c6403a..4284667c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/change_context_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/change_context_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChangeContextAction FIELDS = { 'change_context' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/change_step_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/change_step_action.rb index c1509f5b..606bcba6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/change_step_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/change_step_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChangeStepAction FIELDS = { 'change_step' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/charge_details.rb b/lib/signalwire/rest/namespaces/generated/types/calling/charge_details.rb index b29ffed8..3b5f1463 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/charge_details.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/charge_details.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetails FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/cond.rb b/lib/signalwire/rest/namespaces/generated/types/calling/cond.rb index 58c39f93..1a8d6868 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/cond.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/cond.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Cond FIELDS = { 'cond' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/cond_else.rb b/lib/signalwire/rest/namespaces/generated/types/calling/cond_else.rb index d64ba0eb..4498169e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/cond_else.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/cond_else.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CondElse FIELDS = { 'else' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/cond_reg.rb b/lib/signalwire/rest/namespaces/generated/types/calling/cond_reg.rb index 457f9598..cf8e6297 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/cond_reg.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/cond_reg.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CondReg FIELDS = { 'when' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect.rb index 6618912c..e75154f8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Connect FIELDS = { 'connect' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_parallel.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_parallel.rb index d03dab79..f09e619d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_parallel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_parallel.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial.rb index f1a8b972..a8fbb6bd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSerial FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial_parallel.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial_parallel.rb index a3bb5256..c560e001 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial_parallel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_serial_parallel.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSerialParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_single.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_single.rb index 31148eff..4a4e090e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_single.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_device_single.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSingle FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_headers.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_headers.rb index 313ebb60..a0ade3bf 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_headers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_headers.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectHeaders FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/connect_switch.rb b/lib/signalwire/rest/namespaces/generated/types/calling/connect_switch.rb index d7275e06..fe681afd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/connect_switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/connect_switch.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/const_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/const_property.rb index 1e77173d..a8fa9476 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/const_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/const_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConstProperty FIELDS = { 'const' => :any diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/context_p_o_m_steps.rb b/lib/signalwire/rest/namespaces/generated/types/calling/context_p_o_m_steps.rb index 61f9fbe7..c57c694f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/context_p_o_m_steps.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/context_p_o_m_steps.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextPOMSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/context_switch_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/context_switch_action.rb index add41cd0..e187b687 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/context_switch_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/context_switch_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextSwitchAction FIELDS = { 'context_switch' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/context_text_steps.rb b/lib/signalwire/rest/namespaces/generated/types/calling/context_text_steps.rb index ef6dfa51..ede9c453 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/context_text_steps.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/context_text_steps.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextTextSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/contexts.rb b/lib/signalwire/rest/namespaces/generated/types/calling/contexts.rb index 56b0f508..12b603e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/contexts.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/contexts.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Contexts FIELDS = { 'default' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/contexts_p_o_m_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/contexts_p_o_m_object.rb index e31a25ee..f9ad3446 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/contexts_p_o_m_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/contexts_p_o_m_object.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsPOMObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/contexts_text_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/contexts_text_object.rb index e153d66c..7cfdc357 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/contexts_text_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/contexts_text_object.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsTextObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/conversation_message.rb b/lib/signalwire/rest/namespaces/generated/types/calling/conversation_message.rb index db5cacbc..682269da 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/conversation_message.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/conversation_message.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConversationMessage FIELDS = { 'role' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/data_map.rb b/lib/signalwire/rest/namespaces/generated/types/calling/data_map.rb index 030ff8ed..47fed450 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/data_map.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/data_map.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DataMap FIELDS = { 'output' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/denoise.rb b/lib/signalwire/rest/namespaces/generated/types/calling/denoise.rb index 96e15668..e4f2747d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/denoise.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/denoise.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Denoise FIELDS = { 'denoise' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/detect_machine.rb b/lib/signalwire/rest/namespaces/generated/types/calling/detect_machine.rb index cd73bfb5..dc8c614c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/detect_machine.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/detect_machine.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DetectMachine FIELDS = { 'detect_machine' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue.rb b/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue.rb index da7158c2..800c10f7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EnterQueue FIELDS = { 'enter_queue' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue_object.rb index 7066a7c9..89a850fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/enter_queue_object.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EnterQueueObject FIELDS = { 'queue_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/execute.rb b/lib/signalwire/rest/namespaces/generated/types/calling/execute.rb index d272feec..7ed6c07f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/execute.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/execute.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Execute FIELDS = { 'execute' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/execute_switch.rb b/lib/signalwire/rest/namespaces/generated/types/calling/execute_switch.rb index dacd99dd..e4516dd0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/execute_switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/execute_switch.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ExecuteSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/expression.rb b/lib/signalwire/rest/namespaces/generated/types/calling/expression.rb index 54894170..3f2c0d5d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/expression.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/expression.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Expression FIELDS = { 'string' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/fabric_device_leg.rb b/lib/signalwire/rest/namespaces/generated/types/calling/fabric_device_leg.rb index 9a57ea7f..b25d3606 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/fabric_device_leg.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/fabric_device_leg.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricDeviceLeg FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/function_parameters.rb b/lib/signalwire/rest/namespaces/generated/types/calling/function_parameters.rb index 5ee52ae4..7c8fe087 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/function_parameters.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/function_parameters.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FunctionParameters FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/goto.rb b/lib/signalwire/rest/namespaces/generated/types/calling/goto.rb index 2fa8e994..ab11af61 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/goto.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/goto.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Goto FIELDS = { 'goto' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/hang_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/calling/hang_up_hook_s_w_a_i_g_function.rb index 35c19f96..80beb2e9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/hang_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/hang_up_hook_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HangUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/hangup.rb b/lib/signalwire/rest/namespaces/generated/types/calling/hangup.rb index 3f78ca62..881c5c74 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/hangup.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/hangup.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Hangup FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/hangup_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/hangup_action.rb index a9d5f9f7..89d8e731 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/hangup_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/hangup_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HangupAction FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/hint.rb b/lib/signalwire/rest/namespaces/generated/types/calling/hint.rb index f7d43563..951bfd9e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/hint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/hint.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Hint FIELDS = { 'hint' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/hold_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/hold_action.rb index e24766fa..24428003 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/hold_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/hold_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HoldAction FIELDS = { 'hold' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/inject_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/inject_action.rb index 6a3235ac..61ba6f89 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/inject_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/inject_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class InjectAction FIELDS = { 'inject' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/integer_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/integer_property.rb index 6f59396c..7d033b24 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/integer_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/integer_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class IntegerProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/join_conference.rb b/lib/signalwire/rest/namespaces/generated/types/calling/join_conference.rb index fe071bce..c8e8b098 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/join_conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/join_conference.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinConference FIELDS = { 'join_conference' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/join_conference_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/join_conference_object.rb index 4d79e37c..18d8b27a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/join_conference_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/join_conference_object.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinConferenceObject FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/join_room.rb b/lib/signalwire/rest/namespaces/generated/types/calling/join_room.rb index 81fb5c7c..f8334ae0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/join_room.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/join_room.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinRoom FIELDS = { 'join_room' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/label.rb b/lib/signalwire/rest/namespaces/generated/types/calling/label.rb index c716974e..bcf1395c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/label.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/label.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Label FIELDS = { 'label' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/language_params.rb b/lib/signalwire/rest/namespaces/generated/types/calling/language_params.rb index 47cc91a6..99ac547f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/language_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/language_params.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguageParams FIELDS = { 'stability' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_fillers.rb b/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_fillers.rb index b662a755..5d988766 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_fillers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_fillers.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguagesWithFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_solo_fillers.rb b/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_solo_fillers.rb index 279331fa..6a6fa5a4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_solo_fillers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/languages_with_solo_fillers.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguagesWithSoloFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe.rb index 58269753..33b7226d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranscribe FIELDS = { 'live_transcribe' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_start_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_start_action.rb index 1fefca63..214fbf30 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_start_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranscribeStartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_summarize_action.rb index de9b6c91..d3c31334 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_transcribe_summarize_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranscribeSummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate.rb index 1805ee90..d91366bd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranslate FIELDS = { 'live_translate' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_inject_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_inject_action.rb index 9cea275b..96e9dc92 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_inject_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_inject_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranslateInjectAction FIELDS = { 'inject' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_start_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_start_action.rb index 8ee3afcb..05778160 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_start_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranslateStartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_summarize_action.rb index 58d69480..cd432c18 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/live_translate_summarize_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranslateSummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/null_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/null_property.rb index e1ef873c..2ac37791 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/null_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/null_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NullProperty FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/number_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/number_property.rb index 71d355b2..ea5ae8d8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/number_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/number_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/object_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/object_property.rb index 096e9456..d643f059 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/object_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/object_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ObjectProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/one_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/one_of_property.rb index ccad5678..3914aaa0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/one_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/one_of_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class OneOfProperty FIELDS = { 'oneOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/output.rb b/lib/signalwire/rest/namespaces/generated/types/calling/output.rb index ccce25e9..29c88085 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/output.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/output.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Output FIELDS = { 'response' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pay.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pay.rb index f0f3d095..c122902e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pay.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pay.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Pay FIELDS = { 'pay' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pay_parameters.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pay_parameters.rb index 350ac403..ea6d7f9a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pay_parameters.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pay_parameters.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayParameters FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_play_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_play_action.rb index 37995ce0..f4f4c37b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_play_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_play_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPromptPlayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_say_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_say_action.rb index 4172135f..35a55c03 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_say_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompt_say_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPromptSayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompts.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompts.rb index 44ef3d0f..94f971b4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompts.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pay_prompts.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPrompts FIELDS = { 'actions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/play.rb b/lib/signalwire/rest/namespaces/generated/types/calling/play.rb index 1e77bd92..46b59528 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/play.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/play.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Play FIELDS = { 'play' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l.rb b/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l.rb index a08fb3db..2489c2ed 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlayWithURL FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l_s.rb b/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l_s.rb index 5c3d2797..e760f1c8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l_s.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/play_with_u_r_l_s.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlayWithURLS FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/playback_b_g_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/playback_b_g_action.rb index d35eb0be..653a33df 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/playback_b_g_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/playback_b_g_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlaybackBGAction FIELDS = { 'playback_bg' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_body_content.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_body_content.rb index 3368e1be..59bde5d5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_body_content.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_body_content.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PomSectionBodyContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_bullets_content.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_bullets_content.rb index ccd6d0b2..fa8e14e6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_bullets_content.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pom_section_bullets_content.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PomSectionBulletsContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/prompt.rb b/lib/signalwire/rest/namespaces/generated/types/calling/prompt.rb index cbfc11c8..6189cc24 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/prompt.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/prompt.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Prompt FIELDS = { 'prompt' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/pronounce.rb b/lib/signalwire/rest/namespaces/generated/types/calling/pronounce.rb index d78acb14..c62c2279 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/pronounce.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/pronounce.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Pronounce FIELDS = { 'replace' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/receive_fax.rb b/lib/signalwire/rest/namespaces/generated/types/calling/receive_fax.rb index 0d187949..499ea669 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/receive_fax.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/receive_fax.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ReceiveFax FIELDS = { 'receive_fax' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/record.rb b/lib/signalwire/rest/namespaces/generated/types/calling/record.rb index 7a84f3cb..a874410f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/record.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/record.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Record FIELDS = { 'record' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/record_call.rb b/lib/signalwire/rest/namespaces/generated/types/calling/record_call.rb index e9f9adbd..014c988c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/record_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/record_call.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RecordCall FIELDS = { 'record_call' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/request.rb b/lib/signalwire/rest/namespaces/generated/types/calling/request.rb index f6c45ace..7a66ad60 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/request.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Request FIELDS = { 'request' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/return.rb b/lib/signalwire/rest/namespaces/generated/types/calling/return.rb index b6bd6fec..6a48e501 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/return.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/return.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Return FIELDS = { 'return' => :any diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_i_p_refer.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_i_p_refer.rb index dd95ad7c..8783954e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_i_p_refer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_i_p_refer.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SIPRefer FIELDS = { 'sip_refer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_body.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_body.rb index 04629af1..3cef6709 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_body.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_body.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SMSWithBody FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_media.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_media.rb index b2a62992..a19e6a91 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_media.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_m_s_with_media.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SMSWithMedia FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g.rb index 33f9742f..e43b5584 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIG FIELDS = { 'defaults' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_defaults.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_defaults.rb index 5ec49fb1..2913cf41 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_defaults.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_defaults.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGDefaults FIELDS = { 'web_hook_url' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_includes.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_includes.rb index f415be93..055ff170 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_includes.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_includes.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGIncludes FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_internal_filler.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_internal_filler.rb index a6003503..be21b432 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_internal_filler.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_a_i_g_internal_filler.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGInternalFiller FIELDS = { 'hangup' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_action.rb index c62bbb1b..eb8e4f84 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLAction FIELDS = { 'SWML' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_object.rb b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_object.rb index 1bb4e4a7..69496f4c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/s_w_m_l_object.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLObject FIELDS = { 'version' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/say_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/say_action.rb index b0b2fb72..3976dc84 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/say_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/say_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SayAction FIELDS = { 'say' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/section.rb b/lib/signalwire/rest/namespaces/generated/types/calling/section.rb index a71b1234..4d9e7420 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/section.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/section.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Section FIELDS = { 'main' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/send_digits.rb b/lib/signalwire/rest/namespaces/generated/types/calling/send_digits.rb index 1e4697ec..4dc36888 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/send_digits.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/send_digits.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendDigits FIELDS = { 'send_digits' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/send_fax.rb b/lib/signalwire/rest/namespaces/generated/types/calling/send_fax.rb index e17ab3ba..b3f18935 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/send_fax.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/send_fax.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendFax FIELDS = { 'send_fax' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/send_s_m_s.rb b/lib/signalwire/rest/namespaces/generated/types/calling/send_s_m_s.rb index 2cd1869f..902a3912 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/send_s_m_s.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/send_s_m_s.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendSMS FIELDS = { 'send_sms' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/set.rb b/lib/signalwire/rest/namespaces/generated/types/calling/set.rb index db7c817c..2a984357 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/set.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/set.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Set FIELDS = { 'set' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/set_global_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/set_global_data_action.rb index fe5b64e8..4010e312 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/set_global_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/set_global_data_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SetGlobalDataAction FIELDS = { 'set_global_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/set_meta_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/set_meta_data_action.rb index c5b12c54..118376f5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/set_meta_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/set_meta_data_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SetMetaDataAction FIELDS = { 'set_meta_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/sleep.rb b/lib/signalwire/rest/namespaces/generated/types/calling/sleep.rb index 6a6ff437..ba0f4988 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/sleep.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/sleep.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Sleep FIELDS = { 'sleep' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/start_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/start_action.rb index 8e18fa4b..46da8055 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/start_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/start_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/calling/start_up_hook_s_w_a_i_g_function.rb index f2c92663..83d7c44d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/start_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/start_up_hook_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StartUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/stop_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/stop_action.rb index 42995c32..f5bf17c6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/stop_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/stop_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopAction FIELDS = { 'stop' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/stop_denoise.rb b/lib/signalwire/rest/namespaces/generated/types/calling/stop_denoise.rb index 8a24afca..fb34bdd5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/stop_denoise.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/stop_denoise.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopDenoise FIELDS = { 'stop_denoise' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/stop_playback_b_g_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/stop_playback_b_g_action.rb index 756e8ee4..911a5eba 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/stop_playback_b_g_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/stop_playback_b_g_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopPlaybackBGAction FIELDS = { 'stop_playback_bg' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/stop_record_call.rb b/lib/signalwire/rest/namespaces/generated/types/calling/stop_record_call.rb index 7c5ca86c..92eb3cad 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/stop_record_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/stop_record_call.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopRecordCall FIELDS = { 'stop_record_call' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/stop_tap.rb b/lib/signalwire/rest/namespaces/generated/types/calling/stop_tap.rb index 21929f0d..a682651f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/stop_tap.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/stop_tap.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopTap FIELDS = { 'stop_tap' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/string_property.rb b/lib/signalwire/rest/namespaces/generated/types/calling/string_property.rb index 96d329df..580b3b24 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/string_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/string_property.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StringProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/summarize_action.rb index 37aa854f..135ad637 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/summarize_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/summarize_conversation_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/calling/summarize_conversation_s_w_a_i_g_function.rb index 6a2937db..41fe8034 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/summarize_conversation_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/summarize_conversation_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SummarizeConversationSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/switch.rb b/lib/signalwire/rest/namespaces/generated/types/calling/switch.rb index 2b5fb89c..75226b4b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/switch.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Switch FIELDS = { 'switch' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/tap.rb b/lib/signalwire/rest/namespaces/generated/types/calling/tap.rb index 4cf66153..df2a8b50 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/tap.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/tap.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Tap FIELDS = { 'tap' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/toggle_functions_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/toggle_functions_action.rb index a68ef27b..976a2245 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/toggle_functions_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/toggle_functions_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ToggleFunctionsAction FIELDS = { 'toggle_functions' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_start_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_start_action.rb index 6014af6d..479604bd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_start_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TranscribeStartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_summarize_action.rb index 956b7b2f..68148d85 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/transcribe_summarize_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TranscribeSummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/transfer.rb b/lib/signalwire/rest/namespaces/generated/types/calling/transfer.rb index 07816db5..a8dd2dc1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/transfer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/transfer.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Transfer FIELDS = { 'transfer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_rest_api_error_item.rb index 7d49aeea..534b2541 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code400.rb index 479f3152..2dccb85e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code401.rb index ffed5184..6e529d7a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code404.rb index e9bbfeb5..4ffc8d9e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code500.rb index b26f46a5..b00bdb4f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/unset.rb b/lib/signalwire/rest/namespaces/generated/types/calling/unset.rb index b2da74e5..97669f6b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/unset.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/unset.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Unset FIELDS = { 'unset' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/unset_global_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/unset_global_data_action.rb index 6694e380..b41bb4c8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/unset_global_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/unset_global_data_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UnsetGlobalDataAction FIELDS = { 'unset_global_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/unset_meta_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/unset_meta_data_action.rb index 2c8bad16..014547b8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/unset_meta_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/unset_meta_data_action.rb @@ -22,8 +22,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UnsetMetaDataAction FIELDS = { 'unset_meta_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/user_event.rb b/lib/signalwire/rest/namespaces/generated/types/calling/user_event.rb index 3ebd0071..1adb8948 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/user_event.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/user_event.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserEvent FIELDS = { 'user_event' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/user_input_action.rb b/lib/signalwire/rest/namespaces/generated/types/calling/user_input_action.rb index b3c7435c..20823d2b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/user_input_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/user_input_action.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserInputAction FIELDS = { 'user_input' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/user_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/calling/user_s_w_a_i_g_function.rb index 0f1689d5..c8edddfc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/user_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/user_s_w_a_i_g_function.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/calling/webhook.rb b/lib/signalwire/rest/namespaces/generated/types/calling/webhook.rb index 2663d6f9..c1da1258 100644 --- a/lib/signalwire/rest/namespaces/generated/types/calling/webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/calling/webhook.rb @@ -21,8 +21,8 @@ module Calling # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Webhook FIELDS = { 'expressions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_read.rb b/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_read.rb index b414ee3a..34bb594a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_read.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_read.rb @@ -22,8 +22,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChatPermissionWithRead FIELDS = { 'read' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_write.rb b/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_write.rb index 272d02a0..9650a667 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_write.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/chat_permission_with_write.rb @@ -22,8 +22,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChatPermissionWithWrite FIELDS = { 'read' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/chat_token.rb b/lib/signalwire/rest/namespaces/generated/types/chat/chat_token.rb index 6504eb3a..27c9df09 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/chat_token.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/chat_token.rb @@ -21,8 +21,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChatToken FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/chat_token422_error.rb b/lib/signalwire/rest/namespaces/generated/types/chat/chat_token422_error.rb index bb328252..979031d0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/chat_token422_error.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/chat_token422_error.rb @@ -21,8 +21,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChatToken422Error FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/new_chat_token.rb b/lib/signalwire/rest/namespaces/generated/types/chat/new_chat_token.rb index 218773c7..5dcb165c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/new_chat_token.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/new_chat_token.rb @@ -21,8 +21,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NewChatToken FIELDS = { 'ttl' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_rest_api_error_item.rb index f84ed2d7..6ab61e95 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code400.rb index b5a28007..7d106304 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code401.rb index 6765f5b1..dccec789 100644 --- a/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/chat/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Chat # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk.rb index 3badf8c8..2992e1ef 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk.rb @@ -21,8 +21,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Chunk FIELDS = { 'text' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_list_response.rb index 33b664c8..cd32d807 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_list_response.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChunkListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_pagination_response.rb index db35610f..455342e9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_pagination_response.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChunkPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_response.rb index 99e4e967..c178806a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/chunk_response.rb @@ -21,8 +21,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChunkResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/create_status_code422.rb index eeb9b659..9072f044 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/create_status_code422.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/document.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/document.rb index c56bd1a6..6ea930ec 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/document.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/document.rb @@ -21,8 +21,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Document FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_create_request_base.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_create_request_base.rb index 5f3113ed..08b9b3cb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_create_request_base.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_create_request_base.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DocumentCreateRequestBase FIELDS = { 'url' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_list_response.rb index 54ba7902..7d133069 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_list_response.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DocumentListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_search_request.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_search_request.rb index 99195827..163427bf 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_search_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_search_request.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DocumentSearchRequest FIELDS = { 'tags' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_update_request.rb index 91f49d62..a4f4f204 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/document_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/document_update_request.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DocumentUpdateRequest FIELDS = { 'tags' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/list_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/list_status_code422.rb index d9ce19e9..0dbf27bb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/list_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/list_status_code422.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/pagination_response.rb index 89118508..e0829ae8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/pagination_response.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/search_response.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/search_response.rb index 28a10e29..8cd86436 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/search_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/search_response.rb @@ -21,8 +21,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SearchResponse FIELDS = { 'chunks' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/search_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/search_status_code422.rb index 0f6dd9f1..973126d6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/search_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/search_status_code422.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SearchStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_rest_api_error_item.rb index 1d606590..e6862e49 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code400.rb index 56bd8a9f..92c043c7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code401.rb index 42a9f6d8..a3b6518e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code404.rb index 193a89b7..56e20446 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code500.rb index 0787dcbb..40a694ad 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/datasphere/update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/datasphere/update_status_code422.rb index 6383faac..af272ec2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/datasphere/update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/datasphere/update_status_code422.rb @@ -22,8 +22,8 @@ module Datasphere # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i.rb index edd9c1de..e7cc7f3a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AI FIELDS = { 'ai' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_address_pagination_response.rb index 0dd82006..5f510cf5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent.rb index 0ab9ebcb..5a8d3302 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgent FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_address_list_response.rb index 2d23a1b4..b97fb223 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_request.rb index d5f33316..2393fcfd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentCreateRequest FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_status_code422.rb index 75496e6c..1a0a9eca 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_list_response.rb index 179bc99f..719bbd63 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_pagination_response.rb index 19f88140..558c7834 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_response.rb index c1d71012..1d0c44b8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_request.rb index 49aa7075..d519c48a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentUpdateRequest FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_status_code422.rb index 67152db8..883c6437 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_agent_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIAgentUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_object.rb index 79e5eabc..6390c6bd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_object.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_params.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_params.rb index f4b5c603..2451ddb7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_params.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIParams FIELDS = { 'acknowledge_interruptions' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom.rb index 422fb640..9d052659 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom_update.rb index 0043fe3f..72cd6374 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_pom_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptPomUpdate FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text.rb index 19cac6fd..1206bd8e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text_update.rb index 889fcc14..62bc626b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_post_prompt_text_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPostPromptTextUpdate FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom.rb index 686ab2f3..7a2ff28a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptPom FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom_update.rb index 0a7f1659..837093f6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_pom_update.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptPomUpdate FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text.rb index a72576b4..0ff6c302 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptText FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text_update.rb index 042cc7dd..8ed43f0c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/a_i_prompt_text_update.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AIPromptTextUpdate FIELDS = { 'max_tokens' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/all_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/all_of_property.rb index 4d9704e3..e6f19e5a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/all_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/all_of_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AllOfProperty FIELDS = { 'allOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock.rb index 3063d06f..04ca38cf 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AmazonBedrock FIELDS = { 'amazon_bedrock' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock_object.rb index 8db98696..ce519cbe 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/amazon_bedrock_object.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AmazonBedrockObject FIELDS = { 'global_data' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/answer.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/answer.rb index 5b1835ea..2e60ea1a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/answer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/answer.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Answer FIELDS = { 'answer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/any_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/any_of_property.rb index 54cee9ad..eed7005b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/any_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/any_of_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AnyOfProperty FIELDS = { 'anyOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/array_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/array_property.rb index 65e1cfad..c6710243 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/array_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/array_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ArrayProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/audio_channel.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/audio_channel.rb index 7049777b..55860510 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/audio_channel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/audio_channel.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AudioChannel FIELDS = { 'audio' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_params.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_params.rb index 3c40acd2..16e19c4f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_params.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BedrockParams FIELDS = { 'attention_timeout' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_s_w_a_i_g.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_s_w_a_i_g.rb index 221340e0..1dd063d1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_s_w_a_i_g.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/bedrock_s_w_a_i_g.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BedrockSWAIG FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/boolean_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/boolean_property.rb index 95677939..901619e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/boolean_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/boolean_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BooleanProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script.rb index e69653a4..564d645c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScript FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_list_response.rb index 04d5f182..20aa99ce 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_pagination_response.rb index b63f2260..08995e01 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_request.rb index dbfdf809..1acae968 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptCreateRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_status_code422.rb index c41134f4..d9e92380 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_list_response.rb index e5629a14..82402c2e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_response.rb index 8bbf6061..30efdd3c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_request.rb index 81751aa6..add5b2fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptUpdateRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_status_code422.rb index e8022b24..7e953582 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_script_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLScriptUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook.rb index ee0a0cc5..4cc24c79 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhook FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_list_response.rb index 0e770b80..1ee5b79e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_pagination_response.rb index 73a4043f..75561cc4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_request.rb index ddaa3c2f..132dd552 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_status_code422.rb index 85b4bde2..0fc3ed05 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_list_response.rb index f2f00c16..c07dca28 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_pagination_response.rb index cb92d160..3f067168 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_response.rb index 07b998e7..f4833888 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_request.rb index eb263ddf..f68e70f6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_status_code422.rb index 11d862d4..98351fec 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/c_x_m_l_webhook_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CXMLWebhookUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow.rb index 378657df..d1d27ad4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlow FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_list_response.rb index 1c177dc0..f12c8a71 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_pagination_response.rb index 00d52225..01dca8b1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_request.rb index b4d83037..4d70ad5c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowCreateRequest FIELDS = { 'title' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_status_code422.rb index 4d621e69..9efe4f45 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_list_response.rb index 6a91a321..2dd0022a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_response.rb index 21df7889..c2698427 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_request.rb index 5b087cc5..215efdcb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowUpdateRequest FIELDS = { 'title' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_status_code422.rb index 0846e32c..a9a3274c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version.rb index 8372aa4c..46e747d8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersion FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_document_version.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_document_version.rb index 28cba90a..f05f59b8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_document_version.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_document_version.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersionDeployByDocumentVersion FIELDS = { 'document_version' => :integer diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_version_id.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_version_id.rb index 246288ba..e2145d95 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_version_id.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_by_version_id.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersionDeployByVersionId FIELDS = { 'call_flow_version_id' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_response.rb index a0a67441..e6117f80 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_deploy_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersionDeployResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_list_response.rb index a16ca2ad..2163eae1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_version_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersionListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_versions_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_versions_pagination_response.rb index dd814385..7a8dd8cb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_versions_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/call_flow_versions_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CallFlowVersionsPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/change_context_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/change_context_action.rb index 145bc5e6..357928bd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/change_context_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/change_context_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChangeContextAction FIELDS = { 'change_context' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/change_step_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/change_step_action.rb index 3b4e2bed..041a3e27 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/change_step_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/change_step_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChangeStepAction FIELDS = { 'change_step' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cond.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cond.rb index fae827a8..f43719c7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cond.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cond.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Cond FIELDS = { 'cond' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cond_else.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cond_else.rb index fa070b37..853e544c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cond_else.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cond_else.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CondElse FIELDS = { 'else' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cond_reg.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cond_reg.rb index 43d7cf86..b1555961 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cond_reg.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cond_reg.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CondReg FIELDS = { 'when' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room.rb index 7d894ef9..a08f3e36 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoom FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_list_response.rb index a967cf44..b4d81269 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_pagination_response.rb index 7902bd51..377c5e88 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_request.rb index 75686be7..6f93ea52 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_status_code422.rb index 58c261ce..1c0437b4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_list_response.rb index a546f8bb..5c4a7437 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_response.rb index 5c5fe4a0..4d1c1fd4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_request.rb index ed853280..57ae18f0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_status_code422.rb index fcef27bd..37fb1b4c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conference_room_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceRoomUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect.rb index 5166e35e..fa80bac5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Connect FIELDS = { 'connect' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_parallel.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_parallel.rb index fe8df94d..5d2d0fea 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_parallel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_parallel.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial.rb index 9f70a937..c857f18c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSerial FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial_parallel.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial_parallel.rb index aa5dd2f7..ef8b83dc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial_parallel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_serial_parallel.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSerialParallel FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_single.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_single.rb index d0d81e8b..cab17296 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_single.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_device_single.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectDeviceSingle FIELDS = { 'from' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_headers.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_headers.rb index eb12795c..faab2eba 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_headers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_headers.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectHeaders FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_switch.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_switch.rb index 1f56e116..5512c985 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/connect_switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/connect_switch.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConnectSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/const_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/const_property.rb index 7b963044..882b8844 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/const_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/const_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConstProperty FIELDS = { 'const' => :any diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/context_p_o_m_steps.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/context_p_o_m_steps.rb index c924de9f..06cb22e3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/context_p_o_m_steps.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/context_p_o_m_steps.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextPOMSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/context_switch_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/context_switch_action.rb index 159ed690..4cdc8032 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/context_switch_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/context_switch_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextSwitchAction FIELDS = { 'context_switch' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/context_text_steps.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/context_text_steps.rb index 52ea74e1..9c58f4d4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/context_text_steps.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/context_text_steps.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextTextSteps FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts.rb index 0e361090..80021524 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Contexts FIELDS = { 'default' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object.rb index 0ee8a1e9..b5bbd382 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsPOMObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object_update.rb index 8a2bb9ce..7c12eda0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_p_o_m_object_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsPOMObjectUpdate FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object.rb index a6361f0f..8bbcce17 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsTextObject FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object_update.rb index 78e5cf04..2b10e882 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_text_object_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsTextObjectUpdate FIELDS = { 'steps' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_update.rb index c4762b43..2abd88d9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/contexts_update.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ContextsUpdate FIELDS = { 'default' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/conversation_message.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/conversation_message.rb index a3e06f62..e813b6b5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/conversation_message.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/conversation_message.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConversationMessage FIELDS = { 'role' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application.rb index 78dba96a..a0899a89 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplication FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_list_response.rb index b97d423a..3b670bce 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_pagination_response.rb index 0f9c5e69..fb84f83c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_list_response.rb index 7945c979..729c6a48 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_pagination_response.rb index 4f912f5c..28d2628b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_response.rb index dda002df..28251f50 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_request.rb index 32a5ae39..4abe5a71 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationUpdateRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_status_code422.rb index 5f99a3ba..ede91d85 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/cxml_application_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlApplicationUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/data_map.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/data_map.rb index 2209b1f7..61a124ad 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/data_map.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/data_map.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DataMap FIELDS = { 'output' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/denoise.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/denoise.rb index 347a9bf3..7c5376b2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/denoise.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/denoise.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Denoise FIELDS = { 'denoise' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/detect_machine.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/detect_machine.rb index 811008ce..189562e6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/detect_machine.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/detect_machine.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DetectMachine FIELDS = { 'detect_machine' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialog_flow_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialog_flow_pagination_response.rb index 83360642..bd04c818 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialog_flow_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialog_flow_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogFlowPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent.rb index e8871108..6f744339 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgent FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_list_response.rb index b97771c7..7a08e20a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_pagination_response.rb index 8d788706..1f47131d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_list_response.rb index aa714973..ef2eca84 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_response.rb index 44f2b360..f44e96ff 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_request.rb index d5ab236a..3d0a0769 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_status_code422.rb index 6eeb3146..211b5a53 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/dialogflow_agent_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowAgentUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_assign_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_assign_request.rb index d2639367..3a38cbf4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_assign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_assign_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplicationAssignRequest FIELDS = { 'domain_application_id' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_create_status_code422.rb index ae6cbd29..ad041fa7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplicationCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_response.rb index 8ba10e78..13daff51 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/domain_application_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplicationResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/embed_token_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/embed_token_create_status_code422.rb index 63a9eee4..7261ece5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/embed_token_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/embed_token_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EmbedTokenCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_request.rb index 8aab19fb..0dd2617a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EmbedsTokensRequest FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_response.rb index 8cee1561..9c3ad8b6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/embeds_tokens_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EmbedsTokensResponse FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue.rb index 64970525..8c17bf76 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EnterQueue FIELDS = { 'enter_queue' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue_object.rb index 3ce5b062..bbc2331a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/enter_queue_object.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class EnterQueueObject FIELDS = { 'queue_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/execute.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/execute.rb index d8fe2a60..f3d94a39 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/execute.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/execute.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Execute FIELDS = { 'execute' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/execute_switch.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/execute_switch.rb index da4e6d41..b0f00190 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/execute_switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/execute_switch.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ExecuteSwitch FIELDS = { 'variable' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/expression.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/expression.rb index f49df003..8215abb4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/expression.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/expression.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Expression FIELDS = { 'string' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address.rb index 3384d8f9..7ac04e11 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddress FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_app.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_app.rb index 28232a77..4a190b7d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_app.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_app.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressApp FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_call.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_call.rb index ccc863e1..7415702d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_call.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressCall FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_pagination_response.rb index 53615a43..e66a5a59 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_room.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_room.rb index e84fdf40..9e619887 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_room.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_room.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressRoom FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_subscriber.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_subscriber.rb index e547b8bd..5d72fd73 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_subscriber.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_address_subscriber.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressSubscriber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_addresses_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_addresses_response.rb index ff0b3b7c..f539da10 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_addresses_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/fabric_addresses_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricAddressesResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_conector_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_conector_pagination_response.rb index 7aa433fc..a908b861 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_conector_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_conector_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConectorPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector.rb index 42611cd6..bb9856ba 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnector FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_list_response.rb index 2e7f231e..94686123 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_pagination_response.rb index 7eb53610..af31d590 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_request.rb index 545a7f69..e0b850a4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_status_code422.rb index cfae0103..08be1b3a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_list_response.rb index 25d915b2..f131bc24 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_response.rb index ca48467f..be138743 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_request.rb index cbbb9b60..e1580efa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_status_code422.rb index e1f1826d..07d1e11f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/freeswitch_connector_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FreeswitchConnectorUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/function_parameters.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/function_parameters.rb index dcd561ca..bcb50379 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/function_parameters.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/function_parameters.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FunctionParameters FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/goto.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/goto.rb index 64cf6d7a..624d75e4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/goto.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/goto.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Goto FIELDS = { 'goto' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/guest_token_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/guest_token_create_status_code422.rb index 8f8328b4..2c48f1ed 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/guest_token_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/guest_token_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class GuestTokenCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/hang_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/hang_up_hook_s_w_a_i_g_function.rb index f5219aa7..ba2405b1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/hang_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/hang_up_hook_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HangUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/hangup.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/hangup.rb index a40755a8..338a0c8f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/hangup.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/hangup.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Hangup FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/hangup_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/hangup_action.rb index d38c9e19..ec369d07 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/hangup_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/hangup_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HangupAction FIELDS = { 'hangup' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/hint.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/hint.rb index 6f8d4d6d..bf07cde7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/hint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/hint.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Hint FIELDS = { 'hint' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/hold_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/hold_action.rb index b2b38363..92b23870 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/hold_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/hold_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class HoldAction FIELDS = { 'hold' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/inject_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/inject_action.rb index 77b48bfc..ce257c90 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/inject_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/inject_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class InjectAction FIELDS = { 'inject' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/integer_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/integer_property.rb index f29cad40..9a1beb61 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/integer_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/integer_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class IntegerProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/invite_token_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/invite_token_create_status_code422.rb index 0fe5e6f0..562e2798 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/invite_token_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/invite_token_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class InviteTokenCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference.rb index c7189194..3e1afcaa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinConference FIELDS = { 'join_conference' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference_object.rb index b0cd63e4..b4d218a7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/join_conference_object.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinConferenceObject FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/join_room.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/join_room.rb index dc867e08..60862d5c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/join_room.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/join_room.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class JoinRoom FIELDS = { 'join_room' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/label.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/label.rb index ebdad7a1..29398cac 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/label.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/label.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Label FIELDS = { 'label' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/language_params.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/language_params.rb index 04fedfd0..6e3d6bcb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/language_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/language_params.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguageParams FIELDS = { 'stability' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_fillers.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_fillers.rb index e40283ca..c09a4ae7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_fillers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_fillers.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguagesWithFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_solo_fillers.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_solo_fillers.rb index 76e236c4..94421c02 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_solo_fillers.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/languages_with_solo_fillers.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LanguagesWithSoloFillers FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/live_transcribe.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/live_transcribe.rb index b13b926c..24658c7c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/live_transcribe.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/live_transcribe.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranscribe FIELDS = { 'live_transcribe' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/live_translate.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/live_translate.rb index 491bb14c..5474d0f8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/live_translate.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/live_translate.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LiveTranslate FIELDS = { 'live_translate' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/messaging_channel.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/messaging_channel.rb index 282f50f0..a32da294 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/messaging_channel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/messaging_channel.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessagingChannel FIELDS = { 'messaging' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/null_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/null_property.rb index dcdd49cd..373216f0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/null_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/null_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NullProperty FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/number_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/number_property.rb index b7a4ca7b..82fbbff1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/number_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/number_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/object_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/object_property.rb index d6316495..8de4df40 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/object_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/object_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ObjectProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/one_of_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/one_of_property.rb index 09375668..627e19f2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/one_of_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/one_of_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class OneOfProperty FIELDS = { 'oneOf' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/output.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/output.rb index 38ae8264..7f52fdc9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/output.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/output.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Output FIELDS = { 'response' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pay.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pay.rb index 566ef15e..d2ab8485 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pay.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pay.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Pay FIELDS = { 'pay' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_parameters.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_parameters.rb index 587b63cd..b6b1950a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_parameters.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_parameters.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayParameters FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_play_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_play_action.rb index 87418074..461ebaf1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_play_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_play_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPromptPlayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_say_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_say_action.rb index 8554baeb..9db7e8d3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_say_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompt_say_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPromptSayAction FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompts.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompts.rb index 8b54be18..45df274d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompts.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pay_prompts.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PayPrompts FIELDS = { 'actions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_assign_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_assign_request.rb index 651efac1..ecdb4cb3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_assign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_assign_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneRouteAssignRequest FIELDS = { 'phone_route_id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_create_status_code422.rb index 57caef56..de8d01b3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneRouteCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_response.rb index 00665997..23cb3c05 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/phone_route_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneRouteResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/play.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/play.rb index 6774cf79..b956a718 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/play.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/play.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Play FIELDS = { 'play' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l.rb index d4d61180..35c4b31f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlayWithURL FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l_s.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l_s.rb index 2e0bafb7..052db7dd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l_s.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/play_with_u_r_l_s.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlayWithURLS FIELDS = { 'auto_answer' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/playback_b_g_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/playback_b_g_action.rb index dc996203..3af352a1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/playback_b_g_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/playback_b_g_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PlaybackBGAction FIELDS = { 'playback_bg' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_body_content.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_body_content.rb index 3a3d5cf6..9687c8a7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_body_content.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_body_content.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PomSectionBodyContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_bullets_content.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_bullets_content.rb index f0d2b25b..e32ce0be 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_bullets_content.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pom_section_bullets_content.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PomSectionBulletsContent FIELDS = { 'title' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/prompt.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/prompt.rb index 9a3f3f58..d123fe2c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/prompt.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/prompt.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Prompt FIELDS = { 'prompt' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/pronounce.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/pronounce.rb index 46bc6dfb..69438ed3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/pronounce.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/pronounce.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Pronounce FIELDS = { 'replace' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/receive_fax.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/receive_fax.rb index 767246c5..67fdbdc2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/receive_fax.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/receive_fax.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ReceiveFax FIELDS = { 'receive_fax' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/record.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/record.rb index 82935186..abadb480 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/record.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/record.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Record FIELDS = { 'record' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/record_call.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/record_call.rb index 99c6b56d..83c9be23 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/record_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/record_call.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RecordCall FIELDS = { 'record_call' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/refresh_token_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/refresh_token_status_code422.rb index 18c21642..5b2276ea 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/refresh_token_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/refresh_token_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RefreshTokenStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application.rb index 0b49f36a..518f003f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplication FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_list_response.rb index cca5ce30..058a8775 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_pagination_response.rb index eb4029be..cf25d96a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_request.rb index f4756fa2..e6717a32 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_status_code422.rb index 125e879e..39d01600 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_list_response.rb index e266c403..7e0e3675 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_response.rb index 14588c5b..2e01f254 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_request.rb index 62665657..48df3f67 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_status_code422.rb index 85fd3503..aa0c5e4a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/relay_application_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayApplicationUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/request.rb index 065e4447..f5e19029 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/request.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Request FIELDS = { 'request' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_list_response.rb index 8ae08282..f6e7c28c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_pagination_response.rb index 5641a26a..fad0af91 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_list_response.rb index 5f993c52..cb101c90 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_pagination_response.rb index ed5e894a..7206fec4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourcePaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_a_i.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_a_i.rb index 95575ddb..d6825035 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_a_i.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_a_i.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseAI FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_application.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_application.rb index a94ba2f0..c9572d77 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_application.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_application.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseCXMLApplication FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_script.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_script.rb index f236eef0..250f11b9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_script.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_script.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseCXMLScript FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_webhook.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_webhook.rb index 72fa93eb..f42956e5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_c_x_m_l_webhook.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseCXMLWebhook FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_call_flow.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_call_flow.rb index cff698c0..2a76a238 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_call_flow.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_call_flow.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseCallFlow FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_conference_room.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_conference_room.rb index 28d1cdf5..4a4ef5e5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_conference_room.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_conference_room.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseConferenceRoom FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_dialog_flow_agent.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_dialog_flow_agent.rb index 2940e326..c13df110 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_dialog_flow_agent.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_dialog_flow_agent.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseDialogFlowAgent FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_f_s_connector.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_f_s_connector.rb index 43459667..019aa7f2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_f_s_connector.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_f_s_connector.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseFSConnector FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_relay_app.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_relay_app.rb index 4877384d..b1bec553 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_relay_app.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_relay_app.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseRelayApp FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_script.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_script.rb index 96bc286a..e88b8e15 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_script.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_script.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseSWMLScript FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_webhook.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_webhook.rb index 605f440c..79efdaea 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_s_w_m_l_webhook.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseSWMLWebhook FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_endpoint.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_endpoint.rb index bdb07aef..02cb674f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_endpoint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_endpoint.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseSipEndpoint FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_gateway.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_gateway.rb index 16ff1dbd..6422a792 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_gateway.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_sip_gateway.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseSipGateway FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_subscriber.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_subscriber.rb index 5b5bcb1e..5439bb93 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_subscriber.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_response_subscriber.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceResponseSubscriber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_assign_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_assign_request.rb index 961f873e..89f14894 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_assign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_assign_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceSipEndpointAssignRequest FIELDS = { 'sip_endpoint_id' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_create_status_code422.rb index b6618f94..5e37e418 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceSipEndpointCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_response.rb index adf092ff..29c4adb1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceSipEndpointResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_update_status_code422.rb index 9338d6e1..72950ffc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sip_endpoint_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceSipEndpointUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sub_sip_endpoint_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sub_sip_endpoint_create_status_code422.rb index 9db640b0..5db99c35 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sub_sip_endpoint_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/resource_sub_sip_endpoint_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ResourceSubSipEndpointCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/return.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/return.rb index 5d18033e..548178de 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/return.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/return.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Return FIELDS = { 'return' => :any diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_i_p_refer.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_i_p_refer.rb index 5065b526..c3437bfb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_i_p_refer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_i_p_refer.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SIPRefer FIELDS = { 'sip_refer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_body.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_body.rb index 49a9a860..dc2f4815 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_body.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_body.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SMSWithBody FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_media.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_media.rb index 1fadb3e7..878290cd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_media.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_m_s_with_media.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SMSWithMedia FIELDS = { 'to_number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g.rb index fe3f70e0..c7db154c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIG FIELDS = { 'defaults' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_defaults.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_defaults.rb index 22f04b29..ad61b1e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_defaults.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_defaults.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGDefaults FIELDS = { 'web_hook_url' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_includes.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_includes.rb index 24e03cfd..0d8ad1db 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_includes.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_includes.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGIncludes FIELDS = { 'functions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler.rb index 81ab5f5b..022d74ca 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGInternalFiller FIELDS = { 'hangup' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler_update.rb index 23fe02f6..0b0f783f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_internal_filler_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGInternalFillerUpdate FIELDS = { 'hangup' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_update.rb index 78fe7034..5dd945b8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_a_i_g_update.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWAIGUpdate FIELDS = { 'defaults' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_action.rb index 54a5f367..fa948baa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLAction FIELDS = { 'SWML' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_object.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_object.rb index 6d02e063..669d24b3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_object.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_object.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLObject FIELDS = { 'version' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_list_response.rb index 99ea5286..36e60860 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLScriptAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_pagination_response.rb index 5b07fd21..1c4c2d11 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_script_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLScriptAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook.rb index 9fdc816e..3a4bd002 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhook FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_list_response.rb index 6e5a5b60..212def0f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_pagination_response.rb index 505e65d4..bf0b96d8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_create_request.rb index 88bbc79f..de99dcc5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_list_response.rb index 302ec156..099d0b75 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_pagination_response.rb index 88cd12bc..a3e0e5e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_response.rb index a4b9655d..ecc68020 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_update_request.rb index 29a828aa..266bb422 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/s_w_m_l_webhook_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SWMLWebhookUpdateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/say_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/say_action.rb index 6e0699a8..a994e74b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/say_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/say_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SayAction FIELDS = { 'say' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/section.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/section.rb index 050eaeaa..d1e16919 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/section.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/section.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Section FIELDS = { 'main' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/send_digits.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/send_digits.rb index 7b13b1e0..e2b865a9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/send_digits.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/send_digits.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendDigits FIELDS = { 'send_digits' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/send_fax.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/send_fax.rb index 01090a46..0ef5182c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/send_fax.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/send_fax.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendFax FIELDS = { 'send_fax' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/send_s_m_s.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/send_s_m_s.rb index 8080f860..c364a81c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/send_s_m_s.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/send_s_m_s.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SendSMS FIELDS = { 'send_sms' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/set.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/set.rb index d1098123..94d61cb9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/set.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/set.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Set FIELDS = { 'set' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/set_global_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/set_global_data_action.rb index 75d9e742..9ed2c0fd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/set_global_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/set_global_data_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SetGlobalDataAction FIELDS = { 'set_global_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/set_meta_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/set_meta_data_action.rb index 6bd49a82..d65068a9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/set_meta_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/set_meta_data_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SetMetaDataAction FIELDS = { 'set_meta_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint.rb index a56fcd21..147eaefd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpoint FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_list_response.rb index 2d654251..498c6127 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_pagination_response.rb index 94c9a182..cc556f89 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_request.rb index 1908d099..4dc75989 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointCreateRequest FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_status_code422.rb index 9cc78724..26c95def 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_list_response.rb index e77cfde7..02abd4ca 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_pagination_response.rb index d9b0b1ea..29698ae2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_response.rb index 54d22bb6..9593392e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_request.rb index f328b36a..ddc7a819 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointUpdateRequest FIELDS = { 'username' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_status_code422.rb index e2d182d5..4e5081d7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_endpoint_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway.rb index 26e15d51..7ce604cb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGateway FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_list_response.rb index ca9b9117..c24a5d65 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayAddressListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_pagination_response.rb index e28ddde9..f25a0678 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_create_status_code422.rb index fd34fc26..30ff6b31 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_list_response.rb index fa6d941e..dbf9aa2f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_pagination_response.rb index 2f5e039c..c93b5b55 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request.rb index 534db1d7..c39aa68a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request_update.rb index 73a206cf..c953b38f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_request_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayRequestUpdate FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_response.rb index bea72e37..757415f3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sip_gateway_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipGatewayResponse FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/sleep.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/sleep.rb index c545c5de..5158dda7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/sleep.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/sleep.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Sleep FIELDS = { 'sleep' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/start_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/start_action.rb index 811e57c6..7de24df4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/start_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/start_up_hook_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/start_up_hook_s_w_a_i_g_function.rb index cbe3c523..ee646245 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/start_up_hook_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/start_up_hook_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StartUpHookSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_action.rb index e89ed21b..dd51eb92 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopAction FIELDS = { 'stop' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_denoise.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_denoise.rb index 75d981c2..ac5752c6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_denoise.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_denoise.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopDenoise FIELDS = { 'stop_denoise' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_playback_b_g_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_playback_b_g_action.rb index 45000966..79befeb3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_playback_b_g_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_playback_b_g_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopPlaybackBGAction FIELDS = { 'stop_playback_bg' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_record_call.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_record_call.rb index f0c99937..4524ea69 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_record_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_record_call.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopRecordCall FIELDS = { 'stop_record_call' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_tap.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_tap.rb index d93ddd7b..fc316083 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/stop_tap.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/stop_tap.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StopTap FIELDS = { 'stop_tap' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/string_property.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/string_property.rb index d4f12ad4..72ca3adb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/string_property.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/string_property.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class StringProperty FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber.rb index d09e2606..5f9c93f2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Subscriber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_address_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_address_pagination_response.rb index 1e5a66ec..e334c0aa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_address_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_address_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberAddressPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_addresses_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_addresses_response.rb index c913a6b0..398e74ad 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_addresses_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_addresses_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberAddressesResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_create_status_code422.rb index 75ad7682..b12d1b25 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_request.rb index 7c03a5a2..eb380b59 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberGuestTokenCreateRequest FIELDS = { 'allowed_addresses' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_response.rb index 5958b690..f6dcd652 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_guest_token_create_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberGuestTokenCreateResponse FIELDS = { 'token' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_request.rb index b884f9a8..d2c50fa4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberInviteTokenCreateRequest FIELDS = { 'address_id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_response.rb index 32d5dc64..e367ff93 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_invite_token_create_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberInviteTokenCreateResponse FIELDS = { 'token' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_list_response.rb index de8fe1f4..d416c262 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_pagination_response.rb index 96fc34aa..6c684a1e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_request.rb index a360a9a7..38143c12 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberRefreshTokenRequest FIELDS = { 'refresh_token' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_response.rb index b53f0147..48fba287 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_refresh_token_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberRefreshTokenResponse FIELDS = { 'token' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_request.rb index 2de05de5..8582189c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_request.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberRequest FIELDS = { 'password' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_response.rb index 825695c2..a1d0133a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberResponse FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_s_i_p_endpoint.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_s_i_p_endpoint.rb index d3ff5b8b..419b3dae 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_s_i_p_endpoint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_s_i_p_endpoint.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberSIPEndpoint FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_list_response.rb index c8bda561..38388901 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberSipEndpointListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_pagination_response.rb index 6b875b7e..e3473fa4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_pagination_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberSipEndpointPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request.rb index 26f98303..e70123d6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberSipEndpointRequest FIELDS = { 'username' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request_update.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request_update.rb index 09d107ea..b29aa033 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request_update.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_sip_endpoint_request_update.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberSipEndpointRequestUpdate FIELDS = { 'username' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_request.rb index e172b426..432a56a4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberTokenRequest FIELDS = { 'reference' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_response.rb index f68fb454..b627e264 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberTokenResponse FIELDS = { 'subscriber_id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_status_code422.rb index d99923a7..8b97d8b3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_token_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberTokenStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_update_status_code422.rb index 71272e76..7f09557a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/subscriber_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SubscriberUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_action.rb index 4079cf51..61ab21dd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_conversation_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_conversation_s_w_a_i_g_function.rb index c4dd70f0..0f390802 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_conversation_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/summarize_conversation_s_w_a_i_g_function.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SummarizeConversationSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/switch.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/switch.rb index fa8f3caf..665c9168 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/switch.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/switch.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Switch FIELDS = { 'switch' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script.rb index 15bb4376..0b0040ab 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScript FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_request.rb index 96c1b20a..0d164fb7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptCreateRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_status_code422.rb index b53f0a22..d345b194 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_list_response.rb index 14492fd0..6cd3b859 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_list_response.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptListResponse FIELDS = { 'data' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_paginationresponse.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_paginationresponse.rb index 05881442..f0431134 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_paginationresponse.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_paginationresponse.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptPaginationresponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_response.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_response.rb index 764ddf0e..43eb5c6f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_response.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_request.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_request.rb index 56f42cfc..b9466022 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_request.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptUpdateRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_status_code422.rb index fcdab9fa..758e8bf7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_script_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlScriptUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_create_status_code422.rb index cb17d176..efb9ce90 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_create_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlWebhookCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_update_status_code422.rb index 192fd49d..0796877b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/swml_webhook_update_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlWebhookUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/tap.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/tap.rb index bcd6eaec..513ed862 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/tap.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/tap.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Tap FIELDS = { 'tap' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/toggle_functions_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/toggle_functions_action.rb index 647b2349..51029255 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/toggle_functions_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/toggle_functions_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ToggleFunctionsAction FIELDS = { 'toggle_functions' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_start_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_start_action.rb index 70cd5dda..e768235f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_start_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_start_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TranscribeStartAction FIELDS = { 'start' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_summarize_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_summarize_action.rb index a45a958e..b9663262 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_summarize_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/transcribe_summarize_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TranscribeSummarizeAction FIELDS = { 'summarize' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/transfer.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/transfer.rb index 13d680b6..162386a1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/transfer.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/transfer.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Transfer FIELDS = { 'transfer' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_rest_api_error_item.rb index 2948c134..20da0a93 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code401.rb index c3d8a619..cf4ab943 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code403.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code403.rb index afe1787e..c6a37019 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code403.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code403.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode403 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code404.rb index eafa087b..5938267e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code422.rb index 663e31d7..4ad94b8f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code422.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code500.rb index b565ca95..4571bf1e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/unset.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/unset.rb index 30408f1a..8c4f9db9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/unset.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/unset.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Unset FIELDS = { 'unset' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/unset_global_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/unset_global_data_action.rb index ab798c6e..4a21f9e1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/unset_global_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/unset_global_data_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UnsetGlobalDataAction FIELDS = { 'unset_global_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/unset_meta_data_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/unset_meta_data_action.rb index 778fc713..f83388ad 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/unset_meta_data_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/unset_meta_data_action.rb @@ -22,8 +22,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UnsetMetaDataAction FIELDS = { 'unset_meta_data' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/user_event.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/user_event.rb index 5135e6ac..85ce21f5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/user_event.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/user_event.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserEvent FIELDS = { 'user_event' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/user_input_action.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/user_input_action.rb index 310846ff..a2db2a2e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/user_input_action.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/user_input_action.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserInputAction FIELDS = { 'user_input' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/user_s_w_a_i_g_function.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/user_s_w_a_i_g_function.rb index d38567ee..4343ecd9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/user_s_w_a_i_g_function.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/user_s_w_a_i_g_function.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UserSWAIGFunction FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/video_channel.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/video_channel.rb index 8b728bf0..91b20572 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/video_channel.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/video_channel.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VideoChannel FIELDS = { 'video' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fabric/webhook.rb b/lib/signalwire/rest/namespaces/generated/types/fabric/webhook.rb index 82527448..cec55841 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fabric/webhook.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fabric/webhook.rb @@ -21,8 +21,8 @@ module Fabric # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Webhook FIELDS = { 'expressions' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/charge_detail.rb b/lib/signalwire/rest/namespaces/generated/types/fax/charge_detail.rb index 521f9e69..19c55d19 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/charge_detail.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/charge_detail.rb @@ -21,8 +21,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetail FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/fax_log.rb b/lib/signalwire/rest/namespaces/generated/types/fax/fax_log.rb index c2fea822..292fd566 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/fax_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/fax_log.rb @@ -21,8 +21,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FaxLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/fax_log_show_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fax/fax_log_show_status_code422.rb index 808f2dd1..9911be25 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/fax_log_show_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/fax_log_show_status_code422.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FaxLogShowStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/fax_logs_list_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/fax/fax_logs_list_status_code422.rb index 3eeb353b..9b0f9d76 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/fax_logs_list_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/fax_logs_list_status_code422.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FaxLogsListStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/log_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/fax/log_list_response.rb index f083d72e..bc6eea3d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/log_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/log_list_response.rb @@ -21,8 +21,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/log_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/fax/log_pagination_response.rb index 520bf851..93bd84fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/log_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/log_pagination_response.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/log_response.rb b/lib/signalwire/rest/namespaces/generated/types/fax/log_response.rb index d56ed0ce..f0b4ba80 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/log_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/log_response.rb @@ -21,8 +21,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_rest_api_error_item.rb index 8498c1dc..4eb21ebd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code400.rb index fa086483..c2386290 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code401.rb index 66557e2b..aa60a294 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code404.rb index 672ce449..a2969fe3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code500.rb index fae6309c..02a1ad95 100644 --- a/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/fax/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Fax # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/charge_details.rb b/lib/signalwire/rest/namespaces/generated/types/logs/charge_details.rb index bc8cde60..35173047 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/charge_details.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/charge_details.rb @@ -21,8 +21,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetails FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/conference_log_pagination_links.rb b/lib/signalwire/rest/namespaces/generated/types/logs/conference_log_pagination_links.rb index be24b005..ef7128ec 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/conference_log_pagination_links.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/conference_log_pagination_links.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceLogPaginationLinks FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/conference_logs_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/logs/conference_logs_status_code422.rb index 754d09d6..27360857 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/conference_logs_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/conference_logs_status_code422.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceLogsStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/conferences_response.rb b/lib/signalwire/rest/namespaces/generated/types/logs/conferences_response.rb index 60ec0ef0..1fc80383 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/conferences_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/conferences_response.rb @@ -21,8 +21,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferencesResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/cxml_conference.rb b/lib/signalwire/rest/namespaces/generated/types/logs/cxml_conference.rb index 4833d28c..ebac7fc9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/cxml_conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/cxml_conference.rb @@ -21,8 +21,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CxmlConference FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/relay_conference.rb b/lib/signalwire/rest/namespaces/generated/types/logs/relay_conference.rb index adffb052..7aef94ac 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/relay_conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/relay_conference.rb @@ -21,8 +21,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayConference FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_rest_api_error_item.rb index b96cf9ac..04b5d0df 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code401.rb index 0eff07aa..af408046 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code500.rb index 8f743bfc..cd0e4ee4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/logs/video_room_session_conference.rb b/lib/signalwire/rest/namespaces/generated/types/logs/video_room_session_conference.rb index cce70adf..4ffedd6e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/logs/video_room_session_conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/logs/video_room_session_conference.rb @@ -22,8 +22,8 @@ module Logs # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VideoRoomSessionConference FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/charge_detail.rb b/lib/signalwire/rest/namespaces/generated/types/message/charge_detail.rb index c0ca48b0..7b4f01ef 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/charge_detail.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/charge_detail.rb @@ -21,8 +21,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetail FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/log_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/message/log_list_response.rb index 6c3565fd..60693e5e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/log_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/log_list_response.rb @@ -21,8 +21,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/log_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/message/log_pagination_response.rb index 61368cd3..c6d19c8d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/log_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/log_pagination_response.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/log_retrieve_response.rb b/lib/signalwire/rest/namespaces/generated/types/message/log_retrieve_response.rb index 2a1e82e3..ef236cef 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/log_retrieve_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/log_retrieve_response.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogRetrieveResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/message_log.rb b/lib/signalwire/rest/namespaces/generated/types/message/message_log.rb index 7a51972b..21acf320 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/message_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/message_log.rb @@ -21,8 +21,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessageLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/message_log_show_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/message/message_log_show_status_code422.rb index ac257cab..c4b93477 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/message_log_show_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/message_log_show_status_code422.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessageLogShowStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/message/message_logs_list_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/message/message_logs_list_status_code422.rb index 5086b94a..5e7a7365 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/message_logs_list_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/message_logs_list_status_code422.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessageLogsListStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_rest_api_error_item.rb index 54e4f40f..11f946df 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code400.rb index e2252e51..7de30c85 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code401.rb index 9c53569a..448dd75b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code404.rb index b2985a0a..cc816559 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code500.rb index 9a4deb40..bb1ff627 100644 --- a/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/message/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Message # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/create_message_request.rb b/lib/signalwire/rest/namespaces/generated/types/messages/create_message_request.rb index eb215471..4405d493 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/create_message_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/create_message_request.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateMessageRequest FIELDS = { 'to' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/message.rb b/lib/signalwire/rest/namespaces/generated/types/messages/message.rb index 6f0fa237..a9e3b6a9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/message.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/message.rb @@ -21,8 +21,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Message FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/messages_create_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/messages/messages_create_status_code422.rb index fa207cb0..32809964 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/messages_create_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/messages_create_status_code422.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessagesCreateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/messages_update_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/messages/messages_update_status_code422.rb index 3f103119..55009a6f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/messages_update_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/messages_update_status_code422.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MessagesUpdateStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_rest_api_error_item.rb index 1de33619..d2dc43f0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code400.rb index b3207215..7254f5d6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code401.rb index 04e2dff7..c91726ef 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code404.rb index 2e5ece30..9402f5fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code500.rb index 22263bc5..954ee1c0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/messages/update_message_request.rb b/lib/signalwire/rest/namespaces/generated/types/messages/update_message_request.rb index 31fa76f1..0ecc7f7e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/messages/update_message_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/messages/update_message_request.rb @@ -22,8 +22,8 @@ module Messages # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateMessageRequest FIELDS = { 'body' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/project/create_token_request.rb b/lib/signalwire/rest/namespaces/generated/types/project/create_token_request.rb index ef52b1ad..b2a892b6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/create_token_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/create_token_request.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateTokenRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/project/token_response.rb b/lib/signalwire/rest/namespaces/generated/types/project/token_response.rb index 5aae9fba..5905ced7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/token_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/token_response.rb @@ -21,8 +21,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TokenResponse FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/project/token_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/project/token_status_code422.rb index 20295f6f..32144725 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/token_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/token_status_code422.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class TokenStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_rest_api_error_item.rb index 2ac59ba8..5be5550c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code401.rb index 1dec809f..ee48c849 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code404.rb index 97f0c75c..81593285 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code500.rb index 1e1c881e..57e36b5e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/project/update_token_request.rb b/lib/signalwire/rest/namespaces/generated/types/project/update_token_request.rb index ecaf0858..dfaceeb6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/project/update_token_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/project/update_token_request.rb @@ -22,8 +22,8 @@ module Project # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateTokenRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/project.rb b/lib/signalwire/rest/namespaces/generated/types/projects/project.rb index 84500d68..232b47d2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/project.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/project.rb @@ -21,8 +21,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Project FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/project_create.rb b/lib/signalwire/rest/namespaces/generated/types/projects/project_create.rb index 43be9d64..6c7fca73 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/project_create.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/project_create.rb @@ -21,8 +21,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ProjectCreate FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/project_list.rb b/lib/signalwire/rest/namespaces/generated/types/projects/project_list.rb index bb9e8ab6..9cd67c8a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/project_list.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/project_list.rb @@ -21,8 +21,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ProjectList FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/project_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/projects/project_status_code422.rb index 19d3dd34..6c93136e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/project_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/project_status_code422.rb @@ -22,8 +22,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ProjectStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_rest_api_error_item.rb index 4926db2a..6c50c591 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code401.rb index a099cfa7..3163f481 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code403.rb b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code403.rb index e8a110eb..c4ec072e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code403.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code403.rb @@ -22,8 +22,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode403 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code404.rb index 9d92ec4a..1197bf2b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/projects/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Projects # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/new_pub_sub_token.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/new_pub_sub_token.rb index 6242f708..7b0c24a3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/new_pub_sub_token.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/new_pub_sub_token.rb @@ -21,8 +21,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NewPubSubToken FIELDS = { 'ttl' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_read.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_read.rb index 00cd8630..0f66dc99 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_read.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_read.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PubSubPermissionWithRead FIELDS = { 'read' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_write.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_write.rb index 9174354e..c12a1603 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_write.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_permission_with_write.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PubSubPermissionWithWrite FIELDS = { 'read' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token.rb index fa07b662..65d24324 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token.rb @@ -21,8 +21,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PubSubToken FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token422_error.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token422_error.rb index d41e0dfb..aaea49e4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token422_error.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/pub_sub_token422_error.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PubSubToken422Error FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_rest_api_error_item.rb index db5f3266..e8a61174 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code400.rb index 77924549..7e2c4aaf 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code401.rb index 8c4c2dfb..b3607982 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code500.rb index 4578d165..12b476b4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/pubsub/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module PubSub # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/add_number_group_membership_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/add_number_group_membership_request.rb index 7767bee8..d8e6098a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/add_number_group_membership_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/add_number_group_membership_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AddNumberGroupMembershipRequest FIELDS = { 'phone_number_id' => :object diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address.rb index fd108eef..c8652c12 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Address FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_list_response.rb index 1cb833b9..2b4e3944 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AddressListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_response.rb index 02ca1e80..a523ce5b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/address_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AddressResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number.rb index b9d31092..ce2e7d11 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AssignedNumber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number_list_response.rb index 864ddf5b..99dd7a88 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_number_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AssignedNumberListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_phone_number.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_phone_number.rb index 57cb8d72..131060f8 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_phone_number.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/assigned_phone_number.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AssignedPhoneNumber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_number.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_number.rb index 3e70c625..c7466b60 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_number.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_number.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AvailablePhoneNumber FIELDS = { 'number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_numbers_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_numbers_response.rb index 606bd3be..87c8fc2d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_numbers_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/available_phone_numbers_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class AvailablePhoneNumbersResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand.rb index 8fa17eeb..5e3c5009 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Brand FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_list_response.rb index a477d424..ee363f69 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BrandListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_response.rb index 25d5a66d..f2c5df34 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/brand_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class BrandResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign.rb index 3207edd5..9179a61d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Campaign FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_list_response.rb index 439ec430..21281e27 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CampaignListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_response.rb index ef5a9b53..97b75050 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/campaign_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CampaignResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/carrier_lookup_info.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/carrier_lookup_info.rb index ce217cb7..07473933 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/carrier_lookup_info.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/carrier_lookup_info.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CarrierLookupInfo FIELDS = { 'lrn' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/cnam_info.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/cnam_info.rb index 4e7a4cb9..978d2cca 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/cnam_info.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/cnam_info.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CnamInfo FIELDS = { 'caller_id' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_address_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_address_request.rb index 32e63052..41ba6203 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_address_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_address_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateAddressRequest FIELDS = { 'label' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_csp_brand_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_csp_brand_request.rb index 81ca013a..6dd70b50 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_csp_brand_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_csp_brand_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateCspBrandRequest FIELDS = { 'csp_self_registered' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_domain_application_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_domain_application_request.rb index 592f0b4f..cb82affe 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_domain_application_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_domain_application_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateDomainApplicationRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_brand_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_brand_request.rb index b8519b67..1d312163 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_brand_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_brand_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateManagedBrandRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_campaign_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_campaign_request.rb index 8b964c40..733330d6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_campaign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_managed_campaign_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateManagedCampaignRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_number_group_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_number_group_request.rb index 6a4de670..3ec5721a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_number_group_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_number_group_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateNumberGroupRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_order_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_order_request.rb index fa1a0540..435d2354 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_order_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_order_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateOrderRequest FIELDS = { 'phone_numbers' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_partner_campaign_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_partner_campaign_request.rb index 230ba258..1ccf2f05 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_partner_campaign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_partner_campaign_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreatePartnerCampaignRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_queue_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_queue_request.rb index 3d80fab1..9314b089 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_queue_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_queue_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateQueueRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_sip_endpoint_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_sip_endpoint_request.rb index 548d25dc..8efb4864 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_sip_endpoint_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_sip_endpoint_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateSipEndpointRequest FIELDS = { 'username' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_verified_caller_i_d_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_verified_caller_i_d_request.rb index 22eb4aca..770ffdfa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_verified_caller_i_d_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/create_verified_caller_i_d_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateVerifiedCallerIDRequest FIELDS = { 'number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application.rb index 0b23d34a..05f48281 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplication FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_list_response.rb index 96bfd442..3e4139ae 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplicationListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_response.rb index ce1c8c43..c1a03c55 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/domain_application_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DomainApplicationResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/import_phone_number_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/import_phone_number_request.rb index 662ce3af..9079a1d7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/import_phone_number_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/import_phone_number_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ImportPhoneNumberRequest FIELDS = { 'number' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/membership_phone_number.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/membership_phone_number.rb index 2b212ad4..eee73007 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/membership_phone_number.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/membership_phone_number.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MembershipPhoneNumber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_request.rb index e25e16f0..1f902b2d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_request.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MfaRequest FIELDS = { 'to' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_response.rb index 3aec9efa..7f80641a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MfaResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_request.rb index 98e17110..89ebb315 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_request.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MfaVerifyRequest FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_response.rb index 0947ebb0..84ea22da 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/mfa_verify_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class MfaVerifyResponse FIELDS = { 'success' => :boolean diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group.rb index 0f94fbb0..928e625b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroup FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_list_response.rb index 91dae19a..8d81d7cd 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroupListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership.rb index c0bc829c..24ab56cb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroupMembership FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_list_response.rb index 7d9c6053..c0ae6cd6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroupMembershipListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_response.rb index 64faaf83..682e9116 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_membership_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroupMembershipResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_response.rb index a8c5f22e..4d1b2d82 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/number_group_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class NumberGroupResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order.rb index 3138e743..bda14025 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Order FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_list_response.rb index e54d8708..7b55771e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class OrderListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_response.rb index 0c9bef42..904aa2f1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/order_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class OrderResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/pagination_links.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/pagination_links.rb index 2a9564f3..491c08f3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/pagination_links.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/pagination_links.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PaginationLinks FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_call_handler.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_call_handler.rb index fae2df9d..ac8c1fb3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_call_handler.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_call_handler.rb @@ -21,7 +21,7 @@ module RelayRest # PhoneCallHandler — public closed-set for 'PhoneNumberCallHandlerRequest' # ('relay_rest' API). Frozen string constants whose value IS the wire # string (the idiomatic Ruby closed set — not a static enum type), - # grouped into a frozen ALL. Method-less, records [] like the reference. + # grouped into a frozen ALL. Method-less: constants only, no instance methods. class PhoneCallHandler RELAY_CONTEXT = 'relay_context' RELAY_TOPIC = 'relay_topic' diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number.rb index 6a99e349..eadd69eb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneNumber FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_capabilities.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_capabilities.rb index bd138001..c43753ce 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_capabilities.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_capabilities.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneNumberCapabilities FIELDS = { 'voice' => :boolean, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_list_response.rb index 11fe7c42..21720e5e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneNumberListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_lookup_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_lookup_response.rb index 97e91c35..0d5b2410 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_lookup_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_lookup_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneNumberLookupResponse FIELDS = { 'country_code_number' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_response.rb index 01346e8c..4d88ae40 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/phone_number_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PhoneNumberResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/pstn_recording.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/pstn_recording.rb index 991a0576..8174a929 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/pstn_recording.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/pstn_recording.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PstnRecording FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/purchase_phone_number_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/purchase_phone_number_request.rb index 56892d51..91b043c3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/purchase_phone_number_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/purchase_phone_number_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PurchasePhoneNumberRequest FIELDS = { 'number' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue.rb index e7f372d0..b0dda353 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Queue FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_list_response.rb index 44bb0c86..a6172483 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class QueueListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member.rb index b436252e..94e25467 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class QueueMember FIELDS = { 'call_id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_list_response.rb index 0b5f539f..73abc587 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class QueueMemberListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_response.rb index 05cac03a..d2b5762f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_member_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class QueueMemberResponse FIELDS = { 'call_id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_response.rb index c96c501b..3315eccc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/queue_response.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class QueueResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/recording_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/recording_list_response.rb index 369deb01..22014d77 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/recording_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/recording_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RecordingListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code.rb index a329b017..12cd66bb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ShortCode FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_list_response.rb index 68ec7442..a5c56c0d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ShortCodeListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_response.rb index e80a15b7..b77d88c9 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/short_code_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ShortCodeResponse FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint.rb index 76bf1912..bfcb3351 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpoint FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_list_response.rb index 75e1dee5..ab9d66e4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_response.rb index 2ae67249..6ce0e390 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_endpoint_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipEndpointResponse FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_profile_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_profile_response.rb index 6005e03a..c9eb853a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_profile_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_profile_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipProfileResponse FIELDS = { 'domain' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_recording.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_recording.rb index cbdc8d54..88439260 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_recording.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/sip_recording.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SipRecording FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_space_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_space_api_error_item.rb index 5e1f048a..9ffebb0c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_space_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_space_api_error_item.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_SpaceApiErrorItem FIELDS = { 'detail' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code400.rb index be0b2389..f77cd232 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code401.rb index b1a82767..ea25d73f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code404.rb index ca6e3bb8..5a406e3b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code500.rb index 0edbf7bc..cc94a8ee 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_validation_error.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_validation_error.rb index ce860b3f..da193932 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_validation_error.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/types_status_codes_validation_error.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_ValidationError FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_campaign_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_campaign_request.rb index 02fa3788..7f2bab38 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_campaign_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_campaign_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateCampaignRequest FIELDS = { 'name' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_domain_application_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_domain_application_request.rb index dcee1ae9..c9abe9c5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_domain_application_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_domain_application_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateDomainApplicationRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_number_group_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_number_group_request.rb index 6642ed47..08517e0c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_number_group_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_number_group_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateNumberGroupRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_phone_number_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_phone_number_request.rb index 495da2cf..e74080fb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_phone_number_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_phone_number_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdatePhoneNumberRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_queue_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_queue_request.rb index 2382a183..36dc8043 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_queue_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_queue_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateQueueRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_short_code_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_short_code_request.rb index e2dc61f7..e4a40b02 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_short_code_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_short_code_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateShortCodeRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_endpoint_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_endpoint_request.rb index a9838cf7..a4b314fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_endpoint_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_endpoint_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateSipEndpointRequest FIELDS = { 'username' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_profile_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_profile_request.rb index 8140c969..92f00a66 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_profile_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_sip_profile_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateSipProfileRequest FIELDS = { 'domain_identifier' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_verified_caller_i_d_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_verified_caller_i_d_request.rb index 1ddc709d..40310b1e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_verified_caller_i_d_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/update_verified_caller_i_d_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateVerifiedCallerIDRequest FIELDS = { 'name' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d.rb index 16cb7d71..0a85e244 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VerifiedCallerID FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_list_response.rb index fb5efc50..652109ae 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_list_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VerifiedCallerIDListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_response.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_response.rb index a9207ad1..ef6964f6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verified_caller_i_d_response.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VerifiedCallerIDResponse FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verify_caller_i_d_request.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verify_caller_i_d_request.rb index 06908987..d3ce637b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/verify_caller_i_d_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/verify_caller_i_d_request.rb @@ -22,8 +22,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VerifyCallerIDRequest FIELDS = { 'verification_code' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/relay_rest/web_rtc_recording.rb b/lib/signalwire/rest/namespaces/generated/types/relay_rest/web_rtc_recording.rb index 7ff2ba42..ac331509 100644 --- a/lib/signalwire/rest/namespaces/generated/types/relay_rest/web_rtc_recording.rb +++ b/lib/signalwire/rest/namespaces/generated/types/relay_rest/web_rtc_recording.rb @@ -21,8 +21,8 @@ module RelayRest # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class WebRtcRecording FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_conversation_turn.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_conversation_turn.rb index 250d3560..162d53c7 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_conversation_turn.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_conversation_turn.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PostPromptConversationTurn FIELDS = { 'role' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_data.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_data.rb index c60110a7..b88ea6ae 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_data.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_data.rb @@ -21,8 +21,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PostPromptData FIELDS = { 'event_type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_function_call.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_function_call.rb index e247d5ba..027b0f51 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_function_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_function_call.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PostPromptFunctionCall FIELDS = { 'function' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_params.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_params.rb index da0c228e..17c035fa 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_params.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/post_prompt_params.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PostPromptParams FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/signal_wire_error_body.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/signal_wire_error_body.rb index d54b3f85..dc128748 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/signal_wire_error_body.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/signal_wire_error_body.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SignalWireErrorBody FIELDS = { 'code' => :integer, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_argument.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_argument.rb index 31e08687..5130a922 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_argument.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_argument.rb @@ -21,8 +21,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwaigArgument FIELDS = { 'parsed' => :array, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_request_data.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_request_data.rb index 32d3597f..19cc53a3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_request_data.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swaig_request_data.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwaigRequestData FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_call.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_call.rb index d3b77d8e..476f22fc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_call.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_call.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlRequestCall FIELDS = { 'call_id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_data.rb b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_data.rb index b6655ddd..eb30664f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_data.rb +++ b/lib/signalwire/rest/namespaces/generated/types/swml_webhooks/swml_request_data.rb @@ -22,8 +22,8 @@ module SwmlWebhooks # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class SwmlRequestData FIELDS = { 'call' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/active_session.rb b/lib/signalwire/rest/namespaces/generated/types/video/active_session.rb index 9c46f718..1b5547e0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/active_session.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/active_session.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ActiveSession FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/charge_detail.rb b/lib/signalwire/rest/namespaces/generated/types/video/charge_detail.rb index 7499e013..524c56b0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/charge_detail.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/charge_detail.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetail FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/conference.rb b/lib/signalwire/rest/namespaces/generated/types/video/conference.rb index 75ba8603..c0d5d630 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/conference.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/conference.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Conference FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/conference_token.rb b/lib/signalwire/rest/namespaces/generated/types/video/conference_token.rb index 9bd06150..12b612b3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/conference_token.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/conference_token.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ConferenceToken FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/create_conference_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/create_conference_request.rb index ffc98d55..19f0bcee 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/create_conference_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/create_conference_request.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateConferenceRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/create_room_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/create_room_request.rb index dec07b4e..468f4771 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/create_room_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/create_room_request.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateRoomRequest FIELDS = { 'name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/create_room_token_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/create_room_token_request.rb index 17baa4bb..b3b4be83 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/create_room_token_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/create_room_token_request.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateRoomTokenRequest FIELDS = { 'room_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/create_stream_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/create_stream_request.rb index 29c6bd0e..f5533f55 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/create_stream_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/create_stream_request.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class CreateStreamRequest FIELDS = { 'url' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/discarded_log.rb b/lib/signalwire/rest/namespaces/generated/types/video/discarded_log.rb index 207b5c83..24b1f9d3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/discarded_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/discarded_log.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DiscardedLog FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_conference_tokens_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_conference_tokens_response.rb index bb42932b..5f40ce35 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_conference_tokens_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_conference_tokens_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListConferenceTokensResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_conferences_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_conferences_response.rb index ba5cfd5c..08bf2b5b 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_conferences_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_conferences_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListConferencesResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_logs_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_logs_response.rb index 05ec5b8d..3a62f809 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_logs_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_logs_response.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListLogsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_recording_events_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_recording_events_response.rb index 39b29ecd..9c904c04 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_recording_events_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_recording_events_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomRecordingEventsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_recordings_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_recordings_response.rb index 6a934590..7e23efed 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_recordings_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_recordings_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomRecordingsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_events_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_events_response.rb index f22b78de..5e92350d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_events_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_events_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomSessionEventsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_members_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_members_response.rb index 7efd5b6a..6483cf12 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_members_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_members_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomSessionMembersResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_recordings_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_recordings_response.rb index 5cf82855..1dfb819a 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_recordings_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_session_recordings_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomSessionRecordingsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_room_sessions_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_room_sessions_response.rb index 83c1ebed..5f865c83 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_room_sessions_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_room_sessions_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomSessionsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_rooms_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_rooms_response.rb index 7357a554..3ef5094d 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_rooms_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_rooms_response.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListRoomsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/list_streams_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/list_streams_response.rb index 2f8885cb..858ec338 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/list_streams_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/list_streams_response.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ListStreamsResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/log.rb b/lib/signalwire/rest/namespaces/generated/types/video/log.rb index c8baa0ca..c479b019 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/log.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Log FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/pagination_links.rb b/lib/signalwire/rest/namespaces/generated/types/video/pagination_links.rb index 4bcb4247..90158ef6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/pagination_links.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/pagination_links.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class PaginationLinks FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_recording.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_recording.rb index 1383ad79..7d58edbe 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_recording.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_recording.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomRecording FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_response.rb index 75f5d519..948894d5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_response.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomResponse FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_session.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_session.rb index 54f0ef12..55e76c98 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_session.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_session.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomSession FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_session_event.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_session_event.rb index b4cf0903..29052129 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_session_event.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_session_event.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomSessionEvent FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_session_member.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_session_member.rb index 2876bac5..982bff75 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_session_member.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_session_member.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomSessionMember FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_session_summary.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_session_summary.rb index 2ab16d5a..61b5df9c 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_session_summary.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_session_summary.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomSessionSummary FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/room_token_response.rb b/lib/signalwire/rest/namespaces/generated/types/video/room_token_response.rb index 773bd46a..7a892985 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/room_token_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/room_token_response.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RoomTokenResponse FIELDS = { 'token' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/stream.rb b/lib/signalwire/rest/namespaces/generated/types/video/stream.rb index 06a82dc0..2d323944 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/stream.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/stream.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Stream FIELDS = { 'id' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_rest_api_error_item.rb index 3274de07..47089ff0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code400.rb index 54a746e8..842893b2 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code401.rb index 891321f4..d86c90f5 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code403.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code403.rb index edf2a937..f031c38f 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code403.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code403.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode403 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code404.rb index 593b3486..f4b6c5a4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code500.rb index 432e582f..806daf95 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/update_conference_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/update_conference_request.rb index 9f0ef4f9..4c79dae1 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/update_conference_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/update_conference_request.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateConferenceRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/update_room_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/update_room_request.rb index aeda69c8..27d8bac3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/update_room_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/update_room_request.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateRoomRequest FIELDS = { 'display_name' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/video/update_stream_request.rb b/lib/signalwire/rest/namespaces/generated/types/video/update_stream_request.rb index 7f6e8eae..6d3d0213 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/update_stream_request.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/update_stream_request.rb @@ -22,8 +22,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class UpdateStreamRequest FIELDS = { 'url' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/video/video_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/video/video_status_code422.rb index c1c41f77..d7352708 100644 --- a/lib/signalwire/rest/namespaces/generated/types/video/video_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/video/video_status_code422.rb @@ -21,8 +21,8 @@ module Video # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VideoStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/charge_detail.rb b/lib/signalwire/rest/namespaces/generated/types/voice/charge_detail.rb index 1e4a53b8..2b388516 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/charge_detail.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/charge_detail.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class ChargeDetail FIELDS = { 'description' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/dialogflow_voice_log.rb b/lib/signalwire/rest/namespaces/generated/types/voice/dialogflow_voice_log.rb index e565d4cf..80ed0564 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/dialogflow_voice_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/dialogflow_voice_log.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DialogflowVoiceLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/discarded_voice_log.rb b/lib/signalwire/rest/namespaces/generated/types/voice/discarded_voice_log.rb index 7de2451f..a1586c24 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/discarded_voice_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/discarded_voice_log.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class DiscardedVoiceLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/fabric_voice_log.rb b/lib/signalwire/rest/namespaces/generated/types/voice/fabric_voice_log.rb index 20cf475b..a38c3b58 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/fabric_voice_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/fabric_voice_log.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class FabricVoiceLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/log_event.rb b/lib/signalwire/rest/namespaces/generated/types/voice/log_event.rb index 8beabedb..8595e8bb 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/log_event.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/log_event.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogEvent FIELDS = { 'event_at' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/log_events_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/voice/log_events_list_response.rb index 5b8ad918..63a46232 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/log_events_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/log_events_list_response.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogEventsListResponse FIELDS = { 'data' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/log_list_response.rb b/lib/signalwire/rest/namespaces/generated/types/voice/log_list_response.rb index 438ca8ab..13e4e70e 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/log_list_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/log_list_response.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogListResponse FIELDS = { 'links' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/log_pagination_response.rb b/lib/signalwire/rest/namespaces/generated/types/voice/log_pagination_response.rb index b17503ab..65c76675 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/log_pagination_response.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/log_pagination_response.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class LogPaginationResponse FIELDS = { 'self' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/relay_voice_log.rb b/lib/signalwire/rest/namespaces/generated/types/voice/relay_voice_log.rb index 0f07f613..da925fbc 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/relay_voice_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/relay_voice_log.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class RelayVoiceLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_rest_api_error_item.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_rest_api_error_item.rb index 3f431990..85a2a079 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_rest_api_error_item.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_rest_api_error_item.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_RestApiErrorItem FIELDS = { 'type' => :string, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code400.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code400.rb index b6b950f8..be921c69 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code400.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code400.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode400 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code401.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code401.rb index ef5ccdd7..01d16bb6 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code401.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code401.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode401 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code404.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code404.rb index ec499d14..e4148da0 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code404.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code404.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode404 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code422.rb index afbd7985..c72a30d4 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code422.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code500.rb b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code500.rb index 44509a59..34091135 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code500.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/types_status_codes_status_code500.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class Types_StatusCodes_StatusCode500 FIELDS = { 'error' => :string diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/video_room_voice_log.rb b/lib/signalwire/rest/namespaces/generated/types/voice/video_room_voice_log.rb index 625c0e25..ab441774 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/video_room_voice_log.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/video_room_voice_log.rb @@ -21,8 +21,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VideoRoomVoiceLog FIELDS = { 'id' => :object, diff --git a/lib/signalwire/rest/namespaces/generated/types/voice/voice_logs_list_status_code422.rb b/lib/signalwire/rest/namespaces/generated/types/voice/voice_logs_list_status_code422.rb index d2cfbf6a..86c6f9a3 100644 --- a/lib/signalwire/rest/namespaces/generated/types/voice/voice_logs_list_status_code422.rb +++ b/lib/signalwire/rest/namespaces/generated/types/voice/voice_logs_list_status_code422.rb @@ -22,8 +22,8 @@ module Voice # # Method-less data DTO: the frozen FIELDS constant maps each snake wire # key to its JSON type symbol. No reader/writer methods and no - # initialize — the reference records this as a method-less type - # definition, so the surface enumerator surfaces the bare class name. + # initialize — the class is a bare namespace for its FIELDS map, + # describing the wire shape rather than wrapping a payload. class VoiceLogsListStatusCode422 FIELDS = { 'errors' => :array diff --git a/lib/signalwire/rest/namespaces/generated/video_namespace.rb b/lib/signalwire/rest/namespaces/generated/video_namespace.rb index 3217a197..6abb9c53 100644 --- a/lib/signalwire/rest/namespaces/generated/video_namespace.rb +++ b/lib/signalwire/rest/namespaces/generated/video_namespace.rb @@ -9,13 +9,14 @@ # AUTO-GENERATED from the SignalWire REST API specifications — regenerate with: # python3 scripts/generate_rest.py # -# Generated REST client container for the video namespace (§8). +# Generated REST client container for the video namespace. module SignalWire module REST module Namespaces module Generated - # VideoNamespace — generated container grouping the video namespace resources (§8). + # VideoNamespace — groups the video namespace resources; each is exposed + # as a memoized reader on this container. class VideoNamespace attr_reader :conference_tokens, :conferences, :room_recordings, :room_sessions, :room_tokens, :rooms, :streams diff --git a/scripts/generate_rest.py b/scripts/generate_rest.py index f744f48e..d0a261b0 100644 --- a/scripts/generate_rest.py +++ b/scripts/generate_rest.py @@ -1127,7 +1127,7 @@ def emit_command_dispatch(spec: Spec, anchor: str, markup: dict) -> str: # python3 scripts/generate_rest.py # # Generated Fabric base classes: CRUD + list_addresses (the FabricResource -# method-set, §2), differing only by the update HTTP verb (PATCH vs PUT). +# method-set), differing only by the update HTTP verb (PATCH vs PUT). module SignalWire module REST @@ -1308,7 +1308,8 @@ def emit_container(container: str, members: list[tuple[str, str]]) -> str: lines.append(" module REST") lines.append(" module Namespaces") lines.append(" module Generated") - lines.append(f" # {cls} — generated container grouping the {container} namespace resources (§8).") + lines.append(f" # {cls} — groups the {container} namespace resources; each is exposed") + lines.append(" # as a memoized reader on this container.") lines.append(f" class {cls}") accs = [a for a, _ in members] lines.append(f" attr_reader {', '.join(':' + a for a in accs)}") @@ -1322,7 +1323,7 @@ def emit_container(container: str, members: list[tuple[str, str]]) -> str: lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc=f"Generated REST client container for the {container} namespace (§8).") + "\n" + "\n".join(lines) + "\n" + return GEN_HEADER.format(desc=f"Generated REST client container for the {container} namespace.") + "\n" + "\n".join(lines) + "\n" def emit_resource_tree(placed) -> str: @@ -1366,7 +1367,7 @@ def emit_resource_tree(placed) -> str: lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc="Generated REST resource tree module the hand RestClient includes (§8).") + "\n" + "\n".join(lines) + "\n" + return GEN_HEADER.format(desc="Generated REST resource tree module that RestClient includes.") + "\n" + "\n".join(lines) + "\n" # --------------------------------------------------------------------------- @@ -1495,8 +1496,8 @@ def emit_type_class(ns_mod: str, raw_name: str, node: dict, ns_key: str, lines.append(" #") lines.append(" # Method-less data DTO: the frozen FIELDS constant maps each snake wire") lines.append(" # key to its JSON type symbol. No reader/writer methods and no") - lines.append(" # initialize — the reference records this as a method-less type") - lines.append(" # definition, so the surface enumerator surfaces the bare class name.") + lines.append(" # initialize — the class is a bare namespace for its FIELDS map,") + lines.append(" # describing the wire shape rather than wrapping a payload.") lines.append(f" class {rb_name}") # SDK-surface policy from the single overlay (rest-apis/x-sdk-overlay.yaml), keyed by # the SPEC schema name (raw_name, the components/schemas key — NOT the emitted Ruby @@ -1551,7 +1552,7 @@ class by the reference.""" lines.append(f" # {enum_name} — public closed-set for {raw_name!r}") lines.append(f" # ({ns_key!r} API). Frozen string constants whose value IS the wire") lines.append(" # string (the idiomatic Ruby closed set — not a static enum type),") - lines.append(" # grouped into a frozen ALL. Method-less, records [] like the reference.") + lines.append(" # grouped into a frozen ALL. Method-less: constants only, no instance methods.") lines.append(f" class {enum_name}") used: set[str] = set() consts: list[str] = [] @@ -1644,11 +1645,11 @@ def emit_methodless_class(module_segments: list, rb_name: str, properties: dict, lines.append(f"{indent}#") lines.append(f"{indent}# Frozen FIELDS maps each snake wire key to its JSON type symbol.") if emit_readers: - lines.append(f"{indent}# A zero-arg reader per field mirrors the reference's recorded") - lines.append(f"{indent}# accessors (dropped on the SURFACE by the enumerator — method-less there).") + lines.append(f"{indent}# Each field also has a zero-arg reader, so a decoded payload can be") + lines.append(f"{indent}# accessed by name rather than by wire key.") else: - lines.append(f"{indent}# No reader/writer methods and no initialize — a method-less type the") - lines.append(f"{indent}# reference records method-less on both surface and signatures.") + lines.append(f"{indent}# No reader/writer methods and no initialize — the class is a bare") + lines.append(f"{indent}# namespace for its FIELDS map, describing the wire shape only.") lines.append(f"{indent}class {rb_name}") inner = indent + " " # SDK-surface policy from the single overlay (rest-apis/x-sdk-overlay.yaml), keyed From e9161df531beb16cd630bca11ab4bd95cd7c5280 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 03:16:06 -0400 Subject: [PATCH 56/90] docs: drop cross-language porting framing from the shipped public docs The SDK's own YARD comments and guides explained this gem by reference to the Python implementation it was ported from -- "Mirrors Python's `signalwire.list_skills()`", "REQUIRED, matching the reference (`on_summary(self, summary: PostPromptData | None, ...)`)", "the Ruby port does not ship X". That framing is invisible to the PUBLIC-JARGON gate (its ban list catches "the TS port" but not "Mirrors Python's X") and meaningless to the Ruby developer who is the audience: it describes our porting process, not the code in front of them. MOST OF THESE CARRIED A REAL FACT, so the rule was keep the fact, drop the framing -- never delete a sentence that also states a parameter contract, a default, a wire shape, or an error behaviour: - "``summary`` is REQUIRED, matching the reference (``on_summary(self, summary: PostPromptData | None, raw_data=None)``): the slot is nullABLE, not omittABLE" -> "``summary`` is REQUIRED: the slot is nullABLE, not omittABLE, so a caller states `nil` explicitly rather than relying on a default." - POM's "Output matches Python's ``json.dumps(..., indent=2)`` byte-for-byte, with one special case: an empty model serializes to ``\"[]\"``" -> restated as the serialization contract itself, since the `[]` vs `[\n\n]` distinction IS the wire format. - relay/client's dial docs cited the reference for the `dial_timeout` 120-second fallback; that fallback is applied at the WAIT, not the call, which is the only place that fact is written down. Kept. Self-language references stay untouched -- "Ruby's `''` is TRUTHY, so a bare `if body` would emit `\"body\": \"\"`" explains Ruby to Ruby users and is exactly the kind of note that earns its place. Four sites where "Python" is a FACT, not framing, are deliberately kept: `SchemaUtils#generate_method_signature` / `#generate_method_body` and `PYTHON_SCALAR_TYPES` / `#python_type_annotation` genuinely EMIT Python source as codegen output. Also removes internal-machinery notes that had no business shipping: references to the surface enumerator, SURFACE_METHOD_DONORS, PORT_ADDITIONS.md, the cross-port audit, and review-round tags like `ruby_R5 N1`. DOC BUG FIXED IN PASSING: docs/agent_guide.md documented `secure:` as defaulting to FALSE and named the query parameter `token`. Both are wrong and were wrong in the dangerous direction -- `define_tool` defaults `secure: true` (tests/secure_default_test.rb) and the credential is `__token`. The section now also states the refusal behaviour. Comment/prose only: no non-comment line changes in the diff. The gate's own ban list is NOT widened here -- that is a separate, later step, and widening it now would red every port at once. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- README.md | 2 +- bin/swaig-test | 38 ++-- docs/agent_guide.md | 32 ++-- docs/api_reference.md | 6 +- docs/cli_guide.md | 14 +- docs/cloud_functions_guide.md | 6 +- docs/configuration.md | 4 +- docs/sdk_features.md | 8 +- docs/skills_system.md | 4 +- docs/swml_service_guide.md | 2 +- lib/signalwire.rb | 23 +-- lib/signalwire/agent/agent_base.rb | 179 ++++++++---------- lib/signalwire/agents/bedrock.rb | 8 +- lib/signalwire/ai_chat/client.rb | 23 +-- lib/signalwire/contexts/context_builder.rb | 8 +- lib/signalwire/core/agent/prompt/manager.rb | 25 +-- .../core/agent/tools/type_inference.rb | 11 +- lib/signalwire/core/auth_handler.rb | 25 ++- lib/signalwire/core/config_loader.rb | 7 +- lib/signalwire/core/logging_config.rb | 26 ++- lib/signalwire/core/pom_builder.rb | 9 +- lib/signalwire/core/security_config.rb | 6 +- lib/signalwire/logging.rb | 13 +- lib/signalwire/pom/prompt_object_model.rb | 51 ++--- lib/signalwire/pom/section.rb | 45 ++--- lib/signalwire/prefabs/concierge.rb | 36 ++-- lib/signalwire/prefabs/faq_bot.rb | 18 +- lib/signalwire/prefabs/info_gatherer.rb | 15 +- lib/signalwire/prefabs/receptionist.rb | 13 +- lib/signalwire/prefabs/survey.rb | 8 +- lib/signalwire/relay/call.rb | 43 ++--- lib/signalwire/relay/client.rb | 86 ++++----- lib/signalwire/relay/constants.rb | 23 +-- lib/signalwire/relay/message.rb | 6 +- lib/signalwire/rest/http_client.rb | 18 +- lib/signalwire/rest/pagination.rb | 44 ++--- lib/signalwire/rest/request_options.rb | 12 +- lib/signalwire/runtime.rb | 5 +- lib/signalwire/security/security_utils.rb | 17 +- lib/signalwire/security/session_manager.rb | 84 ++++---- lib/signalwire/security/webhook_middleware.rb | 6 +- lib/signalwire/server/agent_server.rb | 24 ++- .../skills/builtin/claude_skills.rb | 28 +-- lib/signalwire/skills/builtin/mcp_gateway.rb | 17 +- .../skills/builtin/native_vector_search.rb | 7 +- lib/signalwire/skills/builtin/spider.rb | 12 +- .../skills/builtin/swml_transfer.rb | 2 +- lib/signalwire/skills/builtin/web_search.rb | 31 ++- .../skills/builtin/wikipedia_search.rb | 4 +- lib/signalwire/skills/skill_base.rb | 5 +- lib/signalwire/skills/skill_registry.rb | 50 ++--- lib/signalwire/swaig/function_result.rb | 47 +++-- lib/signalwire/swaig/swaig_function.rb | 8 +- lib/signalwire/swml/schema.rb | 9 +- lib/signalwire/swml/service.rb | 79 +++----- lib/signalwire/swml/swml_builder.rb | 20 +- lib/signalwire/swml/swml_handler.rb | 12 +- lib/signalwire/swml/swml_renderer.rb | 6 +- lib/signalwire/utils/schema_utils.rb | 71 +++---- lib/signalwire/utils/serverless.rb | 6 +- lib/signalwire/utils/url_validator.rb | 19 +- lib/signalwire/web/web_service.rb | 20 +- 62 files changed, 624 insertions(+), 862 deletions(-) diff --git a/README.md b/README.md index 8778d653..318c3d7d 100644 --- a/README.md +++ b/README.md @@ -97,7 +97,7 @@ swaig-test my_agent.rb --simulate-serverless lambda \ - **Call flow control** -- pre-answer, post-answer, and post-AI verb insertion - **Prefab agents** -- ready-to-use archetypes (InfoGatherer, Survey, FAQ, Receptionist, Concierge) - **Multi-agent hosting** -- serve multiple agents on a single server with `AgentServer` -- **Document search** -- vector/keyword search over a remote index via the `native_vector_search` skill (remote HTTP mode; the Ruby port does not ship the offline/embedded backend) +- **Document search** -- vector/keyword search over a remote index via the `native_vector_search` skill (remote HTTP mode; the Ruby SDK does not ship the offline/embedded backend) - **SIP routing** -- route SIP calls to agents based on usernames - **Session state** -- persistent conversation state with global data and post-prompt summaries - **Security** -- auto-generated basic auth, function-specific HMAC tokens, SSL support diff --git a/bin/swaig-test b/bin/swaig-test index f1029508..f7c0a451 100755 --- a/bin/swaig-test +++ b/bin/swaig-test @@ -56,9 +56,9 @@ module SwaigTest # the fall-through HTTP path and think the simulator worked. IMPLEMENTED_SERVERLESS_PLATFORMS = %w[lambda].freeze - # All platforms the porting guide recognises, so the CLI can emit a - # helpful "recognised but not implemented" error rather than - # "unrecognised value" for the in-progress ones. + # Every platform name the CLI accepts, so it can emit a helpful + # "recognised but not implemented" error rather than "unrecognised value" + # for the in-progress ones. RECOGNISED_SERVERLESS_PLATFORMS = %w[lambda cgi gcf google_cloud_function azure azure_function].freeze # Environment variables the simulator touches. Captured so the simulator @@ -93,8 +93,7 @@ module SwaigTest # Builds the env-override hash for a serverless simulation from the CLI's # --env-file (loaded first) and --env flags (merged after, so an explicit - # --env wins over a file entry). Mirrors Python's swaig-test, where - # env_overrides is built from --env-file then updated with --env. + # --env wins over a file entry). module EnvOverrides module_function @@ -116,8 +115,7 @@ module SwaigTest end end - # Parse KEY=VALUE lines from a file (blank lines and #-comments skipped), - # matching Python's load_env_file in cli/simulation/mock_env.py. + # Parse KEY=VALUE lines from a file (blank lines and #-comments skipped). def load_file(path) unless File.exist?(path) warn "Error: environment file not found: #{path}" @@ -191,8 +189,6 @@ module SwaigTest # * setting the mode-detection env vars for the target platform, # * clearing conflicting env vars (notably SWML_PROXY_URL_BASE), # * restoring the original environment on deactivate. - # - # Mirrors signalwire/cli/simulation/mock_env.py's ServerlessSimulator. class ServerlessSimulator LAMBDA_PRESETS = { 'AWS_LAMBDA_FUNCTION_NAME' => 'test-agent-function', @@ -258,8 +254,8 @@ module SwaigTest end def warn_if_proxy_base_survived - # Match Python: warn if SWML_PROXY_URL_BASE somehow survived (e.g. - # an override re-set it). A live warning here is far cheaper than + # Warn if SWML_PROXY_URL_BASE somehow survived the simulation clear + # (e.g. an override re-set it). A live warning here is far cheaper than # silently generating the wrong webhook URLs. return unless ENV['SWML_PROXY_URL_BASE'] && !ENV['SWML_PROXY_URL_BASE'].empty? @@ -812,10 +808,10 @@ module SwaigTest end # --env / --env-file feed the ServerlessSimulator's `overrides:` plumbing - # (env vars applied AFTER the platform preset, before activation). Mirrors - # Python's swaig-test --env/--env-file: --env is repeatable KEY=VALUE pairs, - # --env-file loads KEY=VALUE lines from a file (later sources win). Only - # meaningful with --simulate-serverless (validated in the simulate guard). + # (env vars applied AFTER the platform preset, before activation). --env is + # repeatable KEY=VALUE pairs; --env-file loads KEY=VALUE lines from a file + # (later sources win). Only meaningful with --simulate-serverless + # (validated in the simulate guard). def register_env_options(opts) opts.on('--env KEY=VALUE', 'Override an environment variable for the serverless simulation ' \ @@ -1093,8 +1089,8 @@ module SwaigTest # --parse-only / --dry-run: run the same argument validation as a real # invocation, then report success and exit WITHOUT loading the agent, # touching the filesystem, or hitting the network. On a valid invocation - # print exactly "parse OK" and exit 0; on an invalid one exit 2 (canonical - # bad-args code, matching the Python reference) without printing "parse OK". + # print exactly "parse OK" and exit 0; on an invalid one exit 2 (the + # canonical bad-args code) without printing "parse OK". # The validators exit(1) on a bad invocation, which we re-map to 2 here. def run_parse_only OptionsValidator.new(@options).validate! @@ -1167,8 +1163,8 @@ module SwaigTest elsif @options[:list_tools] render_dispatcher_tools(dispatcher) else - # No sub-action: render the SWML and print it (matches the porting-guide - # "render SWML and exit" default). + # No sub-action: render the SWML and print it — the default behaviour + # when no --list-tools/--exec is given. print_json(dispatcher.dump_swml) end end @@ -1209,8 +1205,8 @@ module SwaigTest end # Run when invoked directly. An OptionParser error (unknown flag, missing value) -# is a usage error: report it cleanly and exit 2 (the canonical bad-args code, -# matching the reference), rather than surfacing a raw stack trace. +# is a usage error: report it cleanly and exit 2 (the canonical bad-args code), +# rather than surfacing a raw stack trace. if __FILE__ == $PROGRAM_NAME begin SwaigTest::CLI.new.run diff --git a/docs/agent_guide.md b/docs/agent_guide.md index d1328c88..04872314 100644 --- a/docs/agent_guide.md +++ b/docs/agent_guide.md @@ -410,7 +410,7 @@ The CLI tool will automatically detect external webhook functions and make HTTP > **Ruby note:** the Python reference SDK can infer a function's JSON Schema from > type hints, the docstring, and `Literal`/`Optional` annotations. Ruby has no -> equivalent type-hint reflection, so the Ruby port does not auto-infer +> equivalent type-hint reflection, so the Ruby SDK does not auto-infer > schemas — you always pass an explicit `parameters:` hash to `define_tool`. > The block always receives `|args, raw_data|`, so there is no special "typed > handler" signature to learn. @@ -542,8 +542,9 @@ The SDK implements an automated security mechanism for SWAIG functions to ensure #### Token-Based Security -Pass `secure: true` to a function to enable token-based security (the Ruby port -defaults `secure:` to `false`, so opt in explicitly per function that needs it): +Token-based security is ON BY DEFAULT: `define_tool` defaults `secure:` to +`true`, so every function requires a valid per-call token unless you explicitly +pass `secure: false` to opt out. ```ruby agent.define_tool( @@ -559,8 +560,11 @@ end When a function is marked as secure: 1. The SDK automatically generates a secure token for each function when rendering the SWML document -2. The token is added to the function's URL as a query parameter: `?token=X2FiY2RlZmcuZ2V0X3RpbWUuMTcxOTMxNDI1...` -3. When the function is called, the token is validated before executing the function +2. The token is added to the function's URL as a query parameter: `?__token=X2FiY2RlZmcuZ2V0X3RpbWUuMTcxOTMxNDI1...` +3. When the function is called, the token is validated before executing the + function. A missing, expired, or forged token REFUSES the call: the function + does not run, and the SDK returns a normal 200 whose body explains that the + action could not be executed. These security tokens have important properties: - **Completely stateless**: The system doesn't need to store tokens or track sessions @@ -581,7 +585,7 @@ The token system secures both SWAIG functions and post-prompt endpoints: - Post-prompt requests for receiving conversation summaries You can leave token security off for functions that expose only public data -(this is the default in the Ruby port): +(this is the default in the Ruby SDK): ```ruby agent.define_tool( @@ -796,7 +800,7 @@ agent.add_skill('datasphere', { #### Native Vector Search Skill (`native_vector_search`) Provides document search via a remote search server using vector similarity and -keyword search. The Ruby port implements **remote (network) mode only**: it POSTs +keyword search. The Ruby SDK implements **remote (network) mode only**: it POSTs queries to a search server over HTTP using the Ruby standard library (`net/http`). The Python reference's local/offline `.swsearch` index mode and the `sw-search` index-building CLI are not part of the Ruby gem. @@ -2215,7 +2219,7 @@ Prefab agents are pre-configured agent implementations designed for specific use The SDK includes several built-in prefab agents. > **Ruby note:** in the Python reference SDK each prefab *is* an `AgentBase` -> subclass you serve directly. The Ruby port models prefabs as configuration +> subclass you serve directly. The Ruby SDK models prefabs as configuration > helpers under `SignalWire::Prefabs::` — you construct the prefab, then apply > its `prompt_sections`, `global_data`, and tool handlers to a plain > `SignalWire::AgentBase`. The constructor keywords also differ from Python @@ -2633,7 +2637,7 @@ my-prefab-agents/ - Readers: `agent.prompt`, `agent.post_prompt`, `agent.prompt_text` > The Python `setPersonality` / `setGoal` / `setInstructions` camelCase -> convenience methods are not part of the Ruby port — call `prompt_add_section` +> convenience methods are not part of the Ruby SDK — call `prompt_add_section` > with the relevant title directly. ### SWAIG Methods @@ -2645,7 +2649,7 @@ my-prefab-agents/ - Predicate/readers: `agent.function?(name)`, `agent.get_function(name)`, `agent.all_functions`, `agent.list_tool_names` > The Python `add_native_function` / `remove_native_function` helpers are not in -> the Ruby port — assign the full list via `set_native_functions` / +> the Ruby SDK — assign the full list via `set_native_functions` / > `agent.native_functions =`. ### Configuration Methods @@ -2662,7 +2666,7 @@ my-prefab-agents/ Per-call state is managed internally by the agent's `SessionManager` (used for SWAIG token minting/validation). The Python `get_state` / `set_state` / `update_state` / `clear_state` / `cleanup_expired_state` helpers are not exposed -as public `AgentBase` methods in the Ruby port; persist your own session data in +as public `AgentBase` methods in the Ruby SDK; persist your own session data in a captured Hash or external store (see [Session Lifecycle Hooks](#session-lifecycle-hooks)). ### SIP Routing Methods @@ -2670,8 +2674,8 @@ a captured Hash or external store (see [Session Lifecycle Hooks](#session-lifecy - `enable_sip_routing(auto_map: true, path: '/sip')`: Enable SIP routing for an agent - `register_sip_username(username)`: Register a SIP username for an agent -> The Python `auto_map_sip_usernames()` helper is not separately exposed in the -> Ruby port — auto-mapping happens via `enable_sip_routing(auto_map: true)`. +> There is no separate `auto_map_sip_usernames()` helper — auto-mapping happens +> via `enable_sip_routing(auto_map: true)`. #### AgentServer SIP Methods @@ -2711,7 +2715,7 @@ the AWS Lambda handler adapter, and **in-process file mode** (`--file PATH --list-tools`). The actions are `--dump-swml`, `--list-tools`, and `--exec NAME` (with repeatable `--param KEY=VALUE`). -> **Ruby note:** the Ruby port implements only the flags listed above (plus +> **Ruby note:** the Ruby SDK implements only the flags listed above (plus > `--env` / `--env-file` for the Lambda simulation, `--raw`, and `--verbose`). > The larger Python `swaig-test` surface — multi-agent selection > (`--list-agents` / `--agent-class` / `--route`), CGI / Cloud Functions / Azure diff --git a/docs/api_reference.md b/docs/api_reference.md index 3a12126d..6acbdbad 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -724,7 +724,7 @@ Add a modular skill to the agent. - `math`: Mathematical calculations - `web_search`: Google Custom Search integration - `datasphere`: SignalWire DataSphere search -- `native_vector_search`: Document search over a remote search server (the Ruby port does not ship the offline/embedded backend) +- `native_vector_search`: Document search over a remote search server (the Ruby SDK does not ship the offline/embedded backend) **Usage:** ```ruby @@ -3045,7 +3045,7 @@ agent.add_skill("datasphere", { #### `native_vector_search` Skill Document search against a remote search server using vector similarity and keyword -search. The Ruby port supports **remote (network) mode only** -- it POSTs queries to +search. The Ruby SDK supports **remote (network) mode only** -- it POSTs queries to the server at `remote_url`. Local `.swsearch` index files are not supported. **Parameters:** @@ -3139,7 +3139,7 @@ Built-in skills are automatically discovered from the `lib/signalwire/skills/bui ### SWAIG Functions -The Ruby port does not ship a dedicated `SWAIGFunction` wrapper class (see +The Ruby SDK does not ship a dedicated `SWAIGFunction` wrapper class (see [PORT_OMISSIONS.md](../PORT_OMISSIONS.md)); SWAIG functions are registered as plain Hashes directly with the agent. Use `AgentBase#define_tool` for the conventional case, or `AgentBase#register_swaig_function` for manual hashes: diff --git a/docs/cli_guide.md b/docs/cli_guide.md index bc9ccc34..2c246cea 100644 --- a/docs/cli_guide.md +++ b/docs/cli_guide.md @@ -9,8 +9,8 @@ publicly reachable server. > `swaig-test` actually implements. The Python reference SDK ships a much larger > `swaig-test` surface (agent discovery, per-function argument flags, mock-request > injection, data overrides, and CGI / Cloud Functions / Azure serverless -> simulation). Those are **not** implemented in the Ruby port. See -> [Not implemented in the Ruby port](#not-implemented-in-the-ruby-port) at the +> simulation). Those are **not** implemented in the Ruby SDK. See +> [Not implemented in the Ruby SDK](#not-implemented-in-the-ruby-sdk) at the > end of this guide for the full list and follow-up status. Run > `swaig-test --help` to see the authoritative flag set for your installed > version. @@ -130,8 +130,8 @@ up this way. > **Only `lambda` is supported.** Passing `cgi`, `cloud_function`, > `azure_function`, etc. is rejected with a clear "not implemented in this SDK -> yet" error — the Ruby port has only shipped the Lambda handler adapter -> (Phase 9). See [Not implemented in the Ruby port](#not-implemented-in-the-ruby-port). +> yet" error — the Ruby SDK has only shipped the Lambda handler adapter +> (Phase 9). See [Not implemented in the Ruby SDK](#not-implemented-in-the-ruby-sdk). ### List an agent's tools under Lambda simulation @@ -296,16 +296,16 @@ swaig-test examples/lambda_agent.rb --simulate-serverless lambda --dump-swml --r ## Building search indexes -The Ruby port does **not** ship a search-index-building CLI (Python's +The Ruby SDK does **not** ship a search-index-building CLI (Python's `sw-search`). Document search is provided by the `native_vector_search` skill in **remote mode only** — it queries a remote search server over HTTP; it does not build a local index. See the [Skills System Guide](skills_system.md#native-vector-search-native_vector_search). -## Not implemented in the Ruby port +## Not implemented in the Ruby SDK The Python reference `swaig-test` documents a substantially larger CLI. The -following are **not** implemented in the Ruby port and are intentionally absent +following are **not** implemented in the Ruby SDK and are intentionally absent from the flag set above. They are listed here so you don't reach for a Python recipe that won't parse — and as a follow-up feature backlog. diff --git a/docs/cloud_functions_guide.md b/docs/cloud_functions_guide.md index a4440991..d6e3b953 100644 --- a/docs/cloud_functions_guide.md +++ b/docs/cloud_functions_guide.md @@ -6,7 +6,7 @@ require 'signalwire' ``` This guide covers deploying SignalWire AI Agents for Ruby to serverless -platforms. The Ruby port ships a first-class adapter for AWS Lambda via +platforms. The Ruby SDK ships a first-class adapter for AWS Lambda via `SignalWire::Serverless::LambdaHandler`; deployment to Google Cloud Functions and Azure Functions is not officially supported (see [PORT_OMISSIONS.md](../PORT_OMISSIONS.md)). @@ -101,7 +101,7 @@ https://username:password@{url-id}.lambda-url.{region}.on.aws/ ## Google Cloud Functions / Azure Functions -Google Cloud Functions and Azure Functions are not supported by the Ruby port. +Google Cloud Functions and Azure Functions are not supported by the Ruby SDK. The Python SDK ships per-platform detection mixins (`signalwire.core.mixins.serverless_mixin.ServerlessMixin`) that have not been ported. If you need to run a SignalWire agent on these platforms, options are: @@ -136,7 +136,7 @@ agent = SignalWire::AgentBase.new( ## Testing -The Ruby port does not ship a CLI analogue to Python's `swaig-test`. Tests +The Ruby SDK does not ship a CLI analogue to Python's `swaig-test`. Tests target the agent's Rack app directly with `Rack::Test` or with raw HTTP requests: diff --git a/docs/configuration.md b/docs/configuration.md index 071efbab..7cffac1a 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -19,7 +19,7 @@ agent.run ### With Environment-Driven Configuration ```ruby -# The Ruby port is configured from environment variables (no ConfigLoader). +# The Ruby SDK is configured from environment variables (no ConfigLoader). # Set the relevant SWML_* vars, then instantiate as usual. ENV['SWML_SSL_ENABLED'] = 'true' ENV['SWML_SSL_CERT_PATH'] = '/etc/ssl/cert.pem' @@ -266,7 +266,7 @@ After (Option 3 - Mix config and env vars): ## Programmatic Usage -The Ruby port does not ship a dedicated `ConfigLoader` class; configuration is +The Ruby SDK does not ship a dedicated `ConfigLoader` class; configuration is driven entirely from environment variables (see [PORT_OMISSIONS.md](../PORT_OMISSIONS.md)). Set the relevant `SWML_*` and agent-specific environment variables before instantiating your agent: diff --git a/docs/sdk_features.md b/docs/sdk_features.md index c275a6da..3195913c 100644 --- a/docs/sdk_features.md +++ b/docs/sdk_features.md @@ -275,14 +275,14 @@ That single call auto-detects the environment and does the right thing: Each mode handles authentication differently (HTTP Basic Auth, API Gateway authorizers, function-level auth), constructs webhook URLs using the correct public endpoint, and formats request/response bodies per platform. You write one agent, deploy it anywhere. -In the Ruby port, `agent.run` ships dedicated request/response handling for **Lambda** and **CGI**; Google Cloud Functions and Azure Functions are recognised by the runtime detector but currently fall through to the standard HTTP server rather than emitting a platform-native response shape. (The Python reference additionally returns Flask-compatible and Azure `HttpResponse` objects for those two platforms.) +In the Ruby SDK, `agent.run` ships dedicated request/response handling for **Lambda** and **CGI**; Google Cloud Functions and Azure Functions are recognised by the runtime detector but currently fall through to the standard HTTP server rather than emitting a platform-native response shape. (The Python reference additionally returns Flask-compatible and Azure `HttpResponse` objects for those two platforms.) For standalone mode, the SDK provides: - Kubernetes health (`/health`) and readiness (`/ready`) probes - SSL/TLS support via the `serve(ssl_enabled:, ssl_cert:, ssl_key:)` keyword arguments - Debug events endpoint (`/debug_events`) for inspection -(SSL can also be configured through the `SWML_SSL_ENABLED`, `SWML_SSL_CERT_PATH`, and `SWML_SSL_KEY_PATH` env vars, which `serve` reads when the matching keyword arguments are not passed. The Python reference additionally exposes a CORS configuration option the Ruby port does not.) +(SSL can also be configured through the `SWML_SSL_ENABLED`, `SWML_SSL_CERT_PATH`, and `SWML_SSL_KEY_PATH` env vars, which `serve` reads when the matching keyword arguments are not passed. The Python reference additionally exposes a CORS configuration option the Ruby SDK does not.) --- @@ -326,7 +326,7 @@ Each inbound request creates an **ephemeral copy** of the agent. The callback cu ## Search -The Ruby port provides document search through the `native_vector_search` skill in +The Ruby SDK provides document search through the `native_vector_search` skill in **remote (network) mode only**. The skill POSTs queries to a remote search server over HTTP (using `net/http` from the standard library) and formats the returned results for the agent. The Python reference's local/offline `.swsearch` index mode, @@ -369,7 +369,7 @@ receptionist = SignalWire::Prefabs::Receptionist.new(departments: [ ]) ``` -In the Ruby port a prefab is a helper object rather than an `AgentBase` subclass: it produces the prompt sections, global data, and tool handlers that you wire into a plain `SignalWire::AgentBase.new(...)` for serving (the `examples/info_gatherer_example.rb` and `examples/receptionist_agent_example.rb` files show the full wiring). +In the Ruby SDK a prefab is a helper object rather than an `AgentBase` subclass: it produces the prompt sections, global data, and tool handlers that you wire into a plain `SignalWire::AgentBase.new(...)` for serving (the `examples/info_gatherer_example.rb` and `examples/receptionist_agent_example.rb` files show the full wiring). Five prefabs: **InfoGatherer**, **Survey**, **Receptionist**, **FaqBot**, **Concierge**. Each generates complete SWML with appropriate prompts, tools, and workflows. You instantiate, customize, deploy. diff --git a/docs/skills_system.md b/docs/skills_system.md index 00323ecf..ae80ccbc 100644 --- a/docs/skills_system.md +++ b/docs/skills_system.md @@ -111,7 +111,7 @@ Perform mathematical calculations. ### Native Vector Search (`native_vector_search`) Search document indexes via a remote search server using vector similarity and -keyword search. The Ruby port implements **remote (network) mode only**: it POSTs +keyword search. The Ruby SDK implements **remote (network) mode only**: it POSTs queries to a search server over HTTP using the Ruby standard library (`net/http`). The Python reference's local/offline `.swsearch` index mode and the `sw-search` index-building CLI are not part of the Ruby gem. @@ -134,7 +134,7 @@ index-building CLI are not part of the Ruby gem. **Usage examples:** ```ruby -# Remote mode (the only supported mode in the Ruby port) +# Remote mode (the only supported mode in the Ruby SDK) agent.add_skill('native_vector_search', { 'remote_url' => 'http://localhost:8001', 'index_name' => 'knowledge' diff --git a/docs/swml_service_guide.md b/docs/swml_service_guide.md index 23619c4d..e7492f3c 100644 --- a/docs/swml_service_guide.md +++ b/docs/swml_service_guide.md @@ -189,7 +189,7 @@ document.add_verb("play", { "invalid_param" => "value" }) ### Custom Verb Handlers -In the Ruby port, verb validation is handled uniformly by +In the Ruby SDK, verb validation is handled uniformly by `SignalWire::SWML::Schema`. Per-verb custom handlers are not exposed — if you need custom behavior for a specific verb, subclass `SignalWire::SWML::Service` and override `execute_verb` (or call `add_verb`/`add_verb_to_section` directly diff --git a/lib/signalwire.rb b/lib/signalwire.rb index 8e16a5f5..0380ac03 100644 --- a/lib/signalwire.rb +++ b/lib/signalwire.rb @@ -31,8 +31,7 @@ require_relative 'signalwire/skills/skill_manager' require_relative 'signalwire/skills/skill_registry' require_relative 'signalwire/agent/agent_base' -# AgentServer is top-level public API (Python: ``from signalwire import -# AgentServer``); expose it via ``require 'signalwire'``. +# AgentServer is top-level public API; expose it via ``require 'signalwire'``. require_relative 'signalwire/server/agent_server' require_relative 'signalwire/core/agent/prompt/manager' require_relative 'signalwire/core/agent/tools/registry' @@ -40,16 +39,16 @@ require_relative 'signalwire/agents/bedrock' require_relative 'signalwire/serverless/lambda_handler' -# Generated read-side typed payloads (SESSION_CHANGESET item D): the SWML-verbs -# config types (core.swml_verbs_generated), the RELAY protocol types +# Generated read-side typed payloads: the SWML-verbs config types +# (core.swml_verbs_generated), the RELAY protocol types # (relay.protocol_types_generated), and the SWAIG payloads (core.post_prompt_ # generated / swaig_request_generated / swaig_actions_generated). Method-less -# data classes carrying the wire shape; each generated by its scripts/generate_*.py. +# data classes carrying the wire shape; each emitted by a generator script. require_relative 'signalwire/generated_payloads' module SignalWire - # Top-level convenience entry points — mirror Python's - # ``signalwire/__init__.py`` factory + skill registry helpers. + # Top-level convenience entry points — the client factory and the skill + # registry helpers. module_function @@ -78,8 +77,7 @@ def RestClient(*args, **kwargs) # Register a custom skill class with the global skill registry. # - # Mirrors Python's ``signalwire.register_skill(skill_class)`` — the - # Ruby singleton registry stores factories by name. The class is + # The singleton registry stores factories by name. The class is # expected to expose a ``::skill_name`` (or ``SKILL_NAME`` constant) # so we can derive the registration key. # @@ -100,8 +98,7 @@ def register_skill(skill_class) # Add a directory to search for skills. # - # Mirrors Python's ``signalwire.add_skill_directory(path)`` — delegates - # to the singleton {SignalWire::Skills::SkillRegistry} instance so + # Delegates to the singleton {SignalWire::Skills::SkillRegistry} instance so # third-party skill collections can be registered by path. Subsequent # calls accumulate (de-duplicated) into a shared external paths list. # @@ -115,7 +112,7 @@ def add_skill_directory(path) # List all available skills. # - # Mirrors Python's top-level ``signalwire.list_skills()``. Delegates to + # Delegates to # {SignalWire::Skills::SkillRegistry#list_skills} on the shared # singleton registry, returning one hash per skill (``name`` plus # ``description`` / ``version`` when the factory can be instantiated @@ -129,7 +126,7 @@ def list_skills # Get complete schema for all available skills, including parameter metadata. # - # Mirrors Python's ``signalwire.list_skills_with_params()``. Keys are + # Keys are # skill names; values describe metadata + parameter schema. Useful for # GUI configuration tools, API documentation, or programmatic skill # discovery. diff --git a/lib/signalwire/agent/agent_base.rb b/lib/signalwire/agent/agent_base.rb index 2fe8b639..76eef758 100644 --- a/lib/signalwire/agent/agent_base.rb +++ b/lib/signalwire/agent/agent_base.rb @@ -257,8 +257,8 @@ def init_verb_and_context_state @context_builder = nil - # Python parity: SkillManager(agent) keeps a back-pointer so loaded - # skills can attach SWAIG tools and prompt sections via the manager. + # SkillManager(agent) keeps a back-pointer so loaded skills can attach + # SWAIG tools and prompt sections via the manager. @skill_manager = Skills::SkillManager.new(self) @loaded_skills = {} # skill_name => SkillBase end @@ -365,12 +365,12 @@ def prompt_add_section(title, body = '', bullets: nil, end # @api private — build one POM section hash from the {#prompt_add_section} - # arguments. `body` is omitted when nil or empty (Ruby's `''` is truthy where - # the reference's is falsy, so a bare truth test would emit `"body": ""`); - # the flags are emitted only when true. + # arguments. `body` is omitted when nil or empty — Ruby's `''` is TRUTHY, so + # a bare truth test here would wrongly emit `"body": ""`. The flags are + # emitted only when true. def build_section(title, body, **opts) section = { 'title' => title } - # See prompt_add_subsection: `''` is truthy in Ruby, falsy in python. + # See prompt_add_subsection: `''` is TRUTHY in Ruby, so guard on empty. section['body'] = body unless body.nil? || body.empty? section['bullets'] = opts[:bullets] if opts[:bullets] section['numbered'] = true if opts[:numbered] @@ -410,7 +410,7 @@ def build_subsection(sub) # **Backwards compat:** the original Ruby signature was # ``prompt_add_to_section(title, text)``. When called with two # positional arguments the second becomes ``body``; this preserves - # existing call sites while still supporting Python's keyword form. + # existing call sites while still supporting the keyword form. def prompt_add_to_section(title, body_arg = nil, body: nil, bullet: nil, bullets: nil) effective_body = body || body_arg sec = find_or_create_section(title) @@ -446,10 +446,9 @@ def prompt_add_subsection(parent_title, title, body = '', bullets: nil) parent = find_or_create_section(parent_title) parent['subsections'] ||= [] sub = { 'title' => title } - # An EMPTY body is omitted, not emitted as "". Ruby's `''` is truthy where - # python's is falsy, so a bare `if body` would emit `"body": ""` for the - # default where the reference (`if self.body:` in pom.Section.to_dict) - # omits the key entirely. + # An EMPTY body is omitted, not emitted as "". Ruby's `''` is TRUTHY, so a + # bare `if body` would emit `"body": ""` for the default instead of + # omitting the key entirely. sub['body'] = body unless body.nil? || body.empty? sub['bullets'] = bullets if bullets parent['subsections'] << sub @@ -536,11 +535,9 @@ def get_raw_prompt # ================================================================== # Idiomatic Ruby accessors (PROTOTYPE — see RUBY_ERGONOMICS_MIGRATION.md) # ================================================================== - # Additive aliases layered over the Python-named originals above. The - # `get_`/`set_` methods stay (the cross-port audit matches them 1:1); - # these give Ruby callers the native shape: `agent.post_prompt = "..."` - # and `agent.prompt`. Every alias is recorded in PORT_ADDITIONS.md as a - # port-only symbol. This block prototypes the pattern on the prompt + # Additive aliases layered over the `get_`/`set_` originals above, which + # stay; these give Ruby callers the native shape: `agent.post_prompt = + # "..."` and `agent.prompt`. This block prototypes the pattern on the prompt # accessors only; the full rollout is described in the migration doc. # Reader: the effective prompt (string in text mode, POM array otherwise). @@ -775,7 +772,7 @@ def get_contexts # @param handler [Proc, nil] explicit handler (alternative to a # block); kept for backward compat # @param secure [Boolean] require token validation. Defaults to - # ``true`` (fleet-wide, matching Python): a tool defined without an + # ``true``: a tool defined without an # explicit ``secure:`` requires SWAIG token validation. Pass # ``secure: false`` to opt a tool out. # @param fillers [Hash, nil] language-keyed filler phrases @@ -793,8 +790,7 @@ def get_contexts # @yield [args, raw_data] tool handler body (takes precedence over an # explicit ``handler:``, which must still be supplied — pass ``nil``) # - # ``parameters:`` and ``handler:`` are REQUIRED, matching the reference - # (``define_tool(name, description, parameters, handler, ...)``). They + # ``parameters:`` and ``handler:`` are REQUIRED. They # previously defaulted to ``{}`` / ``nil``, so a call that named no # parameters and registered no handler was silently accepted here while every # other port rejected it. A tool with no parameters states ``parameters: {}`` @@ -957,7 +953,7 @@ def swaig_pre_dispatch(request_data, func_name, env) end # @api private — the `__token` credential from a Rack env's query string. - # `token` is accepted as a legacy alias, matching the reference. + # `token` is accepted as a legacy alias. def swaig_request_token(env) qs = env.is_a?(Hash) ? (env['QUERY_STRING'] || '') : '' params = URI.decode_www_form(qs).to_h @@ -978,7 +974,7 @@ def swaig_call_id(request_data) # Coerce a handler return into a wire Hash: Hash passes through, a # FunctionResult-like object is to_h'd, anything else is wrapped (with a - # warning) — matching Python's web/serverless/tool mixin behaviour. + # warning). def coerce_function_result(name, result) return result if result.is_a?(Hash) return result.to_h if !result.nil? && result.respond_to?(:to_h) @@ -1024,13 +1020,11 @@ def add_hints(hints) # Add a complex (pattern-matched) hint. # - # ``hint``, ``pattern`` and ``replace`` are REQUIRED, matching the reference - # (``add_pattern_hint(hint, pattern, replace, ignore_case=False)``). The - # legacy ``add_pattern_hint(pattern, hint:, language:)`` overload was removed: - # it had no reference counterpart AND emitted a different wire shape + # ``hint``, ``pattern`` and ``replace`` are REQUIRED (``ignore_case`` + # defaults to false). The legacy ``add_pattern_hint(pattern, hint:, + # language:)`` overload was removed: it emitted a different wire shape # (``{pattern, hint, language}`` instead of - # ``{hint, pattern, replace, ignore_case}``), so it was port-invented surface - # rather than an idiomatic spelling of the reference call. + # ``{hint, pattern, replace, ignore_case}``). # # @param hint [String] hint to match # @param pattern [String] regex pattern @@ -1044,12 +1038,10 @@ def add_pattern_hint(hint, pattern, replace, ignore_case: false) # Add a language configuration. # - # ``name``, ``code`` and ``voice`` are REQUIRED, matching the reference - # (``add_language(name, code, voice, ...)``). The preformed-hash shapes this - # method used to also accept (``add_language(config_hash)`` and the braceless - # ``add_language('name' => …, 'code' => …)``) had no reference counterpart — - # the reference spells that capability #set_languages, which takes the list of - # config hashes — so they were removed rather than kept as port-only surface. + # ``name``, ``code`` and ``voice`` are all REQUIRED. The preformed-hash + # shapes this method used to also accept (``add_language(config_hash)`` and + # the braceless ``add_language('name' => …, 'code' => …)``) were removed: + # use #set_languages, which takes a list of config hashes, for that. # # Voice argument can be either a simple voice id (``"en-US-Neural2-F"``) # or a combined ``"engine.voice:model"`` string @@ -1376,7 +1368,7 @@ def set_function_includes(includes) end # An include is valid when it is a Hash carrying a truthy +url+ and a - # +functions+ array (mirrors TS setFunctionIncludes' per-entry filter). + # +functions+ array; anything else is dropped. def valid_function_include?(inc) inc.is_a?(Hash) && inc['url'] && inc['functions'].is_a?(Array) end @@ -1496,11 +1488,9 @@ def clear_post_ai_verbs # @param contexts [SignalWire::Contexts::ContextBuilder, Hash, nil] # optional override # @return [SignalWire::Contexts::ContextBuilder] the active builder - # ``contexts`` is OPTIONAL here, matching the reference's AgentBase-facing - # ``PromptMixin.define_contexts(contexts=None)`` — the no-argument call is the - # documented "get or create the builder" shape. The reference's OTHER - # ``define_contexts``, on PromptManager, does require it; Ruby's - # PromptManager#define_contexts matches that separately. + # ``contexts`` is OPTIONAL here — the no-argument call is the documented + # "get or create the builder" shape. PromptManager#define_contexts is a + # separate method that DOES require its argument. def define_contexts(contexts = nil) return (@context_builder = attach_context_builder(contexts)) if contexts.is_a?(Contexts::ContextBuilder) return (@context_builder = build_context_builder_from_hash(contexts)) if contexts.is_a?(Hash) @@ -1574,9 +1564,9 @@ def add_skill(skill_name, params = nil) factory = Skills::SkillRegistry.get_factory(skill_name) raise ArgumentError, "Unknown skill: '#{skill_name}'" unless factory - # The default is `nil` to match the reference (`params: dict | None = None`), - # but every registered factory is a block that INDEXES the params hash, so - # the nil is normalised here rather than pushed onto each factory. + # The default is `nil`, but every registered factory is a block that + # INDEXES the params hash, so the nil is normalised here rather than + # pushed onto each factory. skill = factory.call(params || {}) @skill_manager.load(skill.instance_key, skill) @loaded_skills[skill_name] = skill @@ -1667,9 +1657,8 @@ def has_skill?(skill_name) # Web / HTTP configuration # ================================================================== - # The callback is REQUIRED, matching the reference - # (``set_dynamic_config_callback(self, callback)``); the block is the - # idiomatic spelling of the same slot and passing neither raises. + # The callback is REQUIRED; the block form is the idiomatic spelling of the + # same slot, and passing neither raises. def set_dynamic_config_callback(callable, &block) callback = callable || block raise ArgumentError, 'set_dynamic_config_callback requires a callback (block or callable)' if callback.nil? @@ -1690,33 +1679,26 @@ def manual_set_proxy_url(url) end # ------------------------------------------------------------------ - # Web / routing surface (Python WebMixin parity — item I). Several of - # these delegate to the inherited SWMLService implementation; explicit - # overrides make them part of AgentBase's own public surface (Python - # composes them via mixins, so the reference records them on AgentBase). + # Web / routing surface. Several of these delegate to the inherited + # SWMLService implementation; the explicit overrides make them part of + # AgentBase's own public surface. # ------------------------------------------------------------------ # The Rack application for this agent (deployment adapters mount this). - # Mirrors Python WebMixin.get_app (which returns the FastAPI app). def get_app rack_app end - # A Rack-mountable router/app for this agent. Mirrors WebMixin.as_router - # (Python returns a FastAPI APIRouter; Ruby returns the Rack app). + # A Rack-mountable router/app for this agent — the Rack app itself. def as_router rack_app end # NOTE: register_routing_callback / on_request / on_swml_request / - # validate_basic_auth are inherited from SWMLService. The reference records - # them on WebMixin/AuthMixin (which Python's AgentBase composes); the Ruby - # surface enumerator projects them onto those mixins from the base - # SWML::Service via SURFACE_METHOD_DONORS, so no useless super-only - # override is defined here. + # validate_basic_auth are inherited from SWMLService unchanged, so no + # super-only override is defined here. # Install SIGTERM/SIGINT handlers for graceful shutdown (Kubernetes). - # Mirrors WebMixin.setup_graceful_shutdown. def setup_graceful_shutdown %w[TERM INT].each do |sig| Signal.trap(sig) do @@ -1730,16 +1712,16 @@ def setup_graceful_shutdown self end - # Handle a serverless-environment request (CGI / Lambda / Cloud Functions). - # Mirrors ServerlessMixin.handle_serverless_request — routes to the normal - # run() entry point with the serverless event/context/mode. + # Handle a serverless-environment request (CGI / Lambda / Cloud Functions) + # by routing to the normal run() entry point with the serverless + # event/context/mode. def handle_serverless_request(event: nil, context: nil, mode: nil) run(event: event, context: context, force_mode: mode) end # Configure ASR-driven multilingual mode (Mode B). Emits a top-level - # ``multilingual`` object on the AI verb. Mirrors - # AIConfigMixin.set_multilingual — mutually exclusive with set_languages. + # ``multilingual`` object on the AI verb. Mutually exclusive with + # set_languages. def set_multilingual(config) @multilingual_config = config self @@ -1803,13 +1785,13 @@ def enable_sip_routing(auto_map: true, path: '/sip') @sip_auto_map = auto_map @sip_path = path - # Python parity (AgentBase.enable_sip_routing): register a routing - # callback at +path+ so the served +/sip+ endpoint actually CONSULTS the + # Register a routing callback at +path+ so the served +/sip+ endpoint + # actually CONSULTS the # SIP mapping. Previously the mapping was stored but never wired into # dispatch (a stored-but-unconsulted mapping). The callback extracts the # SIP username from the request body and returns nil (matched → this agent # handles the call so dispatch renders SWML; unmatched → routing - # continues) — exactly Python's sip_routing_callback. + # continues). register_routing_callback(nil, path) { |body, _headers| sip_routing_callback(body) } auto_map_sip_usernames if auto_map @@ -2090,10 +2072,8 @@ def mcp_error(req_id, code, message) # ``on_summary(summary, raw_data = nil)``. Default implementation # calls the registered block (if any) and otherwise no-ops. # - # ``summary`` is REQUIRED, matching the reference - # (``on_summary(self, summary: PostPromptData | None, raw_data=None)``): the - # slot is nullABLE, not omittABLE, so a caller states `nil` explicitly rather - # than relying on a port-invented default the other nine ports do not have. + # ``summary`` is REQUIRED: the slot is nullABLE, not omittABLE, so a caller + # states `nil` explicitly rather than relying on a default. # # @param summary [Hash, nil] the post-prompt summary # @param raw_data [Hash, nil] the complete raw POST data @@ -2108,9 +2088,8 @@ def on_summary(summary, raw_data = nil, &block) nil end - # Register the debug-event handler. REQUIRED, matching the reference - # (``on_debug_event(self, handler)``); the block is the idiomatic spelling of - # the same slot and passing neither raises. + # Register the debug-event handler. REQUIRED; the block form is the + # idiomatic spelling of the same slot, and passing neither raises. def on_debug_event(handler, &block) callback = block || handler raise ArgumentError, 'on_debug_event requires a handler (block or callable)' if callback.nil? @@ -2119,9 +2098,7 @@ def on_debug_event(handler, &block) self end - # Universal run method — mirrors Python's - # ``WebMixin.run(event=None, context=None, force_mode=None, - # host=None, port=None)``. + # Universal run method. # # Detects execution mode (server / lambda / cgi) and routes # accordingly. ``force_mode`` overrides auto-detection. @@ -2351,7 +2328,7 @@ def webrick_opts(bind_host, bind_port) Logger: WEBrick::Log.new($stderr, WEBrick::Log::WARN), AccessLog: [] } - # WebMixin parity: serve HTTPS when SSL is configured (via the SWML_SSL_* + # Serve HTTPS when SSL is configured (via the SWML_SSL_* # env vars read in SWMLService#initialize, or a config file). Shares the # helper with SWMLService#serve. No-op when SSL is off → plain HTTP. _apply_webrick_ssl!(opts) @@ -2393,8 +2370,8 @@ def render_swml(request_data = nil, request: nil) # Framework-free request-dispatch core for AgentBase — overrides # {SWMLService#handle_request} so the primitive dispatch surface renders SWML - # via the agent's {#render_swml} (mirroring the Rack +handle_main_request+ - # path) instead of the base +render_document+. Performs proxy detection, + # via the agent's {#render_swml} (the same result the Rack + # +handle_main_request+ path produces) instead of the base +render_document+. Performs proxy detection, # basic-auth, the routing-callback check, and the +on_swml_request+ # modification hook over plain primitives, returning a # +[status, headers, body_string]+ triple with the 401-auth and 307-redirect @@ -2465,7 +2442,7 @@ def apply_dynamic_config(request_data, request) # +call_id+ (optional) is the active call's id. When present, each SECURE # tool's rendered SWAIG webhook carries a per-tool ``__token`` (minted via # the SessionManager) so the platform can validate the callback — the wire - # manifestation of ``secure`` (mirrors python agent_base.py:1040/1096-1100). + # manifestation of ``secure``. def _render_swml_internal(call_id: nil) @render_call_id = call_id { 'version' => '1.0.0', 'sections' => { 'main' => build_main_section } } @@ -2475,10 +2452,9 @@ def _render_swml_internal(call_id: nil) # Assemble the ordered SWML "main" section entries. # - # The reference routes every one of these through the validating - # ``SWMLService.add_verb`` (python core/agent_base.py:1194-1216, 1367-1418). - # This assembly builds the section directly, so each entry is put through - # the same schema validation here — otherwise the caller-supplied configs + # This assembly builds the section directly rather than going through the + # validating ``SWMLService.add_verb``, so each entry is put through the same + # schema validation here — otherwise the caller-supplied configs # of #add_pre_answer_verb / #add_post_answer_verb / #add_post_ai_verb reach # the wire completely unchecked. def build_main_section @@ -2617,7 +2593,7 @@ def add_ai_post_prompt(config) # plus `functions` / `native_functions` / `includes` / `internal_fillers` when # non-empty. The whole key is dropped when there is nothing but the defaults. # `mcp_servers` lives INSIDE this SWAIG object, not at the ai verb's top - # level (reference core/agent_base.py:1150-1153 — `swaig_obj["mcp_servers"]`). + # level. # The ai verb's schema is closed, so a top-level `mcp_servers` is a key the # platform rejects; it only ever shipped because this assembly bypassed the # validating add_verb. @@ -2671,9 +2647,8 @@ def add_ai_params(config) # contexts block degrades to a context-free agent instead of failing the render. # # `contexts` belongs INSIDE the prompt object (`ai.prompt.contexts`), not at - # the ai verb's top level — the reference builds it that way - # (core/swml_handler.py:191 `prompt_config["contexts"]`) and this port's own - # AiVerbHandler#build_prompt_config already agrees. The ai verb's schema is + # the ai verb's top level — AiVerbHandler#build_prompt_config already + # builds it that way. The ai verb's schema is # closed, so a top-level `contexts` is a key the platform rejects; it only # ever shipped because this assembly bypassed the validating add_verb. def add_ai_contexts(config) @@ -2703,7 +2678,7 @@ def tool_function_entry(tool) # A SECURE tool rendered with an active call_id gets a per-tool ``__token`` # appended to its webhook URL (minted via the SessionManager) so the # platform validates the callback — the wire manifestation of ``secure`` - # (mirrors python agent_base.py:1040/1096-1100). Absent a call_id (or for + # credential. Absent a call_id (or for # an insecure tool) it falls back to the query-param webhook, if any. qp = @swaig_query_params.dup if tool[:secure] && @render_call_id && !@render_call_id.to_s.empty? @@ -2730,7 +2705,7 @@ def build_webhook_url(endpoint, query_params = nil) # Compute the base URL for webhook construction. # - # Precedence (matches the Python SDK): + # Precedence: # 1. +SWML_PROXY_URL_BASE+ or a call to +manual_set_proxy_url+ # (an explicit override always wins) # 2. AWS Lambda-derived URL when execution mode is +:lambda+ @@ -3015,8 +2990,7 @@ def invoke_summary_callback(request_data) @logger.error "Post-prompt callback error: #{e.message}" end - # Locate the summary in the post-prompt payload. Mirrors the extraction - # order used by the Python and TS ports: + # Locate the summary in the post-prompt payload, in this order: # 1. top-level "summary" key # 2. post_prompt_data["parsed"][0] (when parsed is a non-empty array) # 3. post_prompt_data["raw"] (JSON-parsed when possible, else raw) @@ -3167,11 +3141,10 @@ def credentials_valid?(input) # @api private — the 401 challenge: a `Basic realm="SignalWire Agent"` # www-authenticate header and a JSON `{"error":"Unauthorized"}` body (not - # plain text), matching the reference's auth challenges. + # plain text). def unauthorized - # Python parity (AuthMixin._send_lambda_auth_challenge / the CGI + server - # challenges): a JSON {"error":"Unauthorized"} body with a JSON - # content-type, not a plain-text "Unauthorized". + # A JSON {"error":"Unauthorized"} body with a JSON content-type, not a + # plain-text "Unauthorized". [ 401, { @@ -3184,8 +3157,8 @@ def unauthorized end # Internal helpers extracted during the lint burndown (Metrics cops) for - # locality, but they are implementation details with no Python-reference - # counterpart. Declared private here at the end of the class — after every + # locality; they are implementation details, not public API. Declared + # private here at the end of the class — after every # one is defined — so they stay off the audited public surface (restoring the # encapsulation the pre-extraction inline code had). Placed last because the # methods span multiple public/private regions above. @@ -3199,10 +3172,9 @@ def unauthorized private :matches_env_auth?, :mcp_input_schema, :mcp_tool_entry, :merge_skill_hints_and_data private :merge_skill_prompt_sections, :optional_tool_fields, :rack_env, :register_no_vowels_variation private :register_skill_tools, :sanitize_sip_username, :section_pom_kwargs - # swaig_pre_dispatch / swaig_validate_token are PRIVATE, mirroring the - # reference's `_swaig_pre_dispatch` / `_swaig_validate_token` (both - # underscore-private). Service invokes the hook with an implicit receiver, so - # private visibility is sufficient and the override adds no public surface. + # swaig_pre_dispatch / swaig_validate_token are internal SWAIG dispatch + # plumbing, not agent-author API. Service invokes the hook with an implicit + # receiver, so private visibility is sufficient. private :swaig_pre_dispatch, :swaig_validate_token, :swaig_request_token, :swaig_call_id private :sym_or_str, :verb_entries, :warn_unexpected_function_result private :warn_unknown_filler_name, :warn_unknown_filler_names, :webrick_opts @@ -3210,8 +3182,7 @@ def unauthorized private :valid_function_include?, :warn_dropped_function_include, :find_summary_in_post_data private :summary_from_post_prompt_data # Formerly leading-underscore-by-convention internals; underscore dropped in - # the idiom pass. Declared private so the cross-port surface enumerator keeps - # excluding them (unchanged public surface). + # the idiom pass. Declared private so they stay off the public surface. private :agent_on_swml_request, :agent_render_triple, :apply_env_headers, :extract_http_request, :extract_path_and_query, :handle_debug_events, :handle_mcp_endpoint, :handle_post_prompt, :mcp_default_response, diff --git a/lib/signalwire/agents/bedrock.rb b/lib/signalwire/agents/bedrock.rb index bef8ec33..eb0b27fd 100644 --- a/lib/signalwire/agents/bedrock.rb +++ b/lib/signalwire/agents/bedrock.rb @@ -21,9 +21,8 @@ module SignalWire module Agents # Agent implementation for the Amazon Bedrock voice-to-voice model. # - # Mirrors Python's ``signalwire.agents.bedrock.BedrockAgent`` and the - # PHP ``SignalWire\Agents\BedrockAgent``. It renders the same base - # SWML as {SignalWire::AgentBase} and then transforms the ``ai`` verb + # It renders the same base SWML as {SignalWire::AgentBase} and then + # transforms the ``ai`` verb # into an ``amazon_bedrock`` verb whose object carries voice and # inference parameters inside its prompt config, per the SWML # ``amazon_bedrock`` schema (keys: ``prompt``, ``SWAIG``, ``params``, @@ -166,8 +165,7 @@ def inspect # Build the amazon_bedrock verb object from the base ``ai`` config. # Voice + inference params live inside the prompt config; only - # non-nil keys are emitted (matches the Python reference and the - # amazon_bedrock schema). + # non-nil keys are emitted, per the amazon_bedrock schema. def build_bedrock_object(ai_config) object = { 'prompt' => add_voice_to_prompt(ai_config['prompt'] || {}), diff --git a/lib/signalwire/ai_chat/client.rb b/lib/signalwire/ai_chat/client.rb index 699f9655..5162720f 100644 --- a/lib/signalwire/ai_chat/client.rb +++ b/lib/signalwire/ai_chat/client.rb @@ -27,12 +27,9 @@ module SignalWire # A +chat+ call awaits a full LLM round trip (seconds, not milliseconds). The # service streams keepalive whitespace ahead of a slow response body (proxy # read-timeout protection), so liveness is byte-driven rather than wall-clock: - # there is no total-request timeout an idle turn could trip — only a per-read - # idle timeout, mirroring the python reference's - # +aiohttp.ClientTimeout(total=None, connect=10, sock_read=60)+. Leading - # whitespace is valid JSON, so the buffered +JSON.parse+ is unaffected. - # - # Mirrors the python reference +signalwire.ai_chat.AIChatClient+. + # there is no total-request timeout an idle turn could trip — only a bounded + # connect timeout and a per-read idle timeout. Leading whitespace is valid + # JSON, so the buffered +JSON.parse+ is unaffected. # # require 'signalwire/ai_chat' # @@ -44,14 +41,13 @@ module AIChat # Default endpoint path appended to a +space+-derived base URL. DEFAULT_PATH = '/api/ai/chat' - # Connect timeout (seconds) — a bounded TCP/TLS handshake. Mirrors the python - # reference's +connect=10+. + # Connect timeout (seconds) — a bounded TCP/TLS handshake. DEFAULT_CONNECT_TIMEOUT_SECONDS = 10 # Idle read timeout (seconds) for a single request. The service streams # keepalive whitespace roughly every 10s, so this bounds true byte-silence (a - # dead connection), NOT total turn length — mirroring the python reference's - # +sock_read=60+. Net::HTTP's +read_timeout+ is per-read (it resets on each + # dead connection), NOT total turn length. Net::HTTP's +read_timeout+ is + # per-read (it resets on each # received chunk), so the streaming proxy's heartbeat keeps a live-but-slow # turn alive while a truly dead connection is severed after this many seconds # of silence. A total wall-clock cap is deliberately absent — a slow-but-live @@ -196,11 +192,10 @@ def self.resolve_url(url, space) 'or provide space: / SIGNALWIRE_SPACE.' end - # Release any client-held resources. The reference closes its persistent - # aiohttp session here; Ruby's AIChatClient opens a fresh Net::HTTP + # Release any client-held resources. AIChatClient opens a fresh Net::HTTP # connection per request and owns no long-lived session, so there is nothing # to release — this is a well-defined no-op that completes the lifecycle - # contract (mirrors the reference #close). Safe to call any number of times. + # contract. Safe to call any number of times. def close; end # ── API methods ────────────────────────────────────────────────── @@ -310,7 +305,7 @@ def optional(pairs) # Success/failure is decided by the JSON-RPC BODY, not the HTTP status: the # service's keepalive heartbeat commits +200+ before the turn's outcome is # known, so a slow error can arrive as +200 + {"error": …}+. Never gate on the - # HTTP status here (mirrors the python reference). + # HTTP status here. # # Raises {AIChat::AIChatError} (or a typed subclass) when the body carries # +error+. diff --git a/lib/signalwire/contexts/context_builder.rb b/lib/signalwire/contexts/context_builder.rb index 8c03cefa..28acff2a 100644 --- a/lib/signalwire/contexts/context_builder.rb +++ b/lib/signalwire/contexts/context_builder.rb @@ -113,7 +113,7 @@ class GatherInfo # +isolated+ is the default for every question in this gather: when # true, each question is asked with the sibling Q&A hidden from the # model. A question's own +isolated:+ overrides this default. Held - # privately, matching the reference's `self._isolated`. + # privately — read it through the questions it seeds, not directly. def initialize(output_key: nil, completion_action: nil, prompt: nil, isolated: false) @output_key = output_key @completion_action = completion_action @@ -522,9 +522,9 @@ def render_text class Context attr_reader :name - # rubocop:disable Metrics/AbcSize -- a flat field-initialization list for - # one Python class (Context): every line is a distinct default assignment, - # not branching logic. Splitting it would only hide the data shape. + # rubocop:disable Metrics/AbcSize -- a flat field-initialization list: + # every line is a distinct default assignment, not branching logic. + # Splitting it would only hide the data shape. def initialize(name) @name = name @steps = {} # name => Step diff --git a/lib/signalwire/core/agent/prompt/manager.rb b/lib/signalwire/core/agent/prompt/manager.rb index cd119d36..107f8c7a 100644 --- a/lib/signalwire/core/agent/prompt/manager.rb +++ b/lib/signalwire/core/agent/prompt/manager.rb @@ -20,9 +20,7 @@ module Agent module Prompt # Manages prompt building and configuration for an agent. # - # Mirrors Python's - # ``signalwire.core.agent.prompt.manager.PromptManager`` and the - # TypeScript ``PromptManager`` class. It manages a POM-backed + # Manages a POM-backed # prompt (via {SignalWire::POM::PromptObjectModel}), an optional # raw prompt text, a post-prompt, and a contexts configuration # (via {SignalWire::Contexts::ContextBuilder}). @@ -36,9 +34,8 @@ class PromptManager attr_reader :pom # @return [Object, nil] the parent AgentBase back-reference this - # manager was constructed with. The reference exposes the same - # attribute (core/agent/prompt/manager.py), so a caller that passes - # an agent can read it back. + # manager was constructed with, so a caller that passes an agent + # can read it back. attr_reader :agent # @param agent [Object, nil] optional parent AgentBase instance @@ -73,8 +70,6 @@ def set_post_prompt(text) # Set the prompt from a POM array (list of section Hashes). # - # Mirrors Python's ``set_prompt_pom(pom)``. - # # @param pom [Array] POM section descriptors # @return [self] def set_prompt_pom(pom) @@ -85,10 +80,6 @@ def set_prompt_pom(pom) # Add a section to the prompt. # - # Mirrors Python's ``prompt_add_section(title, body="", - # bullets=None, numbered=False, numbered_bullets=False, - # subsections=None)``. - # # @param title [String] section title # @param body [String] optional body text # @param bullets [Array, nil] optional bullet points @@ -107,9 +98,6 @@ def prompt_add_section(title, body: '', bullets: nil, numbered: false, # Add content to an existing section (creating it if needed). # - # Mirrors Python's ``prompt_add_to_section(title, body=None, - # bullet=None, bullets=None)``. - # # @param title [String] section title # @param body [String, nil] text to append to the section body # @param bullet [String, nil] single bullet to add @@ -125,9 +113,6 @@ def prompt_add_to_section(title, body: nil, bullet: nil, bullets: nil) # Add a subsection to an existing section (creating the parent if # needed). # - # Mirrors Python's ``prompt_add_subsection(parent_title, title, - # body="", bullets=None)``. - # # @param parent_title [String] parent section title # @param title [String] subsection title # @param body [String] optional subsection body @@ -149,8 +134,8 @@ def prompt_has_section(title) # Define contexts for the agent. # - # Mirrors Python's ``define_contexts(contexts)`` which accepts a - # ``ContextBuilder`` (materialised via ``to_h``) or a raw Hash. + # Accepts a {SignalWire::Contexts::ContextBuilder} (materialised via + # +to_h+) or a raw Hash. # # @param contexts [SignalWire::Contexts::ContextBuilder, Hash] # @raise [ArgumentError] if not a ContextBuilder or Hash diff --git a/lib/signalwire/core/agent/tools/type_inference.rb b/lib/signalwire/core/agent/tools/type_inference.rb index b3aa466c..c9e7e6ee 100644 --- a/lib/signalwire/core/agent/tools/type_inference.rb +++ b/lib/signalwire/core/agent/tools/type_inference.rb @@ -58,7 +58,8 @@ module TypeInference # ``[parameters, required, description, is_typed, has_raw_data]``: # - parameters: name => property Hash (string keys) # - required: required parameter names - # - description: always nil (Ruby has no docstrings to parse) + # - description: always nil (there is no comment text to introspect + # at runtime; pass +descriptions:+ to supply one) # - is_typed: true if the callable takes named parameters # (i.e. it is NOT the old-style ``(args, raw_data)`` handler) # - has_raw_data: true if the callable accepts ``raw_data`` @@ -110,10 +111,10 @@ def legacy_handler?(names) [[:args], %i[args raw_data]].include?(names) end - # Parameter kinds that indicate a splat (``*args`` / ``**kwargs``). + # Parameter kinds that indicate a splat (``*rest`` / ``**keyrest``). SPLAT_KINDS = %i[rest keyrest].freeze - # A callable with a splat (``*args`` / ``**kwargs``) can't be + # A callable with a splat (``*rest`` / ``**keyrest``) can't be # introspected into a fixed schema — fall back to old style. def splat_present?(params) params.any? { |kind, _name| SPLAT_KINDS.include?(kind) } @@ -165,8 +166,8 @@ def symbolize_args(args) args.each_with_object({}) { |(k, v), acc| acc[k.to_sym] = v } end - # Internal helpers — the reference exposes only infer_schema and - # create_typed_handler_wrapper at the module level. + # Internal helpers — only infer_schema and + # create_typed_handler_wrapper are public. private_class_method :callable_parameters, :legacy_handler?, :splat_present?, :build_schema, :property_for, :schema_type, :required_kind?, :symbolize_args diff --git a/lib/signalwire/core/auth_handler.rb b/lib/signalwire/core/auth_handler.rb index 08a0ab86..b4fefcc8 100644 --- a/lib/signalwire/core/auth_handler.rb +++ b/lib/signalwire/core/auth_handler.rb @@ -19,9 +19,8 @@ module SignalWire module Core # Unified authentication handler supporting multiple auth methods. # - # Mirrors Python's ``signalwire.core.auth_handler.AuthHandler``. Provides a - # clean pattern for handling Basic Auth, Bearer tokens, and API keys across - # all SignalWire services. All credential comparisons are timing-safe + # Provides a clean pattern for handling Basic Auth, Bearer tokens, and API + # keys across all SignalWire services. All credential comparisons are timing-safe # (``Rack::Utils.secure_compare``). # # Two Rack-native entry points are provided: (a) +rack_middleware+ -- a @@ -37,7 +36,7 @@ class AuthHandler # header is split on the FIRST space: the first part is the +scheme+ # ("Bearer"), the second the +credentials+ (the token itself). Per RFC # 7235 the scheme token is compared case-INSENSITIVELY but carried - # VERBATIM here, mirroring the reference's HTTPAuthorizationCredentials. + # VERBATIM here. BasicCredentials = Struct.new(:username, :password) BearerCredentials = Struct.new(:scheme, :credentials) @@ -76,7 +75,7 @@ def verify_api_key(api_key) secure_compare(api_key, @auth_methods['api_key']['key']) end - # Native Rack equivalent of Python's FastAPI dependency. Returns a + # Rack-native auth dependency. Returns a # callable (lambda) that takes a Rack +env+ and returns an auth-result # Hash ``{ 'authenticated' => Boolean, 'method' => String|nil }``. When # +optional+ is false and authentication fails, the callable raises @@ -93,7 +92,7 @@ def rack_dependency(optional: false) end alias get_fastapi_dependency rack_dependency - # Native Rack equivalent of Python's Flask decorator. Given a Rack app + # Rack-native auth middleware. Given a Rack app # (any object responding to +call(env)+), returns a wrapping app that # enforces authentication: authenticated requests pass through, others # get an HTTP 401 with a WWW-Authenticate challenge. @@ -168,17 +167,15 @@ def bearer_env_ok?(env) scheme, credentials = split_authorization(env['HTTP_AUTHORIZATION']) # RFC 7235: the auth-scheme token is case-INSENSITIVE, so compare it - # folded (the reference does `scheme.lower() != "bearer"`) while - # carrying the scheme VERBATIM into the carrier. + # folded while carrying the scheme VERBATIM into the carrier. return false unless scheme.downcase == 'bearer' && !credentials.empty? verify_bearer_token(BearerCredentials.new(scheme, credentials)) end # Split an Authorization header on the FIRST space into - # +[scheme, credentials]+, mirroring the reference's - # +get_authorization_scheme_param+ (partition on ' ', strip the param). - # A nil/blank header yields +['', '']+. + # +[scheme, credentials]+, stripping surrounding whitespace from the + # credentials. A nil/blank header yields +['', '']+. def split_authorization(header) value = header.to_s return ['', ''] if value.empty? @@ -221,13 +218,13 @@ def basic_env_ok?(env) # @return [BasicCredentials, nil] def parse_basic_auth(header) scheme, param = split_authorization(header) - # RFC 7235 case-insensitive scheme compare (reference: - # `scheme.lower() != "basic"`). + # RFC 7235 case-insensitive scheme compare: "Basic", "basic" and + # "BASIC" are all accepted. return nil unless scheme.downcase == 'basic' decoded = Base64.decode64(param) user, separator, pass = decoded.partition(':') - # RFC 7617 / reference: `if not separator: raise`. A decoded payload + # RFC 7617: a decoded payload # with NO colon is NOT a credential pair -- reject it outright rather # than defaulting the password to ''. return nil if separator.empty? diff --git a/lib/signalwire/core/config_loader.rb b/lib/signalwire/core/config_loader.rb index 8166f557..8fe91570 100644 --- a/lib/signalwire/core/config_loader.rb +++ b/lib/signalwire/core/config_loader.rb @@ -16,7 +16,6 @@ module SignalWire module Core # Configuration loader with environment variable substitution. # - # Mirrors Python's ``signalwire.core.config_loader.ConfigLoader``. # Supports ``${VAR|default}`` syntax for referencing environment variables # within JSON (or YAML) configuration files. This provides a clean pattern # for configuration across all SignalWire services. @@ -29,10 +28,8 @@ class ConfigLoader File.expand_path('~/.swml/config.json'), '/etc/swml/config.json'].freeze # @return [Array] the search paths in use — the caller-supplied - # list, or {DEFAULT_PATHS} when none was given. The reference exposes the - # same resolved attribute (`self.config_paths = config_paths or - # self._get_default_paths()`, core/config_loader.py:37), so which paths a - # loader is actually consulting is readable back either way. + # list, or {DEFAULT_PATHS} when none was given. Reading this back tells + # you which paths a loader is actually consulting. attr_reader :config_paths # Initialize the config loader. diff --git a/lib/signalwire/core/logging_config.rb b/lib/signalwire/core/logging_config.rb index e30d663e..e35517f2 100644 --- a/lib/signalwire/core/logging_config.rb +++ b/lib/signalwire/core/logging_config.rb @@ -1,9 +1,10 @@ # frozen_string_literal: true -# Cross-language SDK contract for serverless / deployment-mode detection. +# Serverless / deployment-mode detection. # -# Mirrors signalwire.core.logging_config.get_execution_mode in the Python -# reference. Order of precedence (FIRST match wins): +# {SignalWire::Core::LoggingConfig.get_execution_mode} reads the environment +# and reports which platform the process is running on. Order of precedence +# (FIRST match wins): # # 1. GATEWAY_INTERFACE -> 'cgi' # 2. AWS_LAMBDA_FUNCTION_NAME or LAMBDA_TASK_ROOT -> 'lambda' @@ -76,14 +77,13 @@ def env_set?(name) end private_class_method :env_set? - # Control characters that could be used for log injection. Mirrors the - # Python reference's _CONTROL_CHAR_RE (C0/C1 controls minus \t\n\r). + # Control characters that could be used for log injection: the C0/C1 + # controls minus \t, \n and \r. CONTROL_CHAR_RE = Regexp.new("[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]") # Strip control characters from every string value of a log event hash, - # preventing log-injection. Mirrors - # signalwire.core.logging_config.strip_control_chars — a structlog - # processor in Python; here it is a plain hash transformer. + # preventing log-injection. A plain hash transformer: one hash in, the + # same hash out. # # @param event_dict [Hash] the log event # @return [Hash] the same hash with string values sanitised @@ -96,8 +96,8 @@ def strip_control_chars(event_dict) # Configure the SDK logging system once, globally, based on the # SIGNALWIRE_LOG_MODE / SIGNALWIRE_LOG_LEVEL environment variables. - # Mirrors signalwire.core.logging_config.configure_logging: idempotent — - # a second call is a no-op unless reset_logging_configuration ran first. + # Idempotent — a second call is a no-op unless + # reset_logging_configuration ran first. def configure_logging return if @logging_configured @@ -107,16 +107,14 @@ def configure_logging # Reset the one-time configuration guard so configure_logging can run # again (used when environment variables change after initial setup). - # Mirrors signalwire.core.logging_config.reset_logging_configuration. def reset_logging_configuration @logging_configured = false SignalWire::Logging.reset! if SignalWire::Logging.respond_to?(:reset!) nil end - # Return a named logger. Mirrors - # signalwire.core.logging_config.get_logger — ensures logging is - # configured, then returns a logger bound to +name+. + # Return a named logger: ensures logging is configured, then returns a + # logger bound to +name+. # # @param name [String] the logger name # @return [Object] a logger instance diff --git a/lib/signalwire/core/pom_builder.rb b/lib/signalwire/core/pom_builder.rb index 4e58c6f6..ebd890db 100644 --- a/lib/signalwire/core/pom_builder.rb +++ b/lib/signalwire/core/pom_builder.rb @@ -18,10 +18,9 @@ module Core # Builder class for creating structured prompts using the Prompt Object # Model. # - # Mirrors Python's ``signalwire.core.pom_builder.PomBuilder``. A flexible - # wrapper around {SignalWire::POM::PromptObjectModel} that allows for - # dynamic creation of sections on demand, adding content to existing - # sections, nesting subsections, and rendering to Markdown or XML. + # A flexible wrapper around {SignalWire::POM::PromptObjectModel} that + # allows for dynamic creation of sections on demand, adding content to + # existing sections, nesting subsections, and rendering to Markdown or XML. # # There are no predefined section types -- you can create any section # structure that fits your needs. All mutator methods return +self+ for @@ -119,8 +118,6 @@ def to_json(*_args) end # Create a PomBuilder from an Array of section Hashes. - # - # Mirrors Python's ``PomBuilder.from_sections`` classmethod. def self.from_sections(sections) builder = new builder.instance_variable_set(:@pom, SignalWire::POM::PromptObjectModel.from_json(sections)) diff --git a/lib/signalwire/core/security_config.rb b/lib/signalwire/core/security_config.rb index 1a6a58e5..7a9da4d2 100644 --- a/lib/signalwire/core/security_config.rb +++ b/lib/signalwire/core/security_config.rb @@ -19,7 +19,6 @@ module SignalWire module Core # Unified security configuration for SignalWire services. # - # Mirrors Python's ``signalwire.core.security_config.SecurityConfig``. # Provides centralized security settings (SSL, allowed hosts, CORS, # security headers, basic auth) that are consumed by the web/agent # services, ensuring consistent behavior. @@ -92,9 +91,8 @@ def validate_ssl_config # Get native TLS options for binding a WEBrick HTTPS server. Returns an # empty Hash when SSL is disabled or the configuration fails validation. # - # Ruby idiom note: Python returns uvicorn ``ssl_certfile``/``ssl_keyfile`` - # kwargs; Ruby returns WEBrick/OpenSSL option keys (:SSLEnable, - # :SSLCertificate, :SSLPrivateKey) ready to merge into a WEBrick config. + # The returned Hash uses WEBrick/OpenSSL option keys (:SSLEnable, + # :SSLCertificate, :SSLPrivateKey), ready to merge into a WEBrick config. def get_ssl_context_kwargs return {} unless ssl_enabled diff --git a/lib/signalwire/logging.rb b/lib/signalwire/logging.rb index e9b44586..58bf150b 100644 --- a/lib/signalwire/logging.rb +++ b/lib/signalwire/logging.rb @@ -85,15 +85,12 @@ def log(level, msg) return if LEVELS[level] < LEVELS[Logging.global_level] timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S') - # Scrub control characters BEFORE emitting — log-injection defence, and the - # reason the reference registers strip_control_chars in both of its structlog - # processor chains. A port that merely EXPOSES the scrub without putting it on - # the emission path offers no protection at all: a caller-supplied "\u0000" or + # Scrub control characters BEFORE emitting — log-injection defence. + # Merely EXPOSING the scrub without putting it on the + # emission path offers no protection at all: a caller-supplied "\u0000" or # an "\e[" escape reaches the terminal verbatim and can forge log lines. - # Route through the reference's event-map contract rather than a second - # public helper: a port-only `strip_control_chars_value` would be surface - # the reference does not have, and the surface gate reports it as an - # invented addition. One key in, one key out. + # The scrub goes through the event-map contract (one key in, one key + # out) rather than a separate value-level helper. safe = Core::LoggingConfig.strip_control_chars('event' => msg.to_s)['event'] @output.puts "[#{timestamp}] #{level.upcase} [#{@name}] #{safe}" end diff --git a/lib/signalwire/pom/prompt_object_model.rb b/lib/signalwire/pom/prompt_object_model.rb index 19a123f0..b2a394e7 100644 --- a/lib/signalwire/pom/prompt_object_model.rb +++ b/lib/signalwire/pom/prompt_object_model.rb @@ -17,10 +17,9 @@ module POM # can include a title, body text, bullet points, and arbitrarily # nested subsections. # - # Mirrors Python's ``signalwire.pom.pom.PromptObjectModel``. The - # rendered output (Markdown / XML / JSON / YAML) is byte-for-byte - # identical to the Python reference so cross-language POM documents - # interoperate. + # The rendered output (Markdown / XML / JSON / YAML) is a stable, + # byte-exact wire format, so POM documents interoperate with every other + # SignalWire SDK. class PromptObjectModel attr_accessor :sections, :debug @@ -33,9 +32,7 @@ def initialize(debug: false) # Build a PromptObjectModel from JSON. # - # +json_data+ may be either a JSON string or an already-parsed - # Array. Mirrors Python's - # ``PromptObjectModel.from_json(json_data: Union[str, dict])``. + # +json_data+ may be either a JSON string or an already-parsed Array. def self.from_json(json_data) data = json_data.is_a?(String) ? JSON.parse(json_data) : json_data _from_array(data) @@ -43,17 +40,14 @@ def self.from_json(json_data) # Build a PromptObjectModel from YAML. # - # +yaml_data+ may be either a YAML string or an already-parsed - # Array. Mirrors Python's - # ``PromptObjectModel.from_yaml(yaml_data: Union[str, dict])``. + # +yaml_data+ may be either a YAML string or an already-parsed Array. def self.from_yaml(yaml_data) data = yaml_data.is_a?(String) ? YAML.safe_load(yaml_data) : yaml_data _from_array(data) end # Internal: build a PromptObjectModel from a raw Array of Hash - # section descriptors. Mirrors Python's ``_from_dict`` (which - # confusingly takes a list, not a dict). + # section descriptors. def self._from_array(data) pom = new data = [] if data.nil? @@ -97,21 +91,19 @@ def find_section(title) recurse.call(@sections) end - # Convert the model to a JSON string. Output matches Python's - # ``json.dumps(..., indent=2)`` byte-for-byte, with one - # special case: an empty model serializes to ``"[]"`` (Ruby's - # default ``JSON.pretty_generate([])`` emits ``"[\n\n]"``). + # Convert the model to a JSON string, 2-space indented. One special + # case: an empty model serializes to ``"[]"``, because Ruby's default + # ``JSON.pretty_generate([])`` emits ``"[\n\n]"``, which is not the + # wire format. def to_json(*_args) return '[]' if @sections.empty? JSON.pretty_generate(@sections.map(&:to_h)) end - # Convert the model to a YAML string. Output matches Python's - # ``yaml.dump(..., default_flow_style=False, sort_keys=False)`` - # byte-for-byte. Ruby's ``YAML.dump`` prepends ``---\n``; we strip - # it. The empty-list case (Ruby emits ``--- []\n``) is normalised - # to Python's ``[]\n``. + # Convert the model to a YAML string: block style, keys in insertion + # order. Ruby's ``YAML.dump`` prepends ``---\n``; we strip it. The + # empty-list case (Ruby emits ``--- []\n``) is normalised to ``[]\n``. def to_yaml return "[]\n" if @sections.empty? @@ -120,14 +112,11 @@ def to_yaml end # Convert the model to an Array of Hash section descriptors. - # Mirrors Python's ``PromptObjectModel.to_dict`` (Ruby idiom uses - # ``to_h``). def to_h @sections.map(&:to_h) end - # Render the entire model as Markdown. Output is byte-for-byte - # identical to Python's ``PromptObjectModel.render_markdown``. + # Render the entire model as Markdown. def render_markdown any_section_numbered = @sections.any?(&:numbered) SectionBuilder.debug_header(@sections, any_section_numbered) if @debug @@ -141,8 +130,7 @@ def render_markdown md.join("\n") end - # Render the entire model as XML. Output is byte-for-byte identical - # to Python's ``PromptObjectModel.render_xml``. + # Render the entire model as XML. def render_xml xml = ['', ''] any_section_numbered = @sections.any?(&:numbered) @@ -161,8 +149,6 @@ def render_xml # Add another PromptObjectModel as a subsection of an existing # section identified either by title or by Section reference. # - # Mirrors Python's - # ``PromptObjectModel.add_pom_as_subsection(target, pom_to_add)``. def add_pom_as_subsection(target, pom_to_add) target_section = resolve_target_section(target) pom_to_add.sections.each do |section| @@ -194,8 +180,7 @@ def resolve_target_section(target) end # Internal: validates raw section Hashes and builds Section trees from - # them. Mirrors Python's ``build_section`` inner helper. Not part of the - # public POM surface. + # them. Not part of the public POM surface. module SectionBuilder module_function @@ -289,8 +274,8 @@ def section_kwargs(hash) kwargs end - # Compute the [section_number, counter] pair for one section, mirroring - # the Python numbering logic. Untitled sections get an empty number and + # Compute the [section_number, counter] pair for one section. Untitled + # sections get an empty number and # don't advance the counter. def section_number(section, counter, any_section_numbered) return [[], counter] if section.title.nil? diff --git a/lib/signalwire/pom/section.rb b/lib/signalwire/pom/section.rb index 4885322f..88e6db30 100644 --- a/lib/signalwire/pom/section.rb +++ b/lib/signalwire/pom/section.rb @@ -8,11 +8,10 @@ module POM # Each section contains a title, optional body text, optional bullet # points, and can have any number of nested subsections. # - # Mirrors Python's ``signalwire.pom.pom.Section`` exactly. See - # ``signalwire-python/signalwire/signalwire/pom/pom.py`` for the - # source-of-truth specification; rendering output (markdown / XML / - # JSON / YAML) must match Python byte-for-byte so cross-language POM - # documents are interoperable. + # The rendering output (markdown / XML / JSON / YAML) is part of the POM + # contract: key order and formatting are load-bearing, so a document + # written by this SDK is byte-comparable with one written by any other + # POM producer. Treat the renderers as wire code, not cosmetics. # # Attributes: # * +title+ — the name of the section. @@ -27,10 +26,9 @@ class Section # Construct a Section. # - # All arguments after +title+ are keyword arguments mirroring the - # Python ``Section.__init__`` signature. ``numbered_bullets`` is - # snake_case in Ruby; the camelCase ``numberedBullets`` form used - # by Python's JSON/YAML serialization is preserved on the wire. + # +title+ is positional; every argument after it is a keyword. + # ``numbered_bullets`` is snake_case in the Ruby API but serializes to + # the camelCase ``numberedBullets`` key on the wire. def initialize(title = nil, body: '', bullets: nil, numbered: nil, numbered_bullets: false) validate_body!(body) validate_bullets!(bullets) @@ -43,8 +41,8 @@ def initialize(title = nil, body: '', bullets: nil, numbered: nil, numbered_bull @numbered_bullets = numbered_bullets end - # Add or replace the body text for this section. Mirrors Python's - # ``Section.add_body`` (which is documented to "Add or replace"). + # Add or replace the body text for this section — an existing body is + # overwritten, not appended to. def add_body(body) raise TypeError, "body must be a string, not #{body.class.name}" unless body.is_a?(String) @@ -52,7 +50,7 @@ def add_body(body) end # Append bullet points to this section. Does not replace existing - # bullets — mirrors Python's ``self.bullets.extend(bullets)``. + # bullets — the given Array is concatenated onto them. def add_bullets(bullets) raise TypeError, "bullets must be an Array, not #{bullets.class.name}" unless bullets.is_a?(Array) @@ -61,9 +59,9 @@ def add_bullets(bullets) # Add a subsection to this section, returning the new Section. # - # Raises ArgumentError when +title+ is nil (Python raises - # ``ValueError("Subsections must have a title")``; Ruby idiom - # is ArgumentError for invalid arguments). + # A subsection MUST have a title: +title+ of nil raises ArgumentError + # ("Subsections must have a title"), the Ruby idiom for an invalid + # argument. def add_subsection(title, body: '', bullets: nil, numbered: false, numbered_bullets: false) raise ArgumentError, 'Subsections must have a title' if title.nil? @@ -74,10 +72,10 @@ def add_subsection(title, body: '', bullets: nil, numbered: false, numbered_bull end # Convert the section to a Hash representation suitable for JSON or - # YAML serialization. Keys are emitted in the same order as Python - # so cross-port string comparisons line up. + # YAML serialization. Key emission order is fixed: title, body, bullets, + # subsections, numbered, numberedBullets. # rubocop:disable Metrics/CyclomaticComplexity -- wire-critical: each guard - # emits one key in exact Python order; flattening to one branch per field is + # emits one key in that exact order; flattening to one branch per field is # the clearest expression and must not be split (key order is the contract). def to_h data = {} @@ -91,9 +89,8 @@ def to_h end # rubocop:enable Metrics/CyclomaticComplexity - # Render this section and all its subsections as Markdown. The - # output is byte-for-byte identical to Python's - # ``Section.render_markdown``. + # Render this section and all its subsections as Markdown. The exact + # output is part of the POM contract — see the class docs. def render_markdown(level: 2, section_number: nil) md = [] section_number = [] if section_number.nil? @@ -113,8 +110,8 @@ def render_markdown(level: 2, section_number: nil) md.join("\n") end - # Render this section and all its subsections as XML. Output is - # byte-for-byte identical to Python's ``Section.render_xml``. + # Render this section and all its subsections as XML. The exact output + # is part of the POM contract — see the class docs. def render_xml(indent: 0, section_number: nil) indent_str = ' ' * indent xml = [] @@ -169,7 +166,7 @@ def number_prefix(section_number) end # Subsections only inherit/extend numbering when this section is itself - # titled or already numbered. Mirrors Python's render guard exactly. + # titled or already numbered. def titled_or_numbered?(section_number) !@title.nil? || !section_number.empty? end diff --git a/lib/signalwire/prefabs/concierge.rb b/lib/signalwire/prefabs/concierge.rb index 7c8c54b8..ca146152 100644 --- a/lib/signalwire/prefabs/concierge.rb +++ b/lib/signalwire/prefabs/concierge.rb @@ -22,19 +22,17 @@ module Prefabs # ) # class Concierge - # The reference's default when the caller supplies no hours - # (prefabs/concierge.py:78). It always renders an Hours of Operation - # section, so the default has to exist rather than the section vanishing. + # The hours used when the caller supplies none. The agent always renders + # an Hours of Operation section, so the default has to exist rather than + # the section vanishing. DEFAULT_HOURS = { 'default' => '9 AM - 5 PM' }.freeze attr_reader :venue_name, :services, :amenities, :name, :route # @return [Hash{String=>String}] operating hours per label — the - # caller-supplied map or {DEFAULT_HOURS}. Reference attribute - # `self.hours_of_operation` (prefabs/concierge.py:78). + # caller-supplied map or {DEFAULT_HOURS}. # @return [Array] +special_instructions+: extra instruction - # bullets appended to the agent's Instructions. Reference attribute - # `self.special_instructions` (prefabs/concierge.py:79). + # bullets appended to the agent's Instructions. attr_reader :hours_of_operation, :special_instructions # @param venue_name [String] the venue the agent represents, used throughout its prompt @@ -52,9 +50,9 @@ def initialize(venue_name:, services:, amenities:, hours_of_operation: nil, @venue_name = venue_name @services = services || [] @amenities = (amenities || {}).transform_keys(&:to_s) - # The reference takes a per-label MAP (`dict[str, str]`); normalise a - # bare String to the default label so both shapes reach the prompt and - # `global_data` always carries a map, as every other port does. + # Hours are a per-label map of String => String; normalise a bare + # String to the default label so both shapes reach the prompt and + # `global_data` always carries a map. @hours_of_operation = normalize_hours(hours_of_operation) @special_instructions = special_instructions || [] @welcome = welcome_message || "Welcome to #{venue_name}! How can I assist you today?" @@ -83,8 +81,8 @@ def prompt_sections } ] sections << instructions_section unless @special_instructions.empty? - # Always emitted — the reference renders this section unconditionally - # from a defaulted map, so hours are never silently absent. + # Always emitted — rendered unconditionally from a defaulted map, so + # hours are never silently absent. sections << hours_section sections end @@ -202,9 +200,9 @@ def format_amenity_detail(info) info.is_a?(Hash) ? info.map { |k, v| "#{k}: #{v}" }.join(', ') : info.to_s end - # Normalise the caller's hours to the reference's per-label map shape. A - # bare String is accepted for convenience and filed under the default - # label; nil falls back to DEFAULT_HOURS. + # Normalise the caller's hours to the per-label map shape. A bare String + # is accepted for convenience and filed under the default label; nil + # falls back to DEFAULT_HOURS. def normalize_hours(hours) return DEFAULT_HOURS.dup if hours.nil? return { 'default' => hours.to_s } unless hours.is_a?(Hash) @@ -213,17 +211,15 @@ def normalize_hours(hours) end # The "Hours of Operation" prompt section. One "Label: value" line per - # entry, labels title-cased and newline-joined, matching the reference - # (`"\n".join(f"{k.title()}: {v}" ...)`, prefabs/concierge.py:133-135). + # entry, labels title-cased and newline-joined. def hours_section body = @hours_of_operation.map { |k, v| "#{k.to_s.split(/\s+/).map(&:capitalize).join(' ')}: #{v}" } .join("\n") { 'title' => 'Hours of Operation', 'body' => body } end - # The extra instruction bullets the caller supplied. The reference appends - # these to its Instructions section (prefabs/concierge.py:106); before this - # they were stored and never reached the prompt at all. + # The extra instruction bullets the caller supplied, appended to the + # agent's Instructions section. def instructions_section { 'title' => 'Instructions', 'bullets' => @special_instructions.map(&:to_s) } end diff --git a/lib/signalwire/prefabs/faq_bot.rb b/lib/signalwire/prefabs/faq_bot.rb index 9d885b45..809f0b42 100644 --- a/lib/signalwire/prefabs/faq_bot.rb +++ b/lib/signalwire/prefabs/faq_bot.rb @@ -22,8 +22,8 @@ module Prefabs # ) # class FaqBot - # The bullet the reference appends to its Instructions section when - # suggest_related is on (prefabs/faq_bot.py:111-113). + # The bullet appended to the Instructions section when suggest_related + # is on. SUGGEST_RELATED_INSTRUCTION = 'When appropriate, suggest other related questions from the FAQ database ' \ 'that might be helpful.' @@ -31,11 +31,9 @@ class FaqBot attr_reader :faqs, :name, :route # @return [String] the personality body in force — the caller-supplied - # +persona:+ or the default. Reference attribute `self.persona` - # (prefabs/faq_bot.py:76). + # +persona:+ or the default. # @return [Boolean] +suggest_related+: whether the agent is instructed to - # offer related questions. Reference attribute `self.suggest_related` - # (prefabs/faq_bot.py:75). + # offer related questions. attr_reader :persona, :suggest_related # @param faqs [Array] the question/answer pairs; must be non-empty @@ -78,10 +76,10 @@ def prompt_sections } ] # suggest_related must reach the PROMPT, not just global_data — it is the - # switch that tells the agent to offer related questions, and the - # reference renders it in two places (an Instructions bullet plus a - # Related Questions section, prefabs/faq_bot.py:110,143-148). Without - # this the flag was accepted and had no effect on agent behaviour. + # switch that tells the agent to offer related questions, and it is + # rendered in two places (an Instructions bullet plus a Related + # Questions section). Without this the flag was accepted and had no + # effect on agent behaviour. sections << { 'title' => 'Related Questions', 'body' => SUGGEST_RELATED_INSTRUCTION } if @suggest_related sections end diff --git a/lib/signalwire/prefabs/info_gatherer.rb b/lib/signalwire/prefabs/info_gatherer.rb index 803414ff..459d12a0 100644 --- a/lib/signalwire/prefabs/info_gatherer.rb +++ b/lib/signalwire/prefabs/info_gatherer.rb @@ -19,8 +19,8 @@ module Prefabs # +global_data+ so the served SWML actually drives the question flow. The # +submit_answer+ tool is a real state machine — it reads the current # +question_index+/+answers+ from the request's +global_data+, records the - # answer, advances the index, and returns the next question (or completion), - # mirroring the Python +InfoGathererAgent+. + # answer, advances the index, and returns the next question (or + # completion). # # agent = InfoGatherer.new( # questions: [ @@ -31,7 +31,7 @@ module Prefabs # class InfoGatherer < AgentBase # Fallback questions used in dynamic mode when no callback is registered - # or the callback raises (mirrors Python's fallback list). + # or the callback raises. FALLBACK_QUESTIONS = [ { 'key_name' => 'name', 'question_text' => 'What is your name?' }, { 'key_name' => 'message', 'question_text' => 'How can I help you today?' } @@ -199,9 +199,10 @@ def configure_agent_settings set_params('end_of_speech_timeout' => 800, 'speech_event_timeout' => 1000) end - # Pull the question-flow state out of a SWAIG request's global_data, with - # the same defaults Python uses. Accepts both the flat seed shape - # ({questions,question_index,answers}) and a nil/empty raw_data. + # Pull the question-flow state out of a SWAIG request's global_data, + # defaulting to the constructor's questions, index 0 and no answers. + # Accepts both the flat seed shape ({questions,question_index,answers}) + # and a nil/empty raw_data. def request_global_data(raw_data) gd = (raw_data.is_a?(Hash) ? raw_data['global_data'] : nil) || {} { @@ -256,7 +257,7 @@ def question_field(question, name) end # Invoke the per-request question callback, normalizing keys to strings. - # Falls back to FALLBACK_QUESTIONS on any error (matching Python). + # Falls back to FALLBACK_QUESTIONS on any error. def resolve_dynamic_questions(request_data, request) query_params = request_attr(request, :query_params) headers = request_attr(request, :headers) diff --git a/lib/signalwire/prefabs/receptionist.rb b/lib/signalwire/prefabs/receptionist.rb index 0f9bbcf2..d743b905 100644 --- a/lib/signalwire/prefabs/receptionist.rb +++ b/lib/signalwire/prefabs/receptionist.rb @@ -27,9 +27,8 @@ class Receptionist attr_reader :departments, :name, :route, :greeting # @param voice [String] voice ID the agent speaks with. Configures the - # agent's English language entry (mirrors Python's - # +add_language(name="English", code="en-US", voice=voice)+); like the - # reference it is held privately, not exposed as public surface. + # agent's English language entry (name "English", code "en-US", this + # voice); it is held privately, not exposed as public surface. def initialize(departments:, name: 'receptionist', route: '/receptionist', greeting: 'Thank you for calling. How can I help you today?', voice: DEFAULT_VOICE, **_opts) @@ -91,8 +90,7 @@ def handle_transfer(args, _raw_data) # Lifecycle hook: on_summary. # # No-op extension point: the base receptionist does not process the - # transfer summary. Subclasses override this to handle the summary - # (mirrors Python's ``def on_summary(...): pass``). + # transfer summary. Subclasses override this to handle the summary. # # @param _summary [Hash, String, nil] conversation summary # @param _raw_data [Hash, nil] full raw POST data @@ -103,9 +101,8 @@ def on_summary(_summary, _raw_data = nil) private - # Configure the agent's language with the requested voice. Mirrors the - # reference's `_configure_agent_settings(voice)` → `add_language(...)`; - # the resulting list is private state (`self._languages` in Python). + # Configure the agent's language with the requested voice. The resulting + # language list is private state, not public surface. def configure_agent_settings(voice) @voice = voice @languages = [{ 'name' => 'English', 'code' => 'en-US', 'voice' => voice }] diff --git a/lib/signalwire/prefabs/survey.rb b/lib/signalwire/prefabs/survey.rb index fd2429c6..03b57661 100644 --- a/lib/signalwire/prefabs/survey.rb +++ b/lib/signalwire/prefabs/survey.rb @@ -95,12 +95,10 @@ class Survey attr_reader :survey_name, :questions, :name, :route, :brand_name, :max_retries # @return [String] the opening message in force — the caller-supplied - # +introduction:+ or the generated default. Reference attribute - # `self.introduction` (prefabs/survey.py). + # +introduction:+ or the generated default. # @return [String] +conclusion+: the closing message — caller-supplied or - # {DEFAULT_CONCLUSION}. Also a public reference attribute. Both are - # defaulted, so reading back is the only way a caller learns which text - # the agent will actually speak. + # {DEFAULT_CONCLUSION}. Both are defaulted, so reading them back is the + # only way a caller learns which text the agent will actually speak. attr_reader :introduction, :conclusion # @param brand_name [String, nil] brand or company name the agent diff --git a/lib/signalwire/relay/call.rb b/lib/signalwire/relay/call.rb index c288699e..f8a79016 100644 --- a/lib/signalwire/relay/call.rb +++ b/lib/signalwire/relay/call.rb @@ -97,9 +97,8 @@ def call_gone_error?(error) # Register an event listener for this call. # - # The handler is REQUIRED, matching the reference - # (``on(self, event_type: str, handler: EventHandler)``). Ruby's block IS - # the handler; supplying neither registers nothing and raises. + # The handler is REQUIRED. Ruby's block IS the handler; supplying neither + # registers nothing and raises. def on(event_type, handler, &block) callback = block || handler raise ArgumentError, 'on requires a handler (block or callable)' if callback.nil? @@ -191,10 +190,10 @@ def ended? # Block until the call reaches +target+, returning immediately if the # call is already at or past that state. Backs the typed +wait_for_*+ - # helpers below. Mirrors Python's +Call._wait_for_state+: states are - # ordered created < ringing < answered < ending < ended, and a call - # already at/past the target resolves with a synthetic state event - # (matching the legacy SDK's short-circuit). + # helpers below. States are ordered + # created < ringing < answered < ending < ended, and a call already + # at/past the target resolves with a synthetic state event (the legacy + # SDK's short-circuit). def _wait_for_state(target, timeout) return synthetic_state_event if state_rank(@state) >= state_rank(target) @@ -219,22 +218,19 @@ def state_rank(state) end # Wait until the call is answered (immediate if already answered or past - # it). Typed wait over #wait_for. Mirrors Python's - # +Call.wait_for_answered(timeout)+. + # it). Typed wait over #wait_for. def wait_for_answered(timeout: nil) _wait_for_state(CALL_STATE_ANSWERED, timeout) end # Wait until the call is ringing (immediate if already ringing or past - # it). Typed wait over #wait_for. Mirrors Python's - # +Call.wait_for_ringing(timeout)+. + # it). Typed wait over #wait_for. def wait_for_ringing(timeout: nil) _wait_for_state(CALL_STATE_RINGING, timeout) end # Wait until the call is ending (immediate if already ending or past - # it). Typed wait over #wait_for. Mirrors Python's - # +Call.wait_for_ending(timeout)+. + # it). Typed wait over #wait_for. def wait_for_ending(timeout: nil) _wait_for_state(CALL_STATE_ENDING, timeout) end @@ -609,8 +605,6 @@ def play(media, volume: nil, direction: nil, loop_count: nil, # # Restores the legacy +call.play_tts(text)+ ergonomics so callers don't # hand-build the +{ 'type' => 'tts', 'params' => {...} }+ media shape. - # Mirrors Python's +Call.play_tts(text, *, language, gender, voice, - # volume, on_completed)+. # # Wire shape: play [{ 'type' => 'tts', 'params' => { 'text', language?, # gender?, voice? } }] with an optional top-level +volume+. @@ -625,7 +619,6 @@ def play_tts(text, language: nil, gender: nil, voice: nil, volume: nil, end # Play an audio file from a URL. Typed convenience over #play. - # Mirrors Python's +Call.play_audio(url, *, volume, on_completed)+. # # Wire shape: play [{ 'type' => 'audio', 'params' => { 'url' } }] with an # optional top-level +volume+. @@ -635,7 +628,6 @@ def play_audio(url, volume: nil, on_completed: nil) end # Play silence for +duration+ seconds. Typed convenience over #play. - # Mirrors Python's +Call.play_silence(duration, *, on_completed)+. # # Wire shape: play [{ 'type' => 'silence', 'params' => { 'duration' } }]. def play_silence(duration, on_completed: nil) @@ -644,8 +636,6 @@ def play_silence(duration, on_completed: nil) end # Play a named ringtone by country code. Typed convenience over #play. - # Mirrors Python's +Call.play_ringtone(name, *, duration, volume, - # on_completed)+. # # Wire shape: play [{ 'type' => 'ringtone', 'params' => { 'name', # duration? } }] with an optional top-level +volume+. @@ -702,8 +692,6 @@ def collect(collect_opts, control_id: nil, on_completed: nil, **kwargs) end # Play TTS then collect input. Typed media over #play_and_collect. - # Mirrors Python's +Call.prompt_tts(text, collect, *, language, gender, - # voice, volume, on_completed)+. # # Wire shape: play_and_collect [{ 'type' => 'tts', 'params' => { 'text', # language?, gender?, voice? } }] with the given +collect+ object and an @@ -719,8 +707,7 @@ def prompt_tts(text, collect, language: nil, gender: nil, voice: nil, end # Play an audio file then collect input. Typed media over - # #play_and_collect. Mirrors Python's +Call.prompt_audio(url, collect, - # *, volume, on_completed)+. + # #play_and_collect. # # Wire shape: play_and_collect [{ 'type' => 'audio', 'params' => # { 'url' } }] with the given +collect+ object and an optional top-level @@ -745,8 +732,6 @@ def detect(detect_opts, timeout: nil, control_id: nil, end # Detect DTMF digits. Typed convenience over #detect. - # Mirrors Python's +Call.detect_digit(*, digits, timeout, - # on_completed)+. # # Wire shape: detect { 'type' => 'digit', 'params' => { digits? } } with # an optional top-level +timeout+. @@ -758,10 +743,7 @@ def detect_digit(digits: nil, timeout: nil, on_completed: nil) end # Detect human vs answering machine (AMD). Typed convenience over - # #detect. Mirrors Python's +Call.detect_answering_machine(*, - # initial_timeout, end_silence_timeout, machine_voice_threshold, - # machine_words_threshold, detect_interruptions, detect_message_end, - # timeout, on_completed)+. + # #detect. # # Wire shape: detect { 'type' => 'machine', 'params' => { ...only the # provided fields... } } with an optional top-level +timeout+. @@ -783,7 +765,6 @@ def detect_answering_machine(initial_timeout: nil, end_silence_timeout: nil, end # Detect a fax tone (CED/CNG). Typed convenience over #detect. - # Mirrors Python's +Call.detect_fax(*, tone, timeout, on_completed)+. # # Wire shape: detect { 'type' => 'fax', 'params' => { tone? } } with an # optional top-level +timeout+. @@ -901,7 +882,7 @@ def inspect attr_reader :client # Internal helpers (formerly leading-underscore by convention). Not part of - # the public/Python surface — declared private so the cross-port surface + # the public surface — declared private so it stays # enumerator continues to exclude them. _execute / _dispatch_event / # _wait_for_state stay public+underscored: they are invoked cross-instance # (Action, RelayClient, and the test suite call them with an explicit diff --git a/lib/signalwire/relay/client.rb b/lib/signalwire/relay/client.rb index b04ed5b8..1cff0bb9 100644 --- a/lib/signalwire/relay/client.rb +++ b/lib/signalwire/relay/client.rb @@ -44,12 +44,9 @@ def initialize(code, message) class Client attr_reader :project_id, :protocol, :host, :max_active_calls - # Caller-supplied connection config, readable back. The reference exposes - # every one of these as a public attribute set from the same-named - # constructor param (relay/client.py:171-175), so a Ruby caller that can - # PASS `token:`/`jwt_token:`/`contexts:` must be able to read them; they - # were behind `private` until now, which took the read-back capability away - # from Ruby callers only. (`space` stays private — it is a back-compat + # Caller-supplied connection config, readable back: a caller that can PASS + # `token:`/`jwt_token:`/`contexts:` can also read them. (`space` stays + # private — it is a back-compat # alias for `host:` with no reference counterpart.) attr_reader :token, :jwt_token, :contexts @@ -116,13 +113,13 @@ def initialize(project: nil, token: nil, jwt_token: nil, host: nil, def resolve_credentials(project, token, host, space) @project_id = value_or_env(project, 'SIGNALWIRE_PROJECT_ID') @token = value_or_env(token, 'SIGNALWIRE_API_TOKEN') - # Accept either `host:` (Python parity) or legacy `space:`. + # Accept either `host:` or the legacy `space:`. @space = value_or_env(host || space, 'SIGNALWIRE_SPACE') end # @api private — the explicit value, else the named environment variable, else # the empty string. Never nil, so callers can test emptiness rather than - # nil-ness (which is what the reference's truthiness checks amount to). + # nil-ness. # # @return [String] def value_or_env(explicit, env_key) @@ -149,16 +146,15 @@ def resolve_max_active_calls(max_active_calls) def validate_credentials # JWT auth (env: SIGNALWIRE_JWT_TOKEN or the jwt_token: kwarg) is a # self-contained alternative to project/token — the project id lives - # inside the token, so only the host is still required. Mirrors the - # Python reference's truthiness check (an empty jwt_token is no token). + # inside the token, so only the host is still required. An EMPTY + # jwt_token counts as no token. unless jwt_token.empty? raise ArgumentError, 'host is required (set SIGNALWIRE_SPACE)' if space.empty? return end # Per-variable actionable pre-connect errors (A6): each names the missing - # credential AND its env var so a failure is self-diagnosing. Mirrors the - # python reference (client.py project-is-required / token-is-required). + # credential AND its env var so a failure is self-diagnosing. raise ArgumentError, 'project is required (set SIGNALWIRE_PROJECT_ID)' if project_id.empty? raise ArgumentError, 'token or jwt_token is required (set SIGNALWIRE_API_TOKEN)' if token.empty? raise ArgumentError, 'host is required (set SIGNALWIRE_SPACE)' if space.empty? @@ -188,12 +184,10 @@ def init_session_state @authorization_state = nil # Server-assigned session id from the connect handshake. Kept off the # public surface (single-underscore reader, like +_set_protocol+ and - # +_authorization_state+, so the surface oracle excludes it) and never - # widens the developer-facing API. Test-harness support only: the - # mock-relay tests read it (via +_session_id+) to scope the shared - # mock's journal to their own connection. This mirrors the frozen - # TypeScript port's private +_sessionId+ capture; Python's RelayClient - # doesn't surface it either, so no public-surface parity is affected. + # +_authorization_state+) and never widens the developer-facing API. + # Test-harness support only: the mock-relay tests read it (via + # +_session_id+) to scope the shared mock's journal to their own + # connection. @session_id = nil @ws = nil @running = false @@ -230,8 +224,7 @@ def inspect # Register inbound call handler. # - # ``handler`` is REQUIRED, matching the reference - # (``on_call(self, handler: CallHandler)``) and every other port. Ruby + # ``handler`` is REQUIRED. Ruby # cannot let a block satisfy a required positional, so the callable is # passed explicitly — ``client.on_call(->(call) { ... })``. A block is still # accepted and takes precedence when both are given, which keeps @@ -264,8 +257,7 @@ def send_json(msg) end # Return the current call_id -> Call registry (a snapshot copy). - # Test/audit-only surface for asserting on internal routing state; - # the Python reference exposes the same via +RelayClient._calls+. + # Test/audit-only surface for asserting on internal routing state. def _calls_snapshot @calls_mutex.synchronize { @calls.dup } end @@ -273,7 +265,7 @@ def _calls_snapshot # Test/reconnect surface: stamp a previously issued protocol # string before calling +run+ so the next signalwire.connect frame # carries it (the production server replies with - # +session_restored: true+). Mirrors Python's +RelayClient._relay_protocol = ...+. + # +session_restored: true+). def _set_protocol(value) @protocol = value end @@ -315,8 +307,8 @@ def run end # Establish the RELAY connection without entering the blocking reconnect - # loop. Mirrors Python RelayClient.connect — brings the socket up and - # returns; use run() for the blocking, auto-reconnecting event loop and + # loop: brings the socket up and + # returns. Use run() for the blocking, auto-reconnecting event loop and # disconnect()/stop() to tear down. def connect @running = true @@ -324,8 +316,7 @@ def connect self end - # Graceful shutdown. Also exposed as +disconnect+ (Python name) via the - # surface enumerator alias. + # Graceful shutdown. Also exposed as +disconnect+. def stop @running = false # Snapshot under the mutex, close outside it. The websocket-client @@ -345,11 +336,10 @@ def stop # ------------------------------------------------------------------ # Dial outbound call(s). Returns a Call object. - # Keyword names and defaults mirror the reference - # (``tag=None, max_duration=None, dial_timeout=None``): ``dial_timeout`` - # defaults to nil and the 120s fallback is applied at the wait, exactly - # where python applies it (`dial_timeout if dial_timeout is not None else - # 120.0`). ``max_duration`` is an explicit keyword, not a **kwargs + # ``tag``, ``max_duration`` and ``dial_timeout`` all default to nil. + # ``dial_timeout``'s 120-second fallback is applied at the WAIT, not at + # the call, so an explicit nil is not the same as omitting it. + # ``max_duration`` is an explicit keyword, not a **kwargs # passenger, and reaches the wire only when truthy. def dial(devices, tag: nil, max_duration: nil, dial_timeout: nil) dial_tag = tag || SecureRandom.uuid @@ -372,8 +362,8 @@ def dial(devices, tag: nil, max_duration: nil, dial_timeout: nil) # Send an SMS/MMS message. Returns a Message object. # - # Mirrors Python's RelayClient.send_message keyword-only signature - # exactly. At least one of body: or media: is required. + # Every argument is keyword-only. At least one of body: or media: is + # required. def send_message(to_number:, from_number:, context: nil, body: nil, media: nil, tags: nil, region: nil, on_completed: nil) validate_message_payload(body, media) @@ -417,7 +407,7 @@ def execute(method, params) entry = { mutex: Mutex.new, cv: ConditionVariable.new, result: nil, error: nil } @pending_mutex.synchronize { @pending[id] = entry } - # Python parity: params are sent VERBATIM. The protocol is only carried + # Params are sent VERBATIM. The protocol is only carried # on the signalwire.connect handshake (see apply_session_restore), NOT # injected into every calling.*/messaging.* frame. _send_json('jsonrpc' => '2.0', 'id' => id, 'method' => method, @@ -434,9 +424,9 @@ def execute(method, params) private # The handler slot for a ``on_*`` registration: the block if one was given, - # else the explicit callable. Raises when neither is supplied — the - # reference declares the handler REQUIRED, so a registration that registers - # nothing must fail loudly rather than leave a silently-dead callback. + # else the explicit callable. Raises when neither is supplied — the handler + # is REQUIRED, so a registration that registers nothing must fail loudly + # rather than leave a silently-dead callback. def require_handler(handler, block, method_name) callback = block || handler raise ArgumentError, "#{method_name} requires a handler (block or callable)" if callback.nil? @@ -746,8 +736,7 @@ def authenticate @protocol = result['protocol'] if result['protocol'] # Capture the server-assigned session id from the ConnectResult. Stays # internal (test-harness only, via +_session_id+) to scope the shared - # mock relay's journal to this connection for parallel-safe tests; - # mirrors the frozen TypeScript port's +_sessionId+ capture. + # mock relay's journal to this connection for parallel-safe tests. @session_id = result['sessionid'] if result['sessionid'] end @@ -764,21 +753,19 @@ def apply_session_restore(params) # @api private — add the credentials to the connect params. A non-empty # jwt_token wins; otherwise project/token go under `authentication` AND are - # repeated at the top level, because the reference emits them nested while the - # audit harness watches the top level. + # repeated at the top level, because Blade-aware servers accept either + # placement. def apply_auth_credentials(params) # An unset jwt_token is the empty string (env fallback), not nil — and - # in Ruby '' is truthy, so guard on emptiness to match Python's - # truthiness check (`if self.jwt_token:`). + # in Ruby '' is TRUTHY, so guard on emptiness rather than truth. unless jwt_token.empty? params['authentication'] = { 'jwt_token' => jwt_token } return end params['authentication'] = { 'project' => project_id, 'token' => token } - # Audit fixtures and Blade-aware servers also accept the credentials at - # the top level. Python's RELAY emits them in `authentication`; the audit - # harness watches the top level. Emit both to satisfy both consumers. + # Blade-aware servers also accept the credentials at the top level. + # Emit both placements to satisfy every consumer. params['project'] = project_id params['token'] = token end @@ -967,7 +954,6 @@ def handle_inbound_call(payload) # True when the configured max_active_calls cap is reached, so the N+1th # inbound call is DROPPED (not silently accepted). nil cap = unlimited. - # Mirrors python client.py _handle_inbound_call (len(_calls) >= cap). def max_active_calls_reached? cap = @max_active_calls return false if cap.nil? @@ -1125,8 +1111,8 @@ def reject_entry(entry, error) end # Internal helpers (formerly leading-underscore by convention). Not part - # of the public/Python surface -- declared private so the cross-port - # surface enumerator continues to exclude them. _send_json / _connected? / + # of the public surface -- declared private so they stay off it. + # _send_json / _connected? / # _calls_snapshot / _set_protocol / _authorization_state / _session_id stay # public+underscored (invoked cross-instance by tests / the send_json wrapper). private :apply_auth_credentials, :apply_session_restore, :authenticate, :await_dial, diff --git a/lib/signalwire/relay/constants.rb b/lib/signalwire/relay/constants.rb index 466388ec..503a6a68 100644 --- a/lib/signalwire/relay/constants.rb +++ b/lib/signalwire/relay/constants.rb @@ -37,12 +37,11 @@ module Relay # value stays a bare String everywhere (the events carry +call_state+ as a # String, +Call#state+ is a String), and the flat +CALL_STATE_*+ constants # above remain the single source of the literals. This module wraps them - # with the Wave-A/Tier-1 idiom — a frozen +ALL+ ordered list, a frozen + # with a frozen +ALL+ ordered list, a frozen # +TERMINAL+ set, and a +terminal?+ predicate — so callers can ask # +CallState.terminal?(state)+ instead of hard-coding +== "ended"+. # - # Grounded in +signalwire/relay/constants.py+ (+CALL_STATES+) — the same - # closed, server-emitted lifecycle the Python reference enumerates. +ended+ + # The set is closed — these are the only states the server emits. +ended+ # is the one terminal state (the call is gone; {Call#wait_for_ended} # resolves on it). module CallState @@ -93,13 +92,11 @@ def self.valid?(state) DIAL_STATE_ANSWERED = 'answered' DIAL_STATE_FAILED = 'failed' - # Named, frozen view over the outbound-dial vocabulary. Unlike call/message - # states, the reference exposes *no* flat dial-state constants — the values - # are grounded in +signalwire/relay/client.py+'s - # +_handle_dial_event+ docstring ("``dial_state`` — ``dialing`` | - # ``answered`` | ``failed``") and the mock dial-dance. This module names - # them (+DIAL_STATE_*+ above are the single source) and adds +ALL+ + - # +TERMINAL+ + +terminal?+. + # Named, frozen view over the outbound-dial vocabulary. The +dial_state+ + # field on a +calling.call.dial+ event carries exactly one of +dialing+, + # +answered+ or +failed+. This module names them (+DIAL_STATE_*+ above are + # the single source of the literals) and adds +ALL+ + +TERMINAL+ + + # +terminal?+. # # Both +answered+ and +failed+ are terminal: {Client#dial} resolves to a # {Call} on +answered+ and raises {RelayError} on +failed+; +dialing+ is @@ -182,9 +179,9 @@ def self.valid?(state) # source of the literals) with +ALL+ + +TERMINAL+ + +terminal?+, so callers # can ask +MessageState.terminal?(state)+ instead of re-deriving the set. # - # Grounded in +signalwire/relay/constants.py+: the terminal set is - # +MESSAGE_TERMINAL_STATES+ ({delivered, undelivered, failed}) — the same - # set the Python reference uses to resolve a sent message's final outcome. + # The terminal set is +MESSAGE_TERMINAL_STATES+ ({delivered, undelivered, + # failed}) — reaching any of the three resolves a sent message's final + # outcome. module MessageState QUEUED = MESSAGE_STATE_QUEUED INITIATED = MESSAGE_STATE_INITIATED diff --git a/lib/signalwire/relay/message.rb b/lib/signalwire/relay/message.rb index 028ed928..653990bb 100644 --- a/lib/signalwire/relay/message.rb +++ b/lib/signalwire/relay/message.rb @@ -104,9 +104,9 @@ def _set_on_completed(callback) # Register an event listener for state changes. # - # The handler is REQUIRED, matching the reference - # (``Message.on(self, handler: Callable[[RelayEvent], Any])``). Ruby's - # block IS the handler; supplying neither registers nothing and raises. + # A handler is REQUIRED: pass a callable taking the {RelayEvent}, or a + # block, which IS the handler. Supplying neither registers nothing and + # raises ArgumentError. def on_event(handler, &block) callback = block || handler raise ArgumentError, 'on_event requires a handler (block or callable)' if callback.nil? diff --git a/lib/signalwire/rest/http_client.rb b/lib/signalwire/rest/http_client.rb index 52a46ebe..7939835e 100644 --- a/lib/signalwire/rest/http_client.rb +++ b/lib/signalwire/rest/http_client.rb @@ -136,8 +136,7 @@ class HttpClient # REST client User-Agent. The product token stays stable at # `signalwire-ruby`; the version segment is the real SDK version so it can - # never drift from a hardcoded literal. Mirrors the Python reference fix - # (rest/_base.py `_user_agent`) — SDK_BUG_LEDGER P1: the old + # never drift from a hardcoded literal. The old # `signalwire-agents-ruby-rest/1.0` was both the wrong product token and a # stale `/1.0` while the package was at 3.x. USER_AGENT = "signalwire-ruby/#{SignalWire::VERSION}".freeze @@ -274,7 +273,7 @@ def delete(path, request_options: nil) # -> http://; every other host is the real platform over https://. This lets # a shipped example run verbatim against a local mock without a separate # base_url knob, and a dev host:port never mangles into - # "myspace:8917.signalwire.com". Mirrors python rest/_base.py. + # "myspace:8917.signalwire.com". def derive_base_url(space, base_url) base_url = ENV.fetch('SIGNALWIRE_REST_BASE_URL', nil) if base_url.nil? || base_url.empty? return base_url.sub(%r{/$}, '') if base_url && !base_url.empty? @@ -526,9 +525,8 @@ def _path(*parts) end end - # Read-only resource with get/list. Mirrors Python's - # +signalwire.rest._base.ReadResource+: the read half of the CRUD surface, - # extended by CrudResource with create/update/delete. + # Read-only resource with get/list — the read half of the CRUD surface, + # extended by {CrudResource} with create/update/delete. class ReadResource < BaseResource # List this resource's collection — ONE raw page, exactly as the server # returned it. Use {#paginate} to walk every page. @@ -551,7 +549,7 @@ def list(request_options: nil, **params) # Wires the resource layer to the tested +PaginatedIterator+ (which walks # +resp["data"]+ and follows +resp["links"]["next"]+), so callers no # longer hand-construct the path + token loop. Returns an Enumerable - # +PaginatedIterator+ — the Ruby idiom for Python's returned iterator. + # +PaginatedIterator+. def paginate(request_options: nil, **params) PaginatedIterator.new(@http, @base_path, params.empty? ? nil : params, 'data', request_options) @@ -575,8 +573,7 @@ class CrudResource < ReadResource # (CallFlowsResource, ConferenceRoomsResource, CxmlApplicationsResource, # SubscribersResource) would otherwise fall back to 'PATCH' and send the # wrong verb to PUT-only routes. Walk the ancestor chain so the nearest - # ancestor that set it wins — mirroring Python's inherited class attribute - # `_update_method`. + # ancestor that set it wins. def self.update_method return @update_method if defined?(@update_method) && @update_method @@ -624,8 +621,7 @@ def delete(resource_id, request_options: nil) end # CRUD resource that also supports listing the addresses bound to a - # resource. Mirrors Python's +signalwire.rest._base.CrudWithAddresses+: - # it adds a single +list_addresses+ helper on top of the standard + # resource. It adds a single +list_addresses+ helper on top of the standard # list/create/get/update/delete surface, issuing # +GET {base_path}/{resource_id}/addresses+. class CrudWithAddresses < CrudResource diff --git a/lib/signalwire/rest/pagination.rb b/lib/signalwire/rest/pagination.rb index 29751dc1..824ab874 100644 --- a/lib/signalwire/rest/pagination.rb +++ b/lib/signalwire/rest/pagination.rb @@ -5,17 +5,17 @@ module SignalWire module REST # Iterates items across paginated API responses. # - # Mirrors the Python PaginatedIterator (signalwire.rest._pagination): - # the constructor records http/path/params/data_key without fetching; - # iteration walks pages by following the +links.next+ cursor. + # The constructor records http/path/params/data_key without fetching; the + # first page is only requested when iteration begins. Iteration walks pages + # by following the +links.next+ cursor. # # Usage: # iter = SignalWire::REST::PaginatedIterator.new(http, '/api/path', # params: {}, data_key: 'data') # iter.each { |item| ... } # - # The iterator is single-pass (matching Python's __next__ semantics); - # use #to_a to collect every item across all pages. + # The iterator is single-pass — once consumed it does not rewind; use + # #to_a to collect every item across all pages. class PaginatedIterator include Enumerable @@ -36,7 +36,7 @@ def initialize(http, path, params = nil, data_key = 'data', request_options = ni @data_key = data_key # Per-request options (timeout / connect_timeout / headers) forwarded to # every page fetch, so pagination honors the same request contract as a - # single call. Mirrors Python _pagination.py's +request_options+ thread. + # single call. @request_options = request_options @items = [] @index = 0 @@ -44,8 +44,7 @@ def initialize(http, path, params = nil, data_key = 'data', request_options = ni # Cycle guard: +links.next+ cursors already followed. A server that keeps # returning the SAME +next+ would otherwise loop forever (the empty-page # fix terminates only on an ABSENT next link, so a repeating next became - # an infinite loop). Seeing a repeat terminates iteration. Mirrors the - # python reference (_pagination.py _seen_next). + # an infinite loop). Seeing a repeat terminates iteration. @seen_next = {} end @@ -65,21 +64,18 @@ def each end end - # Python iterator-protocol parity. Python's PaginatedIterator exposes - # +__iter__+ (returns self) and +__next__+ (advances one item, raising - # +StopIteration+ when exhausted). Ruby's idiomatic surface is +#each+ / - # +#next_item+, but we expose these thin aliases so the protocol shape - # matches the Python reference one-to-one. + # +__iter__+ / +__next__+ are thin compatibility aliases over the + # idiomatic +#each+ / +#next_item+ surface, for callers driving the + # iterator one step at a time by that spelling. Prefer +#each+. - # Equivalent of Python's +__iter__+: returns the iterator itself. + # Returns the iterator itself. def __iter__ self end - # Equivalent of Python's +__next__+: returns the next item across pages, - # raising +StopIteration+ when the iterator is exhausted (mirroring - # Python's raise-StopIteration contract rather than the +:__stop__+ - # sentinel used internally by +#each+). + # Returns the next item across pages, raising +StopIteration+ when the + # iterator is exhausted — as opposed to the +:__stop__+ sentinel + # {#next_item} returns and +#each+ uses internally. def __next__ item = next_item raise StopIteration if item == :__stop__ @@ -87,9 +83,10 @@ def __next__ item end - # Equivalent of Python's __next__. Returns the sentinel +:__stop__+ - # when exhausted (Ruby has no StopIteration error idiom for plain - # Enumerable), but the public surface is +#each+. + # Advance one item, fetching the next page when the buffered one runs + # out. Returns the sentinel +:__stop__+ when exhausted rather than + # raising, so a plain Enumerable loop can test for it. The public + # surface is +#each+. def next_item while @index >= @items.length return :__stop__ if @done @@ -118,14 +115,13 @@ def fetch_next # +links.next+ (more pages exist) while returning zero items on THIS # page — e.g. a filtered page that matches nothing here. The old # +next_url && !data.empty?+ condition stopped on such a page and - # silently dropped every subsequent page. Mirrors the Python reference - # fix (_pagination.py, #58). + # silently dropped every subsequent page. advance_or_finish((resp['links'] || {})['next']) end # Advance to the next page, or terminate. A +next+ we have already followed # (repeating cursor) or an absent +next+ both terminate — the cycle guard - # prevents an infinite re-fetch loop. Mirrors python _pagination.py _seen_next. + # prevents an infinite re-fetch loop. def advance_or_finish(next_url) if next_url && !@seen_next.key?(next_url) @seen_next[next_url] = true diff --git a/lib/signalwire/rest/request_options.rb b/lib/signalwire/rest/request_options.rb index 63a559d0..7db8dd05 100644 --- a/lib/signalwire/rest/request_options.rb +++ b/lib/signalwire/rest/request_options.rb @@ -79,9 +79,8 @@ def merge(override) # built-in floor. +nil+ on any field inherits the next level down; the # result has every field concrete. Returns an {EffectiveOptions}. # - # A module-level operation (mirrors the reference's module function - # +signalwire.rest._request_options.resolve+); exposed as a class method so - # the Ruby call site reads +RequestOptions.resolve(...)+. + # A stateless operation, exposed as a class method so the call site + # reads +RequestOptions.resolve(...)+. def self.resolve(client_default, per_request) merged = (client_default || RequestOptions.new).merge(per_request) EffectiveOptions.new( @@ -94,10 +93,9 @@ def self.resolve(client_default, per_request) end # Whether an HTTP +status+ for +method+ should trigger a retry, given the - # resolved +opts+ ({EffectiveOptions}). A module-level operation (mirrors - # the reference's module function - # +signalwire.rest._request_options.status_is_retryable+); delegates to the - # resolved options so the idempotency asymmetry lives in one place. + # resolved +opts+ ({EffectiveOptions}). A stateless operation; delegates + # to the resolved options so the idempotency asymmetry lives in one + # place. def self.status_is_retryable(method, status, opts) opts.status_retryable?(method, status) end diff --git a/lib/signalwire/runtime.rb b/lib/signalwire/runtime.rb index 5ac3c9c4..6ba77fe9 100644 --- a/lib/signalwire/runtime.rb +++ b/lib/signalwire/runtime.rb @@ -11,9 +11,6 @@ module SignalWire # Detects the execution environment (plain server, AWS Lambda, CGI, # Google Cloud Functions, Azure Functions) by inspecting well-known # environment variables set by each platform. - # - # This is the Ruby counterpart to the Python SDK's - # +signalwire.core.logging_config.get_execution_mode+. module Runtime MODES = %i[server lambda cgi google_cloud_function azure_function unknown].freeze @@ -58,7 +55,7 @@ def self.execution_mode # line is a bare `agent.run` — swaig-test (--file / --list / exec / # --simulate-serverless) sets it before Kernel.load. Unset (the normal case), # `run`/`serve` behave exactly as before, so an example still serves when run - # directly. (ruby_R5 N1.) + # directly. def self.suppress_run? env_present?('SIGNALWIRE_SUPPRESS_RUN') end diff --git a/lib/signalwire/security/security_utils.rb b/lib/signalwire/security/security_utils.rb index a3ad1db0..d3d648bf 100644 --- a/lib/signalwire/security/security_utils.rb +++ b/lib/signalwire/security/security_utils.rb @@ -7,23 +7,18 @@ # # Standalone security hygiene utilities. # -# These mirror the TypeScript SDK's ``SecurityUtils`` (filterSensitiveHeaders, -# redactUrl, isValidHostname) and the Python reference's -# ``signalwire.core.security.security_utils`` free functions, so the same -# protections -- keeping credentials out of user callbacks and logs, reusable -# hostname validation -- are available in every port. +# Three stateless helpers -- filter_sensitive_headers, redact_url and +# is_valid_hostname -- that keep credentials out of user callbacks and logs and +# provide reusable hostname validation. module SignalWire # Security — webhook signature validation, session tokens and request hardening. module Security # Stateless security hygiene helpers exposed as module functions. # - # The three public entry points project onto the Python free functions - # ``signalwire.core.security.security_utils.{filter_sensitive_headers, - # redact_url, is_valid_hostname}`` via the Ruby->Python module override in - # scripts/enumerate_surface.rb + scripts/enumerate_signatures.py. The - # ``SENSITIVE_HEADERS`` set + regexes are internal (not on the public - # surface; the Python reference doesn't export them either). + # The public entry points are {filter_sensitive_headers}, {redact_url} and + # {is_valid_hostname}. The ``SENSITIVE_HEADERS`` set and the regexes are + # internal — not part of the public surface, and subject to change. module SecurityUtils # Header names whose values are credentials/secrets and must never be # handed to user callbacks or written to logs. Compared case-insensitively. diff --git a/lib/signalwire/security/session_manager.rb b/lib/signalwire/security/session_manager.rb index 5cec48ba..d7cb2509 100644 --- a/lib/signalwire/security/session_manager.rb +++ b/lib/signalwire/security/session_manager.rb @@ -25,27 +25,23 @@ module Security # class SessionManager # When set true, {#debug_token} decodes token internals instead of - # returning +{ "error" => "debug mode not enabled" }+. Mirrors the - # Python reference's +_debug_mode+ attribute (off by default). Exposed - # as a writer only — there is no corresponding reader on the Python - # surface, so none is projected here. + # returning +{ "error" => "debug mode not enabled" }+. Off by default, + # and a writer only — the flag is deliberately not readable back. attr_writer :debug_mode # @return [String] the hex-encoded HMAC secret in use — the caller-supplied # +secret_key:+, or the +SecureRandom.hex(32)+ value generated when none - # was given. The reference exposes the same attribute - # (`self.secret_key`, core/security/session_manager.py) and keys every - # HMAC with this STRING's bytes, so reading it back is what lets a caller - # verify or reproduce a token minted elsewhere (cross-port interop). + # was given. Every HMAC is keyed with this STRING's bytes, so reading it + # back is what lets a caller verify or reproduce a token minted + # elsewhere. # @return [Integer] +token_expiry_secs+: the clamped lifetime tokens are - # minted with. Also a public reference attribute; a caller that passes a - # lifetime must be able to read the value actually in force (the clamp - # means the stored value is not always the value passed). + # minted with. A caller that passes a lifetime must be able to read the + # value actually in force (the clamp means the stored value is not + # always the value passed). attr_reader :secret_key, :token_expiry_secs # @param token_expiry_secs [Integer] seconds until tokens expire - # (default: 900 — 15 minutes; minimum 1). Matches the reference - # (+core/security/session_manager.py+ +__init__+). + # (default: 900 — 15 minutes; minimum 1). # @param secret_key [String, nil] hex-encoded secret; generated if omitted def initialize(token_expiry_secs: 900, secret_key: nil) @token_expiry_secs = [token_expiry_secs, 1].max @@ -68,20 +64,18 @@ def create_token(function_name, call_id) nonce = SecureRandom.hex(8) signature = compute_hmac("#{call_id}:#{function_name}:#{expiry}:#{nonce}") token_raw = "#{call_id}.#{function_name}.#{expiry}.#{nonce}.#{signature}" - # PADDED urlsafe Base64 — the reference is +base64.urlsafe_b64encode+, which - # KEEPS the '=' padding, and its +validate_token+ decodes with - # +urlsafe_b64decode+, which RAISES on a stripped '='. +padding: false+ made - # every token this port minted unusable to the reference (and to any port that - # decodes strictly) even though the message and HMAC were correct. Our own - # +validate_token+ still accepted them, because +urlsafe_decode64+ tolerates - # missing padding on urlsafe input — that asymmetry is why round-tripping - # against ourselves could not catch it, and why TOKEN-INTEROP validates against - # the REFERENCE decoder instead. + # PADDED urlsafe Base64 — the '=' padding MUST be kept. A strict decoder + # raises on a stripped '=', so +padding: false+ here would make every + # token this SDK mints unusable to any such consumer even though the + # message and HMAC are correct. Ruby's own +urlsafe_decode64+ tolerates + # missing padding on urlsafe input, so {#validate_token} would still + # accept them — that asymmetry means round-tripping a token through this + # class cannot catch the bug. Do not "tidy" the padding away. Base64.urlsafe_encode64(token_raw) end - alias generate_token create_token # Python-surface name for minting. - alias create_tool_token create_token # Python back-compat alias. + alias generate_token create_token # Alternate public name for minting. + alias create_tool_token create_token # Back-compat alias. # Validate a function-call token. # @@ -111,35 +105,33 @@ def validate_token(function_name, token, call_id) false end - alias validate_tool_token validate_token # Python back-compat alias. + alias validate_tool_token validate_token # Back-compat alias. # Return the given +call_id+, or generate a new URL-safe session # identifier when none is supplied. # - # Matches the Python reference's stateless +create_session+: the SDK - # does not persist sessions, it just mints an identifier callers can - # thread through subsequent token operations. + # Stateless: the SDK does not persist sessions, it just mints an + # identifier callers can thread through subsequent token operations. # # @param call_id [String, nil] existing call ID to reuse # @return [String] the resolved call ID def create_session(call_id = nil) return call_id unless _blank?(call_id) - # token_urlsafe(16) in Python yields ~22 url-safe chars from 16 bytes. + # 16 random bytes, unpadded — ~22 url-safe characters. Base64.urlsafe_encode64(SecureRandom.bytes(16), padding: false) end - # Legacy lifecycle hook retained for API compatibility with the Python - # reference. The session manager is stateless with respect to - # activation, so this accepts the call ID and reports success. + # Legacy lifecycle hook retained for API compatibility. The session + # manager is stateless with respect to activation, so this accepts the + # call ID and reports success. # # @param _call_id [String] # @return [Boolean] always +true+ def activate_session(_call_id) = true - # Legacy lifecycle hook retained for API compatibility with the Python - # reference. Clears any metadata accumulated for the session and - # reports success. + # Legacy lifecycle hook retained for API compatibility. Clears any + # metadata accumulated for the session and reports success. # # @param call_id [String] # @return [Boolean] always +true+ @@ -150,10 +142,9 @@ def end_session(call_id) # Fetch the metadata hash stored for +call_id+. # - # The Python reference is stateless and always returns +{}+; this port - # keeps a real per-session store (matching the TypeScript port) so the - # getter/setter pair round-trips, but still returns an empty hash for - # unknown sessions — callers never get +nil+. + # A real per-session store backs this, so the getter/setter pair + # round-trips. An unknown session yields an empty hash — callers never + # get +nil+. # # @param call_id [String] # @return [Hash] the session's metadata, or +{}+ if none is stored @@ -161,10 +152,8 @@ def end_session(call_id) def get_session_metadata(call_id) = (@session_metadata[call_id] || {}).dup # Store a single +key+/+value+ pair in +call_id+'s metadata, merging - # with anything already recorded for that session. - # - # Signature mirrors the Python reference's - # +set_session_metadata(call_id, key, value)+. + # with anything already recorded for that session. All three arguments + # are positional. # # @param call_id [String] # @param key [String] @@ -178,9 +167,8 @@ def set_session_metadata(call_id, key, value) # Decode a token's components for inspection WITHOUT validating it. # # Requires {#debug_mode=} to have been set +true+; otherwise returns - # +{ "error" => "debug mode not enabled" }+, matching the Python - # reference. The returned structure mirrors Python's nested - # +components+/+status+ shape (call_id and signature truncated to + # +{ "error" => "debug mode not enabled" }+. The success shape is a + # nested +components+/+status+ pair (call_id and signature truncated to # 8 chars + "..." when longer). # # @param token [String] @@ -259,8 +247,8 @@ def _token_fields_valid?(parts, function_name, call_id) Integer(token_expiry) >= Time.now.to_i end - # Truncate +str+ to "first8..." when longer than 8 chars, mirroring the - # Python reference's debug-output redaction for call_id and signature. + # Truncate +str+ to "first8..." when longer than 8 chars — the + # debug-output redaction applied to call_id and signature. def truncate(str) = str.length > 8 ? "#{str[0, 8]}..." : str # Compute HMAC-SHA256 of +message+ using the instance secret key. diff --git a/lib/signalwire/security/webhook_middleware.rb b/lib/signalwire/security/webhook_middleware.rb index 42c1f759..af707326 100644 --- a/lib/signalwire/security/webhook_middleware.rb +++ b/lib/signalwire/security/webhook_middleware.rb @@ -139,9 +139,9 @@ def call(env) env[RAW_BODY_ENV_KEY] = raw_body url = reconstruct_url(env) - # Delegate the pass/reject decision to the framework-free decomposed - # core (the cross-port contract). It returns nil to pass or a Rack - # [status, headers, body] triple to reject. + # Delegate the pass/reject decision to the framework-free {validate} + # core. It returns nil to pass, or a Rack [status, headers, body] + # triple to reject. rejection = self.class.validate( env['REQUEST_METHOD'].to_s, url, rack_signature_headers(env), raw_body, signing_key: @signing_key diff --git a/lib/signalwire/server/agent_server.rb b/lib/signalwire/server/agent_server.rb index e20ebe34..065463ff 100644 --- a/lib/signalwire/server/agent_server.rb +++ b/lib/signalwire/server/agent_server.rb @@ -84,15 +84,14 @@ def initialize(host: '0.0.0.0', port: 3000, log_level: 'info') apply_log_level(@logger, @log_level) end - # Map a Python-style log level string to the underlying logger's - # threshold. Mirrors Python's ``log_level`` mapping in AgentServer - # so callers get equivalent verbosity controls. + # Apply a lowercase level-name String (see {#map_log_level}) to the + # underlying logger's threshold. # # The SignalWire stdlib logger doesn't expose a per-instance # ``level=``; we attach a ``@level`` ivar to the underlying # ``Logger`` so introspection-style tests can check it. The # ``::Logger`` constant from Ruby's stdlib (``require 'logger'``) - # exposes DEBUG/INFO/WARN/ERROR/FATAL constants we mirror. + # supplies the DEBUG/INFO/WARN/ERROR/FATAL constants used here. # @api private def apply_log_level(logger, level) require 'logger' @@ -120,7 +119,8 @@ def set_logger_level(logger, mapped) end end - # Map a Python-style log level string to a ::Logger constant. + # Map a lowercase level-name String ('debug', 'info', 'warning'/'warn', + # 'error', 'critical'/'fatal') to a ::Logger constant. # 'info' and the else fallback both map to INFO; the explicit 'info' arm # documents it as a known level rather than an unrecognized default. # @api private @@ -201,10 +201,9 @@ def setup_sip_routing(route: '/sip', auto_map: true) # @param callback_fn [#call, nil] the routing callback (Proc/lambda) # @param path [String] the path to register the callback at # @return [self] - # ``callback_fn`` and ``path`` are both REQUIRED, matching the reference - # (``register_global_routing_callback(callback_fn, path)``). The block is the - # idiomatic spelling of ``callback_fn``; pass ``nil`` in its slot when using - # the block form. + # ``callback_fn`` and ``path`` are both REQUIRED positionals. The block is + # the idiomatic spelling of ``callback_fn``; pass ``nil`` in its slot when + # using the block form. def register_global_routing_callback(callback_fn, path, &block) callback = block || callback_fn raise ArgumentError, 'a callback (block or callable) is required' if callback.nil? @@ -255,8 +254,7 @@ def serve_static_files(directory, route = '/') self end - # Universal run method — mirrors Python's - # ``AgentServer.run(event=None, context=None, host=None, port=None)``. + # Universal run method. All four keywords are optional and default to nil. # # Detects execution mode and routes appropriately: # @@ -540,8 +538,8 @@ def static_file_response(resolved) end # Internal helpers (formerly leading-underscore by convention). Not part of - # the public/Python surface — declared private so the cross-port surface - # enumerator continues to exclude them. + # the public surface — declared private so the surface enumerator continues + # to exclude them. private :apply_log_level, :set_logger_level, :map_log_level, :run_server, :build_webrick, :handle_cgi_request, :format_cgi_response, :body_to_string, :handle_lambda_request, :lambda_env, :lambda_path, diff --git a/lib/signalwire/skills/builtin/claude_skills.rb b/lib/signalwire/skills/builtin/claude_skills.rb index 1a32c03b..075f6318 100644 --- a/lib/signalwire/skills/builtin/claude_skills.rb +++ b/lib/signalwire/skills/builtin/claude_skills.rb @@ -12,8 +12,7 @@ module Skills module Builtin # Loads Claude SKILL.md files as agent tools. # - # Mirrors the Python reference (`skills/claude_skills/skill.py`): the - # `skills_path` load-path is validated (exists + is a directory), then + # The `skills_path` load-path is validated (exists + is a directory), then # each SUBDIRECTORY containing a `SKILL.md` file is discovered, its YAML # frontmatter parsed for `name`/`description`, and one SWAIG tool is # registered per discovered skill. A loose `.md` file that is NOT a @@ -39,8 +38,8 @@ def supports_multiple_instances? = true # # @return [Boolean] true when the skill is ready to run def setup - # Load-path validation (Python parity: validate_packages then the - # skills_path exists/is-a-directory checks). + # Load-path validation, in order: validate_packages first, then the + # skills_path exists/is-a-directory checks. return false unless validate_packages read_params @@ -132,10 +131,10 @@ def skill_tool(skill) } end - # Discover skill DIRECTORIES (each containing a SKILL.md), mirroring - # Python's `_discover_skills`: iterate the immediate subdirectories of - # skills_path, keep those with a SKILL.md, apply include/exclude - # patterns against the directory name, and parse the frontmatter. + # Discover skill DIRECTORIES (each containing a SKILL.md): iterate the + # immediate subdirectories of skills_path, keep those with a SKILL.md, + # apply include/exclude patterns against the directory name, and parse + # the frontmatter. def discover_skills Dir.children(@skills_path).sort.filter_map do |entry| dir = File.join(@skills_path, entry) @@ -151,8 +150,9 @@ def discover_skills [] end - # Include/exclude glob-pattern gate against a skill directory name, - # mirroring Python's `_matches_patterns` (excludes win, then includes). + # Include/exclude glob-pattern gate against a skill directory name. + # Excludes are applied first and win; an entry must then match an + # include pattern. def matches_patterns?(dir_name) return false if @exclude.any? { |pat| File.fnmatch(pat, dir_name) } @@ -160,8 +160,8 @@ def matches_patterns?(dir_name) end # Build a skill entry from a SKILL.md, parsing YAML frontmatter for - # name/description and falling back to the directory name. Mirrors - # Python's `_parse_skill_md` name-fallback behavior. + # name/description and falling back to the directory name when the + # frontmatter carries no `name`. def skill_entry(dir_name, skill_file) front, body = parse_skill_md(skill_file) skill_name = front['name'] || dir_name @@ -174,8 +174,8 @@ def skill_entry(dir_name, skill_file) } end - # Split a SKILL.md into (frontmatter_hash, body). No frontmatter => - # ({}, whole content). Mirrors Python's `---`-delimited split. + # Split a SKILL.md into (frontmatter_hash, body) on the `---` delimiter. + # No frontmatter => ({}, whole content). def parse_skill_md(path) content = File.read(path, encoding: 'UTF-8') return [{}, content.strip] unless content.start_with?('---') diff --git a/lib/signalwire/skills/builtin/mcp_gateway.rb b/lib/signalwire/skills/builtin/mcp_gateway.rb index e7a542cf..3388bce1 100644 --- a/lib/signalwire/skills/builtin/mcp_gateway.rb +++ b/lib/signalwire/skills/builtin/mcp_gateway.rb @@ -27,10 +27,9 @@ module Builtin # services + tools, and registers each MCP tool as a SWAIG function whose # handler proxies the call back through the gateway. # - # Mirrors the Python reference - # (``signalwire.skills.mcp_gateway.skill.MCPGatewaySkill``). The Python-only - # SERVER half (``signalwire.mcp_gateway.*`` — the subprocess + sandbox - # daemon) is deliberately NOT ported; see PORT_PHILOSOPHY_RUBY.md. + # This SDK ships the client half only. Running the gateway service itself + # (the subprocess + sandbox daemon that hosts MCP servers) is out of + # scope here; point this skill at an already-running gateway. class MCPGatewaySkill < SkillBase # The name this skill is added under (`agent.add_skill('mcp_gateway')`). # @@ -50,10 +49,8 @@ def version = '1.0.0' # for basic auth, plus a gateway_url that passes SSRF validation and a # reachable ``/health`` endpoint. # - # Mirrors the Python reference, which has NO constructor override — all - # config is read here (and lazily by the hook accessors via - # {#ensure_config}), so the port carries no ``__init__`` the reference - # lacks. + # There is no constructor override: all config is read here, and lazily + # by the hook accessors via {#ensure_config}. def setup read_config return false unless valid_auth? @@ -112,7 +109,7 @@ def get_prompt_sections [integration_prompt_section(descriptions)] end - # Config schema for GUI / validation. Mirrors the Python reference. + # Config schema for GUI / validation. def get_parameter_schema auth_params_schema .merge(services_param_schema) @@ -182,7 +179,7 @@ def ensure_config # Read every config param off @params (with defaults). Called from # #setup and (lazily) from the hook accessors so the ivars are always - # populated. Matches the Python reference, which reads config in setup(). + # populated. def read_config @config_read = true read_auth_config diff --git a/lib/signalwire/skills/builtin/native_vector_search.rb b/lib/signalwire/skills/builtin/native_vector_search.rb index 82a90f5b..56b8edcf 100644 --- a/lib/signalwire/skills/builtin/native_vector_search.rb +++ b/lib/signalwire/skills/builtin/native_vector_search.rb @@ -13,7 +13,8 @@ module SignalWire module Skills # Builtin — the skills that ship with the SDK, registered by name at load time. module Builtin - # Network/remote mode only (as per porting manifest). + # Vector search against a remote search service. Network/remote mode + # only — there is no local-index mode. class NativeVectorSearchSkill < SkillBase # The name this skill is added under (`agent.add_skill('native_vector_search')`). # @@ -124,8 +125,8 @@ def handle_search(args, _raw_data) # # @return [Net::HTTPResponse] def post_search(query, count) - # Python parity: POST to "/search" (the remote_url is - # a base URL; the /search endpoint is appended). + # POST to "/search" — the configured remote_url is a + # BASE url; the /search endpoint is appended. uri = URI(search_endpoint) params = { query: query, count: count, similarity_threshold: @threshold } params[:index_name] = @index_name if @index_name diff --git a/lib/signalwire/skills/builtin/spider.rb b/lib/signalwire/skills/builtin/spider.rb index cfaa2a11..9c24371b 100644 --- a/lib/signalwire/skills/builtin/spider.rb +++ b/lib/signalwire/skills/builtin/spider.rb @@ -37,9 +37,9 @@ def supports_multiple_instances? = true # Elements whose *entire subtree* is dropped before text extraction — # boilerplate that would otherwise pollute the extracted text. Spelled - # as XPath expressions to match the reference; {#strip_html} compiles - # each to the equivalent tag-with-content regex (Ruby has no bundled - # HTML tree parser, so there is no lxml-style +drop_tree+ to call). + # as XPath expressions; {#strip_html} compiles each to the equivalent + # tag-with-content regex (Ruby has no bundled HTML tree parser, so + # there is no tree-level drop to call). DEFAULT_REMOVE_XPATHS = [ '//script', '//style', @@ -84,8 +84,8 @@ def setup @tool_prefix = get_param('tool_name', default: '') @tool_prefix = "#{@tool_prefix}_" unless @tool_prefix.empty? @cache_enabled = get_param('cache_enabled', default: true) != false - # Response cache, mirroring Python's per-instance fetch cache. Held as - # state so #cleanup has something concrete to tear down. + # Per-instance fetch cache. Held as state so #cleanup has something + # concrete to tear down. @cache = @cache_enabled ? {} : nil true end @@ -262,7 +262,7 @@ def cache_hit?(url) end # SPIDER_BASE_URL redirects every fetch through a configured host - # (used by audit_skills_dispatch.py to point the skill at a loopback + # (used by the skills-dispatch audit to point the skill at a loopback # fixture). The path/query of the user-supplied URL is preserved so # the audit can match on it. def redirect_url(url) diff --git a/lib/signalwire/skills/builtin/swml_transfer.rb b/lib/signalwire/skills/builtin/swml_transfer.rb index 1cac5d5d..eac207da 100644 --- a/lib/signalwire/skills/builtin/swml_transfer.rb +++ b/lib/signalwire/skills/builtin/swml_transfer.rb @@ -141,7 +141,7 @@ def read_transfer_params end # Fills in default fields on a transfer config. Returns false when the - # config is invalid (mirrors the Python validation that fails setup). + # config is invalid, which fails skill setup. def normalize_transfer_config(config) return false unless config.is_a?(Hash) return false unless config.key?('url') || config.key?('address') diff --git a/lib/signalwire/skills/builtin/web_search.rb b/lib/signalwire/skills/builtin/web_search.rb index 38fd4f8d..c78f6791 100644 --- a/lib/signalwire/skills/builtin/web_search.rb +++ b/lib/signalwire/skills/builtin/web_search.rb @@ -34,7 +34,7 @@ def run_search(query) processed = scrape_candidates(query, results, deadline_at) # Time ran out or every page was below quality threshold: fall back to - # snippet-only results so we return SOMETHING useful (Python parity). + # snippet-only results so we return SOMETHING useful. return format_snippet_results(query, results, num_results) if processed.empty? wrap_response(format_scraped_results(query, processed)) @@ -100,8 +100,7 @@ def scrape_parallel(query, results, deadline_at) end # Fetch + score one candidate. Returns an enriched hash or nil (empty - # page / below the quality threshold / past the deadline). Mirrors - # Python's _scrape_one closure. + # page / below the quality threshold / past the deadline). def scrape_one(query, result, deadline_at) return nil if monotonic_now >= deadline_at @@ -127,7 +126,7 @@ module WebPageFetcher # Fetch a page and extract meaningful text, bounded by per_page_timeout # (Net::HTTP open_timeout/read_timeout). Returns the text, or nil on any - # failure. Mirrors Python's GoogleSearchScraper.extract_text_from_url. + # failure. def extract_text_from_url(url) uri = URI(url) return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS) @@ -163,9 +162,9 @@ def strip_html(body) .strip end - # Lightweight content-quality heuristic. Mirrors the spirit of Python's - # _calculate_content_quality: longer, query-relevant text scores higher. - # Returns a hash with at least 'quality_score' and 'domain'. + # Lightweight content-quality heuristic: longer, query-relevant text + # scores higher. Returns a hash with at least 'quality_score' and + # 'domain'. def calculate_content_quality(text, url, query) length = text.length # Length component: saturates around ~2000 chars. @@ -199,7 +198,7 @@ def query_relevance(text, query) # when snippets_only is true, or as a graceful fallback when page # scraping is abandoned by the overall_deadline. Always non-empty when # CSE returned anything at all, so the kernel never sees a webhook - # timeout. Mirrors Python's _format_snippet_results. + # timeout. def format_snippet_results(query, results, num_results) return no_results_msg if results.empty? @@ -252,9 +251,9 @@ def google_search(query, num) end # Build the Google CSE request URI. WEB_SEARCH_BASE_URL overrides the - # host for tests and the audit fixture (matches the Rust SDK — env var - # is the *host*, the `/customsearch/v1` path is appended so the audit - # can match on `customsearch` in req.path). + # host for tests and the audit fixture. The env var is the *host*; the + # `/customsearch/v1` path is appended, so a fixture can match on + # `customsearch` in req.path. def google_search_uri(query, num) base = resolved_base_url('WEB_SEARCH_BASE_URL', 'https://www.googleapis.com') uri = URI("#{base}/customsearch/v1") @@ -267,13 +266,14 @@ def google_search_uri(query, num) # Private mixin: {WebSearchSkill}'s param parsing + SWAIG parameter-schema # builders + prompt-section bullets. The description constants are - # wire-load-bearing (match the Python reference). Extracted to keep the - # skill class within the size budget. + # wire-load-bearing — they ship in the SWAIG schema the model reads, so + # editing them changes agent behaviour. Extracted to keep the skill class + # within the size budget. module WebSearchConfig DEFAULT_NO_RESULTS_MESSAGE = "I couldn't find quality results for that query. Try rephrasing your search." - # SWAIG parameter-schema descriptions (wire-load-bearing — match Python). + # SWAIG parameter-schema descriptions (wire-load-bearing). PER_PAGE_TIMEOUT_DESC = 'Maximum seconds to wait on a single page scrape.' OVERALL_DEADLINE_DESC = 'Wall-clock budget in seconds for the whole tool call. In-flight scrapes are ' \ @@ -352,14 +352,13 @@ def read_core_params # Optional prefix/postfix wrapped around every non-empty search # result. Use these to give the calling agent a mechanical cue # (e.g. "tell the user this came from a public web search") - # without needing prompt-side rules. Mirrors Python parity. + # without needing prompt-side rules. @response_prefix = get_param('response_prefix', default: '') @response_postfix = get_param('response_postfix', default: '') end # Latency-control parameters. The SignalWire kernel times out webhook # responses around 55s, so the handler MUST finish under that. - # Mirrors Python's web_search/skill.py (51101da + 295745b). # per_page_timeout: max seconds to wait on a single page scrape # (Net::HTTP open_timeout/read_timeout). # overall_deadline: wall-clock budget for the whole tool call. Once diff --git a/lib/signalwire/skills/builtin/wikipedia_search.rb b/lib/signalwire/skills/builtin/wikipedia_search.rb index ca00ba04..36511b13 100644 --- a/lib/signalwire/skills/builtin/wikipedia_search.rb +++ b/lib/signalwire/skills/builtin/wikipedia_search.rb @@ -125,8 +125,8 @@ def no_results_msg # Default to en.wikipedia.org host; WIKIPEDIA_BASE_URL overrides # for tests and the audit fixture. The env var is the *host*; the - # `/w/api.php` path is appended so audit_skills_dispatch can match - # on `api.php` in req.path. + # The `/w/api.php` path is appended so the skills-dispatch audit can + # match on `api.php` in the request path. def api_endpoint "#{resolved_base_url('WIKIPEDIA_BASE_URL', 'https://en.wikipedia.org')}/w/api.php" end diff --git a/lib/signalwire/skills/skill_base.rb b/lib/signalwire/skills/skill_base.rb index 8d4919ea..d7064e6c 100644 --- a/lib/signalwire/skills/skill_base.rb +++ b/lib/signalwire/skills/skill_base.rb @@ -64,7 +64,7 @@ def initialize(agent = nil, params = nil) end @agent = agent @params = (params || {}).transform_keys(&:to_s) - # Python: pop swaig_fields out of params for separate access. + # swaig_fields is removed from params and held separately. @swaig_fields = @params.delete('swaig_fields') || {} @logger = ::SignalWire::Logging.logger("signalwire.skills.#{logger_name_segment}") end @@ -78,8 +78,7 @@ def register_tools = [] # Define a SWAIG tool on the owning agent, automatically merging any # swaig_fields configured for this skill. Skills should use this instead - # of calling agent.define_tool directly. Mirrors Python - # SkillBase.define_tool(**kwargs). + # of calling agent.define_tool directly. # # @param name [String] tool name # @param description [String] tool description diff --git a/lib/signalwire/skills/skill_registry.rb b/lib/signalwire/skills/skill_registry.rb index e0e08924..2f11f783 100644 --- a/lib/signalwire/skills/skill_registry.rb +++ b/lib/signalwire/skills/skill_registry.rb @@ -100,12 +100,8 @@ def initialize # `SIGNALWIRE_SKILL_PATHS` environment variable (colon-separated, # deduped, registered paths first). # - # Mirrors the Python reference `SkillRegistry`, which appends - # `os.environ["SIGNALWIRE_SKILL_PATHS"]` (split on `os.pathsep`) to its - # registered `_external_paths` when resolving/discovering skills - # (`registry.py` `_load_skill_on_demand` + `get_all_skills_schema`). The - # env var is read on every call so a value set after construction still - # takes effect, matching Python's search-time read. + # The env var is read on every call, so a value set after construction + # still takes effect. # # @return [Array] def external_paths @@ -116,10 +112,8 @@ def external_paths # Add a directory to search for skills. # - # Mirrors Python's `SkillRegistry.add_skill_directory`: validate - # that the path exists and is a directory, then append it - # (de-duplicated) to `@external_paths`. Raises `ArgumentError` - # (the Ruby analog of Python's `ValueError`) for invalid input. + # Validates that the path exists and is a directory, then appends it + # (de-duplicated) to `@external_paths`. # # @param path [String] absolute or relative path to a directory # @return [void] @@ -136,13 +130,10 @@ def add_skill_directory(path) # Get complete schema for all registered skills (instance form). # - # Mirrors Python's instance-method - # ``SkillRegistry.get_all_skills_schema()`` — returns a hash keyed - # by skill name, each value containing parameter metadata. Ruby - # skills don't carry rich Python-style parameter introspection in - # v1, so the value defaults to a minimal shape with the skill - # name; built-ins that expose ``parameter_schema`` get richer - # detail. + # Returns a hash keyed by skill name, each value containing parameter + # metadata. Skills are not introspected for their parameters, so the + # value defaults to a minimal shape carrying just the skill name; + # built-ins that expose ``parameter_schema`` get richer detail. # # @return [Hash{String => Hash}] def get_all_skills_schema = self.class.get_all_skills_schema @@ -258,7 +249,7 @@ def list_skills = @mutex.synchronize { @factories.keys.dup } # available. # @api private def list_skills_full - register_builtins! # parity: Python auto-discovers builtins (idempotent) + register_builtins! # builtins are auto-discovered here (idempotent) @mutex.synchronize { @factories.keys.sort.map { |skill_name| skill_summary(skill_name) } } end @@ -273,11 +264,8 @@ def reset! = @mutex.synchronize { @factories.clear } # Directories named by the `SIGNALWIRE_SKILL_PATHS` environment variable # (path-separator-delimited, empty entries dropped). # - # Mirrors the Python reference, which reads - # `os.environ.get("SIGNALWIRE_SKILL_PATHS", "").split(os.pathsep)` and - # folds those directories into the skill search path (`registry.py:59` - # and `:387`). Read fresh on every call so a var set after startup still - # takes effect, matching Python's search-time read. + # These are folded into the skill search path. Read fresh on every + # call, so a var set after startup still takes effect. # # @return [Array] def env_skill_paths @@ -300,7 +288,7 @@ def register_builtins! # named set can never silently drift from what gets registered. # @return [Array] def builtin_skill_names = SkillName::ALL.dup - # Internal helper — not part of the Python surface; reached via + # Internal helpers — not part of the public surface; reached via # discover_skills / list_all_skill_sources. private :builtin_skill_names, :list_skills_full, :env_skill_paths @@ -339,17 +327,15 @@ def list_all_skill_sources(external_paths: []) # Get complete schema for all registered skills. # - # Mirrors Python's - # ``SkillRegistry.get_all_skills_schema()`` — returns a hash - # keyed by skill name, with each value containing parameter - # metadata. Ruby skills don't carry rich Python-style parameter - # introspection in v1, so the value defaults to a minimal shape - # with the skill name; built-in skills that expose - # ``parameter_schema`` get richer detail. + # Returns a hash keyed by skill name, with each value containing + # parameter metadata. Skills are not introspected for their + # parameters, so the value defaults to a minimal shape carrying just + # the skill name; built-in skills that expose ``parameter_schema`` + # get richer detail. # # @return [Hash{String => Hash}] def get_all_skills_schema - register_builtins! # parity: Python auto-discovers builtins here (idempotent) + register_builtins! # builtins are auto-discovered here (idempotent) @mutex.synchronize do @factories.keys.sort.to_h { |name| [name, skill_schema_entry(name)] } end diff --git a/lib/signalwire/swaig/function_result.rb b/lib/signalwire/swaig/function_result.rb index 856dd698..0faea759 100644 --- a/lib/signalwire/swaig/function_result.rb +++ b/lib/signalwire/swaig/function_result.rb @@ -15,13 +15,12 @@ module Swaig # Closed-set vocabularies for SWAIG verbs. # # Each constant's value IS the wire string, so a caller may pass the - # bare string (parity with the Python reference, which takes a plain - # +str+) or the named constant interchangeably — they are literally + # bare string or the named constant interchangeably — they are literally # the same object. The +FunctionResult+ validators below reference # these +ALL+ arrays directly, so the named set and the validated set # can never drift apart (single source of truth). # - # Idiom note: this mirrors +SignalWire::Relay+'s constants module + # Idiom note: these follow +SignalWire::Relay+'s constants module # (flat +NAME = 'value'+ string constants grouped into a frozen +ALL+ # array). These are SWAIG (SWML-verb) vocabularies and are deliberately # kept DISTINCT from the RELAY codecs/directions — see the warnings on @@ -41,8 +40,8 @@ module RecordFormat # Channel selection for the +record_call+ verb. # # DISTINCT from {TapDirection}: record uses +listen+, tap uses +hear+. - # Never share a constant between the two — Python validates two - # different lists, and conflating them is a known bug generator. + # Never share a constant between the two — each verb is validated against + # its OWN list, and conflating them is a known bug generator. module RecordDirection SPEAK = 'speak' LISTEN = 'listen' @@ -93,12 +92,13 @@ module Codec # class FunctionResult # Default +ai_response+ for +pay+ (extracted to keep the signature line - # within length limits; value is wire-load-bearing — mirrors Python). + # within length limits; the value is wire-load-bearing). PAY_DEFAULT_AI_RESPONSE = 'The payment status is ${pay_result}, do not mention anything else ' \ 'about collecting payment if successful.' - # Enum validations for +join_conference+, in Python's raise order. + # Enum validations for +join_conference+, in the order they are checked: + # the FIRST invalid value in this order is the one that raises. # Each entry: [opts_key, allowed_values, error_message]. JOIN_CONFERENCE_ENUMS = [ [:beep, %w[true false onEnter onExit], @@ -115,8 +115,8 @@ class FunctionResult # Spec for the non-default conference params, in exact wire-key order. # Each entry: [wire_key, opts_key, ->(value) { include? }]. Driving the - # build off this table keeps key insertion order byte-identical to the - # Python reference while staying flat (one loop, not 18 branches). + # build off this table pins the emitted key insertion order while staying + # flat (one loop, not 18 branches). JOIN_CONFERENCE_PARAM_SPEC = [ ['muted', :muted, ->(v) { v }], ['beep', :beep, ->(v) { v != 'true' }], @@ -815,9 +815,9 @@ def assign_present(target, pairs) target end - # Build the object-form +context_switch+ payload (key order matches - # the Python reference: system_prompt, user_prompt, consolidate, - # full_reset, isolated). + # Build the object-form +context_switch+ payload. Key order is + # wire-load-bearing: system_prompt, user_prompt, consolidate, + # full_reset, isolated. def build_context_switch_data(system_prompt, user_prompt, consolidate, full_reset, isolated) context_data = {} context_data['system_prompt'] = system_prompt if system_prompt @@ -843,8 +843,7 @@ def pay_swml_doc(ai_response, pay_params) end # Build the +pay+ verb params. Key order (the fixed block, then - # postal_code, then the optional tail) is wire-load-bearing and - # identical to the Python reference. + # postal_code, then the optional tail) is wire-load-bearing. def build_pay_params(payment_connector_url:, input_method:, payment_method:, timeout:, max_attempts:, security_code:, min_postal_code_length:, token_type:, currency:, language:, voice:, valid_card_types:, postal_code:, @@ -900,7 +899,7 @@ def parse_swml_string(swml_content) # Wrap a single SWAIG verb + params in the standard SWML envelope. # Key order (version, sections → main → [{verb => params}]) is - # wire-load-bearing and identical to the Python reference. + # wire-load-bearing. def swml_envelope(verb, params) { 'version' => '1.0.0', @@ -922,15 +921,16 @@ def response? @response && !@response.empty? end - # nil, or responds to #empty? and is empty (mirrors the Python - # truthiness checks used by +send_sms+). + # The blank test +send_sms+ applies to its arguments: nil, or responds to + # #empty? and is empty. (An empty String is truthy in Ruby, so a plain + # truthiness check would not do.) def sms_blank?(value) value.nil? || (value.respond_to?(:empty?) && value.empty?) end # @api private — the join_conference action. When every option is at its # default the wire value collapses to the bare conference NAME rather than a - # params object, matching the reference's emitted shape. + # params object. def join_conference_action(name, opts) validate_join_conference!(name, opts) join_params = if join_conference_all_defaults?(opts) @@ -941,14 +941,13 @@ def join_conference_action(name, opts) execute_swml(swml_envelope('join_conference', join_params)) end - # Validation order + message text mirror the Python reference - # (core/function_result.py::join_conference). Python renders its - # valid-value lists via an f-string over a Python list literal, i.e. - # "one of ['a', 'b']"; we reproduce that exact form. + # Validation order and message text are both load-bearing. Each + # valid-value list renders bracketed with single-quoted, comma-separated + # members — "one of ['a', 'b']" — so the message a caller sees is stable. def validate_join_conference!(name, opts) JOIN_CONFERENCE_ENUMS.each do |opts_key, allowed, message| - # max_participants is validated immediately after beep, mirroring - # the Python reference's raise order. + # max_participants is validated immediately after beep, before + # record — the order decides which error a caller sees first. validate_max_participants!(opts[:max_participants]) if opts_key == :record raise ArgumentError, message unless allowed.include?(opts[opts_key]) end diff --git a/lib/signalwire/swaig/swaig_function.rb b/lib/signalwire/swaig/swaig_function.rb index 548bf27f..90cde034 100644 --- a/lib/signalwire/swaig/swaig_function.rb +++ b/lib/signalwire/swaig/swaig_function.rb @@ -7,9 +7,8 @@ # # SWAIGFunction class for defining and managing SWAIG function interfaces. # -# Mirrors the Python reference signalwire.core.swaig_function.SWAIGFunction and -# the PHP SignalWire\SWAIG\SwaigFunction. A SWAIGFunction is exactly the same -# concept as a "tool" in native OpenAI / Anthropic tool calling: it holds a +# A SWAIGFunction is exactly the same concept as a "tool" in native +# OpenAI / Anthropic tool calling: it holds a # name/description/parameters/handler and renders into the tool schema sent to # the model. @@ -68,8 +67,7 @@ def initialize(name:, handler:, description:, parameters: nil, secure: false, # Call the underlying handler function. # - # Ruby analog of the Python reference's +__call__+ (makes the object - # callable). +function.call(args, raw_data)+ invokes the handler. + # +function.call(args, raw_data)+ invokes the handler. # # @return [Object] the handler's return value def call(*, **) diff --git a/lib/signalwire/swml/schema.rb b/lib/signalwire/swml/schema.rb index 60a40d05..86eb2cde 100644 --- a/lib/signalwire/swml/schema.rb +++ b/lib/signalwire/swml/schema.rb @@ -85,7 +85,7 @@ def self.reset_schema! # Normalize a vivified verb's positional args + kwargs into its config Hash # (string-keyed). This is the strict-render contract for the auto-vivified - # (method_missing / __getattr__-analog) verb path, shared by SWMLService and + # (+method_missing+) verb path, shared by SWMLService and # SWMLBuilder so both behave identically: # # verb(k: v) -> {"k" => v} (kwargs) @@ -99,10 +99,9 @@ def self.reset_schema! # # Silently dropping a positional Hash (the previous behavior) produced an # empty verb — e.g. `svc.play({'url'=>...})` rendered `{"play":{}}` with no - # warning (ruby_R5 N2). A misshapen call now fails loudly instead. - # Underscore-prefixed: an internal helper shared by SWMLService + SWMLBuilder, - # not part of the public reference surface (the enumerator skips single-`_` - # names). + # warning. A misshapen call now fails loudly instead. + # Underscore-prefixed: an internal helper shared by SWMLService + + # SWMLBuilder, not part of the public surface. def self._verb_config(verb_name, args, kwargs) kw = kwargs.transform_keys(&:to_s) positional = _positional_config!(verb_name, args) diff --git a/lib/signalwire/swml/service.rb b/lib/signalwire/swml/service.rb index 1ac1ea45..de73c2da 100644 --- a/lib/signalwire/swml/service.rb +++ b/lib/signalwire/swml/service.rb @@ -12,10 +12,9 @@ module SignalWire # SWML — SWML document construction, rendering and serving. module SWML - # rubocop:disable Metrics/ClassLength -- one Python class (SWMLService): the - # full public surface (tool registry, auth helpers, verb auto-vivification, - # Rack serving) plus the two nested Rack middleware classes must live together; - # splitting breaks the 1:1 surface mapping to the reference. + # rubocop:disable Metrics/ClassLength -- the full public surface (tool + # registry, auth helpers, verb auto-vivification, Rack serving) plus the two + # nested Rack middleware classes must live together on one class. class Service # Attributes: # - ``name``, ``route``, ``host``, ``port`` — service identity and @@ -302,9 +301,8 @@ def get_full_url(include_auth: false) # consistent lookup — trailing slash stripped, leading slash ensured # (so "/sip/" and "sip" both store as "/sip"). # - # Parameter ORDER and defaults mirror the reference - # (``register_routing_callback(callback_fn, path="/sip")``): the CALLBACK - # comes first and is required, +path+ second and defaulted. Ruby's block is + # The CALLBACK comes first and is required; +path+ is second and defaults + # to ``"/sip"``. Ruby's block is # the idiomatic spelling of ``callback_fn``, so # ``register_routing_callback('/sip') { ... }`` would put the path in the # callback slot — pass the path as the second argument @@ -320,9 +318,7 @@ def register_routing_callback(callback_fn, path = '/sip', &block) end # Framework-free request-dispatch core — the primitive dispatch surface - # the SDK ports share (mirrors python - # ``SWMLService.handle_request(method, url, headers, body)`` and dotnet's - # ``(int, Dictionary, string) HandleRequest``). Performs proxy detection, + # every SignalWire SDK shares. Performs proxy detection, # basic-auth, the routing-callback check, and the ``on_request`` # modification hook over plain primitives instead of the Rack ``env``, # returning a ``[status, headers, body_string]`` triple. The Rack path @@ -447,14 +443,13 @@ def check_basic_auth_headers(headers) def decode_basic_auth(auth) return [nil, nil] if auth.nil? || auth.empty? - # FIRST-space split, case-INSENSITIVE scheme compare (RFC 7235; the - # reference does `scheme.lower() != "basic"`). + # FIRST-space split, case-INSENSITIVE scheme compare (RFC 7235). scheme, _sep, credentials = auth.partition(' ') return [nil, nil] unless scheme.downcase == 'basic' && !credentials.strip.empty? require 'base64' username, separator, password = Base64.decode64(credentials.strip).partition(':') - # RFC 7617 / the reference's `if not separator: raise` -- a decoded + # RFC 7617 -- a decoded # payload with NO colon is not a credential pair; reject it at the parse # rather than returning a 1-element split with a nil password. return [nil, nil] if separator.empty? @@ -462,8 +457,8 @@ def decode_basic_auth(auth) [username, password] end - # Framework-free proxy detection over a URL + plain headers Hash, mirroring - # python's +detect_proxy_from_primitives+: honor an already-set proxy base, + # Framework-free proxy detection over a URL + plain headers Hash: honor an + # already-set proxy base, # else auto-configure +@proxy_url_base+ from X-Forwarded-* (then RFC-7239 # Forwarded). No-op when neither is present. def detect_proxy_from_primitives(_url, headers) @@ -552,30 +547,27 @@ def render_pretty attr_reader :document # ------------------------------------------------------------------ - # Document accessors — parity with Python SWMLService (item I). Thin - # wrappers over the underlying Document so the reference method surface - # is present on the Service directly. + # Document accessors — thin wrappers over the underlying Document, so the + # whole document surface is reachable on the Service directly. # ------------------------------------------------------------------ - # The current SWML document as a Hash. Mirrors get_document(). + # The current SWML document as a Hash. def get_document @document.to_h end - # Render the current document as a compact JSON string. Mirrors - # render_document() (render() returns compact JSON already). + # Render the current document as a compact JSON string. def render_document @document.render end - # Reset the current document to an empty state. Mirrors reset_document(). + # Reset the current document to an empty state. def reset_document @document.reset self end - # Add a verb to the main section of the current document. Mirrors - # Python SWMLService.add_verb(verb_name, config). + # Add a verb to the main section of the current document. # # The +sleep+ verb accepts a bare Integer; every other verb takes a # config Hash. Config is validated (specialized handler if registered, @@ -590,22 +582,20 @@ def add_verb(verb_name, config) @document.add_verb(verb_name, config) end - # Add a new (empty) section to the current document. Mirrors Python - # SWMLService.add_section(section_name). Returns false if it already - # exists, true otherwise. + # Add a new (empty) section to the current document. Returns false if it + # already exists, true otherwise. def add_section(section_name) @document.add_section(section_name.to_s) end - # Add a verb to a specific section. Mirrors Python - # SWMLService.add_verb_to_section(section_name, verb_name, config). The + # Add a verb to a specific section. The # +sleep+ verb accepts a bare Integer; other verbs take a config Hash # (validated as in {#add_verb}). def add_verb_to_section(section_name, verb_name, config) section_name = section_name.to_s verb_name = verb_name.to_s - # Parity: Python auto-creates the section if it doesn't exist. + # The section is auto-created if it doesn't exist. @document.add_section(section_name) unless @document.has_section?(section_name) return @document.add_verb_to_section(section_name, verb_name, config) if sleep_direct?(verb_name, config) @@ -614,8 +604,8 @@ def add_verb_to_section(section_name, verb_name, config) @document.add_verb_to_section(section_name, verb_name, config) end - # Register a custom verb handler with this service's registry. Mirrors - # register_verb_handler(handler) — delegates to the VerbHandlerRegistry. + # Register a custom verb handler with this service's registry — + # delegates to the VerbHandlerRegistry. def register_verb_handler(handler) verb_registry.register_handler(handler) self @@ -629,26 +619,23 @@ def verb_registry end # Whether full JSON-schema validation is active for this service. - # Mirrors full_validation_enabled(). def full_validation_enabled @schema_validation && schema_utils.full_validation_available? end # Manually set/override the proxy URL base used for webhook callbacks. - # Mirrors manual_set_proxy_url(proxy_url). def manual_set_proxy_url(proxy_url) @proxy_url_base = proxy_url.chomp('/') if proxy_url && !proxy_url.empty? self end # Extract the SIP username from a parsed request body's call.to field. - # Mirrors the staticmethod extract_sip_username(request_body): parses a - # "sip:user@domain" (or "tel:") URI's user portion, or nil. + # Parses a "sip:user@domain" (or "tel:") URI's user portion, or nil. def self.extract_sip_username(request_body) to_field = request_body.dig('call', 'to') if request_body.is_a?(Hash) return nil unless to_field.is_a?(String) - # Python parity: sip: -> username before '@'; tel: -> the number; + # sip: -> username before '@'; tel: -> the number; # otherwise the whole 'to' field is returned. return to_field.delete_prefix('sip:').split('@', 2).first if to_field.start_with?('sip:') return to_field.delete_prefix('tel:') if to_field.start_with?('tel:') @@ -658,16 +645,13 @@ def self.extract_sip_username(request_body) nil end - # Build a Rack-mountable router (app) for this service. Mirrors - # as_router() (Python returns a FastAPI APIRouter; Ruby returns the - # equivalent Rack app so the service can be mounted in any Rack server). + # Build a Rack-mountable router (app) for this service, so it can be + # mounted in any Rack server. def as_router rack_app end - # SchemaUtils helper bound to this Service. Mirrors Python's - # self.schema_utils public instance attribute on SWMLService. - # Built lazily on first access. + # SchemaUtils helper bound to this Service. Built lazily on first access. def schema_utils return @schema_utils if defined?(@schema_utils) @@ -725,14 +709,13 @@ def stop # Static health/ready JSON triple. Class method so the no-auth lambdas in # +build_rack_app+ don't capture +self+. Underscore-prefixed to stay out of - # the surface inventory (no Python counterpart on SWMLService). + # the surface inventory. def self._status_response(status) [200, { 'content-type' => 'application/json' }, [JSON.generate({ status: status })]] end # Request-handling internals (formerly leading-underscore by convention). - # Not part of the public/Python surface — declared private so the - # cross-port surface enumerator continues to exclude them. + # Not part of the public surface — declared private so they stay off it. private :handle_request_core, :unauthorized_triple, :routing_redirect, :invoke_routing_callback, :render_dispatch_triple, :callback_path_for_url, :check_basic_auth_headers, :decode_basic_auth, :detect_proxy_from_primitives, @@ -788,7 +771,7 @@ def validate_verb_config(verb_name, config) # false-reject legitimate renders the bundled schema doesn't fully # accept (empty prompt.pom, SWAIG defaults). ai.params stays open. # validate_verb_top_level_keys is an @api-private SchemaUtils helper - # (not part of the reference surface), so reach it via __send__. + # so reach it via __send__. schema_utils.__send__(:validate_verb_top_level_keys, verb_name, config) end @@ -1156,7 +1139,7 @@ def credentials_ok?(auth) # www-authenticate header and a JSON `{"error":"Unauthorized"}` body, not # plain text. def unauthorized - # Python parity: a JSON {"error":"Unauthorized"} body (not plain text). + # A JSON {"error":"Unauthorized"} body, not plain text. [ 401, { diff --git a/lib/signalwire/swml/swml_builder.rb b/lib/signalwire/swml/swml_builder.rb index f2bb1455..f4d79117 100644 --- a/lib/signalwire/swml/swml_builder.rb +++ b/lib/signalwire/swml/swml_builder.rb @@ -9,9 +9,7 @@ # # Provides a fluent builder API for creating SWML documents by chaining method # calls. It delegates to an underlying SWML::Service instance for the actual -# document creation, mirroring the Python reference -# signalwire.core.swml_builder.SWMLBuilder (which wraps an SWMLService) and the -# PHP SignalWire\SWML\SWMLBuilder. +# document creation. module SignalWire # SWML — SWML document construction, rendering and serving. @@ -20,8 +18,7 @@ module SWML # # The explicit verb helpers (#answer, #hangup, #play, #ai, #say) cover the # common verbs; every other schema verb is auto-vivified through - # #method_missing (e.g. +builder.denoise.goto(...)+), the Ruby analog of the - # Python reference's runtime +__getattr__+ verb dispatch. + # #method_missing (e.g. +builder.denoise.goto(...)+). class SWMLBuilder # Initialize with a SWML::Service instance to delegate to. # @@ -74,7 +71,7 @@ def ai(prompt_text: nil, prompt_pom: nil, post_prompt: nil, config['prompt'] = ai_prompt(prompt_text, prompt_pom) unless prompt_text.nil? && prompt_pom.nil? config['post_prompt'] = { 'text' => post_prompt } unless post_prompt.nil? put(config, 'post_prompt_url' => post_prompt_url, 'SWAIG' => swaig) - # Merge any additional kwargs (parity with Python's config.update(kwargs)). + # Merge any additional kwargs into the config, stringifying their keys. kwargs.each { |key, value| config[key.to_s] = value } add_verb('ai', config) @@ -148,10 +145,9 @@ def reset # Auto-vivify SWML verb methods from the schema. # - # This is the Ruby analog of the Python reference's +__getattr__+ runtime - # verb dispatch: any schema verb name not covered by an explicit method - # above is dispatched to the underlying document, returning +self+ for - # chaining (e.g. +builder.denoise.record+, +builder.sleep(2000)+). + # Any schema verb name not covered by an explicit method above is + # dispatched to the underlying document, returning +self+ for chaining + # (e.g. +builder.denoise.record+, +builder.sleep(2000)+). def method_missing(method_name, *args, **kwargs) verb = method_name.to_s return super unless SWML.schema.valid_verb?(verb) @@ -163,8 +159,8 @@ def method_missing(method_name, *args, **kwargs) end end - # Report the auto-vivified verbs as respondable (Ruby analog of Python's - # +__getattr__+ making verb names look like real attributes). + # Report the auto-vivified verbs as respondable, so +respond_to?+ answers + # true for any valid schema verb name. def respond_to_missing?(method_name, include_private = false) SWML.schema.valid_verb?(method_name.to_s) || super end diff --git a/lib/signalwire/swml/swml_handler.rb b/lib/signalwire/swml/swml_handler.rb index 7ba22dad..9c530f28 100644 --- a/lib/signalwire/swml/swml_handler.rb +++ b/lib/signalwire/swml/swml_handler.rb @@ -7,11 +7,10 @@ # # SWML Verb Handlers - Interface and implementations for SWML verb handling. # -# This module defines the base interface for SWML verb handlers and provides -# implementations for specific verbs that require special handling. Mirrors the -# Python reference signalwire.core.swml_handler (SWMLVerbHandler / AIVerbHandler -# / VerbHandlerRegistry) and the PHP SignalWire\SWML\{SWMLVerbHandler, -# AIVerbHandler, VerbHandlerRegistry}. +# This module defines the base interface for SWML verb handlers +# (SWMLVerbHandler) and provides implementations for specific verbs that +# require special handling (AIVerbHandler), along with the lookup registry +# that maps a verb name to its handler (VerbHandlerRegistry). module SignalWire # SWML — SWML document construction, rendering and serving. @@ -113,7 +112,8 @@ def build_config(prompt_text: nil, prompt_pom: nil, contexts: nil, config['post_prompt_url'] = post_prompt_url unless post_prompt_url.nil? config['SWAIG'] = swaig unless swaig.nil? - # Match Python behaviour: always initialise the params dict. + # +params+ is always initialised, so the key is present on the wire + # even when no extra keyword routed into it. config['params'] = {} route_extra_kwargs(config, kwargs) config diff --git a/lib/signalwire/swml/swml_renderer.rb b/lib/signalwire/swml/swml_renderer.rb index 5ab333ec..a866d38a 100644 --- a/lib/signalwire/swml/swml_renderer.rb +++ b/lib/signalwire/swml/swml_renderer.rb @@ -7,10 +7,8 @@ # # SWML document rendering utilities for SignalWire AI Agents. # -# Mirrors the Python reference signalwire.core.swml_renderer.SwmlRenderer (two -# staticmethod-like helpers) and the PHP SignalWire\SWML\SwmlRenderer. Both -# helpers are module functions in Ruby (def self.) since the reference methods -# are static. +# Two stateless helpers, exposed as module functions (def self.) — there is +# nothing to instantiate. require_relative 'swml_builder' diff --git a/lib/signalwire/utils/schema_utils.rb b/lib/signalwire/utils/schema_utils.rb index 40003f76..1f626fa5 100644 --- a/lib/signalwire/utils/schema_utils.rb +++ b/lib/signalwire/utils/schema_utils.rb @@ -12,15 +12,12 @@ module SignalWire # Utils — small shared helpers with no dependency on the agent surface. module Utils - # SchemaValidationError — Ruby port of - # signalwire.utils.schema_utils.SchemaValidationError. - # - # Raised when SWML schema validation of a verb config fails. + # SchemaValidationError — raised when SWML schema validation of a verb + # config fails. class SchemaValidationError < SignalWire::Error attr_reader :verb_name, :errors - # Construct a SchemaValidationError. Mirrors Python's - # SchemaValidationError(verb_name, errors). + # Construct a SchemaValidationError from the verb name and its errors. def initialize(verb_name, errors) @verb_name = verb_name @errors = errors || [] @@ -29,12 +26,10 @@ def initialize(verb_name, errors) end end - # SchemaUtils — Ruby port of signalwire.utils.schema_utils.SchemaUtils. - # - # Loads the SWML JSON Schema, extracts verb metadata, and validates - # either a single verb config or a complete SWML document. + # SchemaUtils — loads the SWML JSON Schema, extracts verb metadata, and + # validates either a single verb config or a complete SWML document. # - # Construction rules mirror Python: + # Construction rules: # - Pass schema_path: nil to use the bundled schema.json. # - schema_validation: false disables validation (validate_verb returns # true for every call). @@ -43,11 +38,10 @@ def initialize(verb_name, errors) # # Full JSON Schema validation (Draft 2020-12, including closed-key # `unevaluatedProperties` and type checking) is performed via the - # `json_schemer` gem, mirroring Python's jsonschema-rs validator: a verb - # config is wrapped in a minimal SWML document and validated against the - # bundled schema.json. When json_schemer is unavailable the port falls back - # to the lightweight validator (verb existence + required-property check), - # which matches Python's _validate_verb_lightweight() exactly. + # `json_schemer` gem: a verb config is wrapped in a minimal SWML document + # and validated against the bundled schema.json. When json_schemer is + # unavailable this falls back to a lightweight validator that checks verb + # existence and required properties only. class SchemaUtils # JSON-schema scalar type → Python type-annotation string (codegen). PYTHON_SCALAR_TYPES = { @@ -83,12 +77,11 @@ def initialize(schema_path = nil, schema_validation = true) end # Whether full JSON Schema validation is wired up. - # Mirrors Python's full_validation_available property. def full_validation_available? !@full_validator.nil? end - # Read and parse the JSON Schema. Mirrors Python's load_schema(). + # Read and parse the JSON Schema. def load_schema path = @schema_path || default_schema_path return {} if path.nil? || !File.exist?(path) @@ -100,13 +93,11 @@ def load_schema end # Sorted list of all known verb names. - # Mirrors Python's get_all_verb_names(). def get_all_verb_names @verbs.keys.sort end # The properties[verb_name] block for a verb, or {} when unknown. - # Mirrors Python's get_verb_properties(verb_name). def get_verb_properties(verb_name) v = @verbs[verb_name] return {} if v.nil? @@ -119,7 +110,6 @@ def get_verb_properties(verb_name) end # The required list for a verb, or [] when unknown / no required. - # Mirrors Python's get_verb_required_properties(verb_name). def get_verb_required_properties(verb_name) inner = get_verb_properties(verb_name) req = inner['required'] @@ -129,7 +119,6 @@ def get_verb_required_properties(verb_name) end # Parameter-definition block used by code-gen tooling. - # Mirrors Python's get_verb_parameters(verb_name). def get_verb_parameters(verb_name) inner = get_verb_properties(verb_name) props = inner['properties'] @@ -139,7 +128,6 @@ def get_verb_parameters(verb_name) end # Validate a verb config against the schema. - # Mirrors Python's validate_verb(verb_name, verb_config). # # @return [Array(Boolean, Array)] (valid, errors) tuple. def validate_verb(verb_name, verb_config) @@ -154,8 +142,7 @@ def validate_verb(verb_name, verb_config) end end - # Validate a complete SWML document against the full JSON Schema. - # Mirrors Python's validate_document(document): runs the json_schemer + # Validate a complete SWML document by running the full JSON Schema # validator over the whole document. Returns # (false, ['Schema validator not initialized']) when no full validator is # wired in (validation disabled or json_schemer unavailable). @@ -169,7 +156,6 @@ def validate_document(document) end # Generate a Python-style method signature string for a verb. - # Mirrors Python's generate_method_signature(verb_name). def generate_method_signature(verb_name) params = get_verb_parameters(verb_name) keys = params.keys.sort @@ -179,7 +165,6 @@ def generate_method_signature(verb_name) end # Generate a Python-style method body string for a verb. - # Mirrors Python's generate_method_body(verb_name). def generate_method_body(verb_name) keys = get_verb_parameters(verb_name).keys.sort config_lines = keys.flat_map do |name| @@ -191,8 +176,7 @@ def generate_method_body(verb_name) private - # @api private — internal helper used by SWMLService for handler - # verbs (not part of the reference SchemaUtils surface). + # @api private — internal helper used by SWMLService for handler verbs. # Top-level-key validation for a verb whose config is checked by a # specialized handler (e.g. the ai verb). Enforces exactly the closed-key # + required-key contract at the verb's OWN level — reject an unknown or @@ -200,10 +184,10 @@ def generate_method_body(verb_name) # into the verb's deep sub-schemas. The ai verb's deep shapes (an empty # prompt.pom [], SWAIG.defaults/web_hook_url/__token) are legitimate # renders the bundled schema does not fully accept, so full-deep - # validating the ai verb would false-reject valid documents. This mirrors - # the reference: the ai verb rejects stray TOP-LEVEL keys like every other - # verb, but its inner objects (prompt, SWAIG, params) stay as the handler - # and runtime define them. params is open by construction — this check + # validating the ai verb would false-reject valid documents. So the ai + # verb rejects stray TOP-LEVEL keys like every other verb, but its inner + # objects (prompt, SWAIG, params) stay as the handler and runtime define + # them. params is open by construction — this check # never looks inside it. # # @return [Array(Boolean, Array)] (valid, errors) tuple. @@ -347,7 +331,7 @@ def entry_schema_name(entry) end # Wire the json_schemer full validator (Draft 2020-12) over the loaded - # schema, mirroring Python's jsonschema-rs Draft202012Validator. Leaves + # schema. Leaves # @full_validator nil (lightweight fallback) if json_schemer is not # installed or the schema lacks the full document structure — so a # partial/test schema without a 'sections' property never crashes here. @@ -405,11 +389,10 @@ def widen_base_type(node) types.length == 1 ? types.first : nil end - # Full JSON Schema validation via json_schemer. Mirrors Python's - # _validate_verb_full: wrap the verb in a minimal SWML document - # ({version, sections:{main:[{verb: config}]}}) and validate the whole - # doc, so the schema's closed-key (`unevaluatedProperties`) and type - # rules apply to the verb config exactly as they do in the reference. + # Full JSON Schema validation via json_schemer: wrap the verb in a + # minimal SWML document ({version, sections:{main:[{verb: config}]}}) + # and validate the whole doc, so the schema's closed-key + # (`unevaluatedProperties`) and type rules apply to the verb config. def validate_verb_full(verb_name, verb_config) return validate_verb_lightweight(verb_name, verb_config) if @full_validator.nil? @@ -424,8 +407,8 @@ def validate_verb_full(verb_name, verb_config) [false, ["Schema validation error for '#{verb_name}': #{detail}"]] end - # Build a concise error string from json_schemer's error records, capped - # like Python's 500-char truncation. + # Build a concise error string from json_schemer's error records, + # truncated to 500 characters. def schema_error_detail(_verb_name, errors) msg = errors.filter_map { |e| e['error'] || e['type'] }.join('; ') msg = "#{msg[0, 500]}..." if msg.length > 500 @@ -433,8 +416,7 @@ def schema_error_detail(_verb_name, errors) end # @api private — the fallback validator used when json_schemer is unavailable: - # presence of every required property, and nothing deeper. Matches the - # reference's own lightweight path. + # presence of every required property, and nothing deeper. # # @return [Array(Boolean, Array)] def validate_verb_lightweight(verb_name, verb_config) @@ -465,8 +447,7 @@ def resolved_verb_schema(verb_name) # Closed-key + required-key errors at the verb's own level. A key not in # the schema's declared `properties` is rejected only when the schema is - # closed (unevaluatedProperties / additionalProperties disallow extras) — - # matching the reference's closed-verb contract. + # closed (unevaluatedProperties / additionalProperties disallow extras). def top_level_key_errors(verb_name, verb_config, schema) errors = missing_required_errors(verb_name, verb_config, schema) errors.concat(unknown_key_errors(verb_name, verb_config, schema)) if schema_closed?(schema) diff --git a/lib/signalwire/utils/serverless.rb b/lib/signalwire/utils/serverless.rb index b383ef58..10135b4d 100644 --- a/lib/signalwire/utils/serverless.rb +++ b/lib/signalwire/utils/serverless.rb @@ -2,10 +2,8 @@ require_relative '../core/logging_config' -# Cross-language SDK contract: SignalWire::Utils.is_serverless_mode -# mirrors signalwire.utils.is_serverless_mode in the Python reference. -# Returns true when running inside any short-lived / event-driven -# environment (i.e. not 'server'). +# SignalWire::Utils.is_serverless_mode returns true when running inside any +# short-lived / event-driven environment (i.e. not 'server'). module SignalWire # Utils — small shared helpers with no dependency on the agent surface. diff --git a/lib/signalwire/utils/url_validator.rb b/lib/signalwire/utils/url_validator.rb index 4c8ffc10..95ab69af 100644 --- a/lib/signalwire/utils/url_validator.rb +++ b/lib/signalwire/utils/url_validator.rb @@ -17,18 +17,13 @@ module SignalWire module Utils # SSRF-prevention guard for user-supplied URLs. # - # Mirrors Python's signalwire.utils.url_validator.validate_url: - # rejects non-http(s) schemes, missing hostnames, and any URL whose - # hostname resolves to a private / loopback / link-local / cloud- - # metadata IP. When +allow_private+ is true, OR the + # {.validate_url} rejects non-http(s) schemes, missing hostnames, and any + # URL whose hostname resolves to a private / loopback / link-local / + # cloud-metadata IP. When +allow_private+ is true, OR the # +SWML_ALLOW_PRIVATE_URLS+ env var is set to "1", "true" or "yes" # (case-insensitive), the IP-blocklist check is skipped. - # - # The method UrlValidator.validate_url projects onto the Python free - # function signalwire.utils.url_validator.validate_url via - # scripts/enumerate_signatures.py. module UrlValidator - # Cross-port SSRF block list. Order matches the Python reference. + # SSRF block list, checked in this order. BLOCKED_NETWORKS = %w[ 10.0.0.0/8 172.16.0.0/12 @@ -44,9 +39,9 @@ module UrlValidator LOG = SignalWire::Logging.logger('signalwire.url_validator') # Pluggable resolver hook. Tests inject a lambda to keep the suite - # hermetic; production calls Resolv.getaddresses. Underscore prefix - # keeps it out of the public surface inventory — the Python - # reference only exposes ``validate_url`` at this module level. + # hermetic; production calls Resolv.getaddresses. The underscore prefix + # keeps it out of the public surface inventory — {.validate_url} is the + # only public entry point on this module. def self._resolver @_resolver end diff --git a/lib/signalwire/web/web_service.rb b/lib/signalwire/web/web_service.rb index 5eefcd5b..af079661 100644 --- a/lib/signalwire/web/web_service.rb +++ b/lib/signalwire/web/web_service.rb @@ -21,12 +21,11 @@ module SignalWire module Web # Static file serving service with an HTTP API. # - # Mirrors Python's ``signalwire.web.web_service.WebService``. Maps URL route - # prefixes to local directories and serves their files over HTTP with - # security headers, extension filtering, and optional basic auth. + # Maps URL route prefixes to local directories and serves their files over + # HTTP with security headers, extension filtering, and optional basic auth. # - # Ruby idiom note: Python builds a FastAPI/uvicorn app; Ruby uses WEBrick. - # {#start} launches the server in a background thread (non-blocking) so it is + # The server is WEBrick. {#start} launches it in a background thread + # (non-blocking) so it is # safe to start and {#stop} in tests without hanging; pass +block: true+ to # {#start} to run in the foreground. class WebService @@ -97,9 +96,8 @@ def remove_directory(route) # foreground. +port+ 0 binds an ephemeral port. # # +host+ defaults to '0.0.0.0' -- the INTENDED server default: listen on all - # interfaces so a containerised or remote-hosted agent is reachable. This - # matches the reference (signalwire/web/web_service.py, which carries the same - # deliberate-choice marker). It is not an oversight; do NOT "harden" it back to + # interfaces so a containerised or remote-hosted agent is reachable. It is + # a deliberate choice, not an oversight; do NOT "harden" it back to # '127.0.0.1' -- pass +host: '127.0.0.1'+ explicitly for loopback-only binding. def start(host: '0.0.0.0', port: nil, ssl_cert: nil, ssl_key: nil, block: false) bind_port = port || @port @@ -246,14 +244,14 @@ def authorized?(req, res) # @return [Boolean] true when both halves match def credentials_match?(req, user, pass) # Split on the FIRST space and compare the scheme case-INSENSITIVELY - # (RFC 7235; the reference does `scheme.lower() != "basic"`). + # (RFC 7235): "Basic", "basic" and "BASIC" are all accepted. scheme, _sep, param = req['Authorization'].to_s.partition(' ') return false unless scheme.downcase == 'basic' decoded = Base64.decode64(param.strip) input_user, separator, input_pass = decoded.partition(':') - # RFC 7617 / the reference's `if not separator: raise` -- a payload with - # NO colon is not a credential pair; never default the password to ''. + # RFC 7617 -- a payload with NO colon is not a credential pair; reject + # it rather than defaulting the password to ''. return false if separator.empty? Rack::Utils.secure_compare(user.to_s, input_user) && Rack::Utils.secure_compare(pass.to_s, input_pass) From 4c98046bf86960aefc8e2d15f5fd0dcd5debd3e2 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:03:44 -0400 Subject: [PATCH 57/90] lint: remove the directory carve-outs so examples/ + bin/*-dump are linted Owner ruling 2026-07-30: "all the full directories should be linted and formatted including tests examples and all ... examples and tests are shipping code too, all at the levels the shipping code gets." Drops every AllCops/Exclude entry except vendor/ (genuine third-party code we do not own). That widens the FMT + LINT gates -- which already invoke bare `rubocop` from the repo root -- over examples/, relay/examples/, rest/examples/, the 12 bin/*-dump programs, and scripts/doc_wire_runner.rb. 81 files, 743 offenses, previously invisible to both gates. The deleted comment blocks argued these were "tutorial-style ... not audited library surface". That rationale was about PUBLIC-SURFACE AUDITING, not about whether the code should be well-formed, and it is not a reason to hold code below the bar the rest of the repo already meets. The same file already refuses to exclude the generated trees for exactly this reason. The per-cop suppressions (Metrics/ParameterLists, Lint/DuplicateBranch, Lint/EmptyBlock's tests/ scope, etc.) are a different category -- one rule, a stated reason the construct is correct there -- and are untouched. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- .rubocop.yml | 35 ++++++++--------------------------- 1 file changed, 8 insertions(+), 27 deletions(-) diff --git a/.rubocop.yml b/.rubocop.yml index 456c12c0..be90dae0 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -23,34 +23,15 @@ AllCops: TargetRubyVersion: 3.2 SuggestExtensions: false Exclude: - # Demo programs, not library surface — excluded from the blocking gate the way - # signalwire-go tags its examples //go:build ignore. They are not part of the - # audited public surface and are free to read as tutorial-style code. - - 'examples/**/*' - - 'relay/examples/**/*' - - 'rest/examples/**/*' + # THIRD-PARTY code we do not own. This is the ONLY directory-level carve-out. + # Everything else in this repo — lib/, tests/, examples/, relay/examples/, + # rest/examples/, bin/ (including the *-dump programs), scripts/ — is linted + # and formatted at the SAME bar as the shipped library. Owner ruling + # 2026-07-30: "examples and tests are shipping code too ... all at the levels + # the shipping code gets." The prior "tutorial-style / not audited public + # surface" rationale was about PUBLIC-SURFACE AUDITING, not about whether the + # code should be well-formed; it is not a reason to hold it below the bar. - 'vendor/**/*' - # Layer-D cross-port dump programs (bin/*-dump) — the per-surface behavioral - # differ tooling, mirroring the Go reference's cmd/*-dump. Tutorial-style - # port-native dispatch programs, not audited library surface; same rationale - # as examples/ above and go's //go:build ignore dumps. - - 'bin/wire-dump' - - 'bin/swml-dump' - - 'bin/state-dump' - - 'bin/http-dump' - - 'bin/envelope-dump' - - 'bin/wire-relay-dump' - - 'bin/wait-liveness-dump' - - 'bin/secure-default-dump' - - 'bin/relay-liveness-dump' - - 'bin/pagination-dump' - - 'bin/secret-scrub-dump' - - 'bin/ai-chat-dump' - # Cross-port gate fixture-replay tooling, same category as the bin/*-dump - # programs above: doc_wire_runner.rb only DRIVES the documented REST calls - # against the DOC-WIRE flag-mode mock so it journals the wire shape. Not - # audited library surface. - - 'scripts/doc_wire_runner.rb' # NOTE: the machine-generated trees (REST resource layer, READ-SIDE typed # payload trees, and the full-mock REST wire-test suite) are DELIBERATELY NOT # excluded here — generated code is linted like hand-written code so a From 2a6a161dbafe21d1a19fb207c0e2ad88210bcc58 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:04:49 -0400 Subject: [PATCH 58/90] lint: burn the mechanical rubocop findings in examples/ + bin/*-dump (743 -> 75) `rubocop --autocorrect` (SAFE corrections only) over the newly-in-scope tree. 819 offenses corrected across 72 files; 743 -> 75 residual, all of which need a judgement call and are handled in follow-up commits. Every correction here is semantics-preserving by construction: * Layout/* (382 HashAlignment, 85 MultilineMethodCallIndentation, ...) -- whitespace only. * Style/RescueStandardError -- `rescue => e` IS `rescue StandardError => e`. * Style/FetchEnvVar -- `ENV[name]` -> `ENV.fetch(name, nil)`, identical result including the nil-on-absent case (deliberately NOT `fetch(name)`, which would raise). * Style/StringLiterals, Style/NumericLiterals (-32002 -> -32_002), Style/RedundantParentheses, Style/ConditionalAssignment. * Lint/ScriptPermission -- 4 examples with a shebang got the +x bit they were already documented as needing. No cop was disabled, no path re-excluded, no inline suppression added. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/pagination-dump | 2 +- bin/relay-liveness-dump | 6 +- bin/wire-relay-dump | 2 +- examples/advanced_datamap_demo.rb | 142 +++++++++--------- examples/auto_vivified_example.rb | 30 ++-- examples/basic_swml_service.rb | 26 ++-- examples/call_flow_and_actions_demo.rb | 42 +++--- examples/comprehensive_dynamic_agent.rb | 46 +++--- examples/concierge_agent_example.rb | 32 ++-- examples/contexts_demo.rb | 24 +-- examples/custom_path_agent.rb | 10 +- examples/datamap_demo.rb | 36 ++--- examples/datasphere.rb | 46 +++--- examples/datasphere_multi_instance_demo.rb | 40 ++--- examples/datasphere_serverless_env.rb | 14 +- examples/datasphere_webhook_env_demo.rb | 14 +- examples/declarative_agent.rb | 22 +-- examples/dynamic_info_gatherer_example.rb | 6 +- examples/dynamic_swml_service.rb | 11 +- examples/faq_bot_agent.rb | 26 ++-- examples/gather_info_demo.rb | 9 +- .../gather_per_question_functions_demo.rb | 60 ++++---- examples/info_gatherer_example.rb | 24 +-- examples/joke_agent.rb | 12 +- examples/joke_skill_demo.rb | 16 +- examples/kubernetes_ready_agent.rb | 10 +- examples/lambda_agent.rb | 18 +-- examples/llm_params_demo.rb | 46 +++--- examples/mcp_agent.rb | 6 +- examples/multi_agent_server.rb | 40 ++--- examples/multi_endpoint_agent.rb | 16 +- examples/quickstart_agent.rb | 6 +- examples/quickstart_relay.rb | 6 +- examples/quickstart_rest.rb | 4 +- examples/receptionist_agent_example.rb | 18 +-- examples/record_call_example.rb | 74 ++++----- examples/relay_answer_and_welcome.rb | 14 +- examples/relay_audit_harness.rb | 35 +++-- examples/rest_demo.rb | 4 +- examples/room_and_sip_example.rb | 44 +++--- examples/session_and_state_demo.rb | 20 +-- examples/simple_agent.rb | 8 +- examples/simple_dynamic_agent.rb | 10 +- examples/simple_dynamic_enhanced.rb | 53 ++++--- examples/simple_static_agent.rb | 18 +-- examples/skills_audit_harness.rb | 16 +- examples/step_function_inheritance_demo.rb | 26 ++-- examples/survey_agent_example.rb | 36 ++--- examples/swaig_features_agent.rb | 42 +++--- examples/swml_service_example.rb | 18 +-- examples/swml_service_routing_example.rb | 8 +- examples/swmlservice_ai_sidecar.rb | 28 ++-- examples/swmlservice_swaig_standalone.rb | 16 +- examples/tap_example.rb | 54 +++---- examples/web_search_agent.rb | 26 ++-- examples/web_search_multi_instance_demo.rb | 40 ++--- examples/wikipedia_demo.rb | 12 +- relay/examples/relay_answer_and_welcome.rb | 2 +- relay/examples/relay_dial_and_play.rb | 2 +- relay/examples/relay_ivr_connect.rb | 6 +- rest/examples/rest_10dlc_registration.rb | 22 +-- .../rest_bind_phone_to_swml_webhook.rb | 4 +- rest/examples/rest_calling_ivr_and_ai.rb | 8 +- rest/examples/rest_calling_play_and_record.rb | 26 ++-- rest/examples/rest_datasphere_search.rb | 6 +- .../rest_fabric_conferences_and_routing.rb | 4 +- .../rest_fabric_subscribers_and_sip.rb | 16 +- .../rest_fabric_swml_and_callflows.rb | 6 +- rest/examples/rest_manage_resources.rb | 8 +- rest/examples/rest_phone_number_management.rb | 22 +-- .../rest_queues_mfa_and_recordings.rb | 16 +- rest/examples/rest_video_rooms.rb | 14 +- 72 files changed, 815 insertions(+), 817 deletions(-) mode change 100644 => 100755 examples/mcp_agent.rb mode change 100644 => 100755 examples/relay_audit_harness.rb mode change 100644 => 100755 examples/skills_audit_harness.rb mode change 100644 => 100755 examples/swml_service_example.rb diff --git a/bin/pagination-dump b/bin/pagination-dump index 25a3a1a7..95870655 100755 --- a/bin/pagination-dump +++ b/bin/pagination-dump @@ -58,7 +58,7 @@ CYCLE_WATCHDOG_S = 8.0 # optional 'next' cursor URL. def push_page(mock, data, links) mock.push_scenario(LIST_ENDPOINT_ID, status: 200, - response: { 'data' => data, 'links' => links }) + response: { 'data' => data, 'links' => links }) end def new_iterator(client) diff --git a/bin/relay-liveness-dump b/bin/relay-liveness-dump index cad8e394..25f94624 100755 --- a/bin/relay-liveness-dump +++ b/bin/relay-liveness-dump @@ -54,7 +54,7 @@ require_relative '../lib/signalwire' require_relative '../lib/signalwire/relay/client' # The RELAY error code a server sends to reject connect credentials. -AUTH_REQUIRED_CODE = -32002 +AUTH_REQUIRED_CODE = -32_002 # ====================================================================== # ControllableWsServer — a minimal single-connection WebSocket server that @@ -104,7 +104,7 @@ class ControllableWsServer return unless ws_handshake(sock) @mutex.synchronize { @connects += 1 } - drop_after_auth = (@fault == :reconnect && connect_count == 1) + drop_after_auth = @fault == :reconnect && connect_count == 1 serve_frames(sock, drop_after_auth) rescue StandardError nil @@ -234,7 +234,7 @@ def drive_cred_missing(omit, expect_contains) failed = false end actionable = expect_contains.all? { |w| msg.include?(w) } - { 'failed_preconnect_on_missing' => (failed && actionable) } + { 'failed_preconnect_on_missing' => failed && actionable } end # cred_auth_reject: a 401-class connect rejection must RAISE the server message, diff --git a/bin/wire-relay-dump b/bin/wire-relay-dump index 181a2c8f..072386b7 100755 --- a/bin/wire-relay-dump +++ b/bin/wire-relay-dump @@ -160,7 +160,7 @@ out['relay_live_transcribe'] = c.frames.last # relay_live_translate (action MUST be wrapped as params.action; status_url sibling) c = new_call c.live_translate(action: { 'start' => { 'from_lang' => 'en', 'to_lang' => 'es' } }, - status_url: 'https://x/cb') + status_url: 'https://x/cb') out['relay_live_translate'] = c.frames.last # ---- control-ops (Action methods) ---- diff --git a/examples/advanced_datamap_demo.rb b/examples/advanced_datamap_demo.rb index 44063013..731f2b5a 100644 --- a/examples/advanced_datamap_demo.rb +++ b/examples/advanced_datamap_demo.rb @@ -12,9 +12,9 @@ # --- Expression-based command processor --- command_processor = SignalWire::DataMap.new('command_processor') - .purpose('Process user commands with pattern matching') - .parameter('command', 'string', 'User command to process', required: true) - .parameter('target', 'string', 'Optional target for the command', required: false) + .purpose('Process user commands with pattern matching') + .parameter('command', 'string', 'User command to process', required: true) + .parameter('target', 'string', 'Optional target for the command', required: false) command_processor.expression( '${args.command}', '^start', @@ -35,31 +35,31 @@ # --- Advanced webhook tool --- advanced_api = SignalWire::DataMap.new('advanced_api_tool') - .purpose('API tool with advanced webhook features') - .parameter('action', 'string', 'Action to perform', required: true) - .parameter('data', 'string', 'Data to send', required: false) - .webhook( - 'POST', 'https://api.example.com/advanced', - headers: { - 'Authorization' => 'Bearer ${token}', - 'User-Agent' => 'SignalWire-Agent/1.0' - }, - input_args_as_params: true, - require_args: ['action'], - form_param: 'payload' - ) - .webhook_expressions([ - { - 'string' => '${response.status}', - 'pattern' => '^success$', - 'output' => { 'response' => 'Operation completed successfully' } - }, - { - 'string' => '${response.error_code}', - 'pattern' => '^(404|500)$', - 'output' => { 'response' => 'API Error: ${response.error_message}' } - } - ]) + .purpose('API tool with advanced webhook features') + .parameter('action', 'string', 'Action to perform', required: true) + .parameter('data', 'string', 'Data to send', required: false) + .webhook( + 'POST', 'https://api.example.com/advanced', + headers: { + 'Authorization' => 'Bearer ${token}', + 'User-Agent' => 'SignalWire-Agent/1.0' + }, + input_args_as_params: true, + require_args: ['action'], + form_param: 'payload' + ) + .webhook_expressions([ + { + 'string' => '${response.status}', + 'pattern' => '^success$', + 'output' => { 'response' => 'Operation completed successfully' } + }, + { + 'string' => '${response.error_code}', + 'pattern' => '^(404|500)$', + 'output' => { 'response' => 'API Error: ${response.error_message}' } + } + ]) # Fallback webhook advanced_api.webhook( @@ -78,58 +78,58 @@ # --- Form-encoded submission --- form_tool = SignalWire::DataMap.new('form_submission_tool') - .purpose('Submit form data using form encoding') - .parameter('name', 'string', 'User name', required: true) - .parameter('email', 'string', 'User email', required: true) - .parameter('message', 'string', 'Message content', required: true) - .webhook( - 'POST', 'https://forms.example.com/submit', - headers: { - 'Content-Type' => 'application/x-www-form-urlencoded', - 'X-API-Key' => '${api_key}' - }, - form_param: 'form_data' - ) - .params( - 'name' => '${args.name}', - 'email' => '${args.email}', - 'message' => '${args.message}' - ) - .output( - SignalWire::Swaig::FunctionResult.new( - 'Form submitted successfully for ${args.name}' - ) - ) + .purpose('Submit form data using form encoding') + .parameter('name', 'string', 'User name', required: true) + .parameter('email', 'string', 'User email', required: true) + .parameter('message', 'string', 'Message content', required: true) + .webhook( + 'POST', 'https://forms.example.com/submit', + headers: { + 'Content-Type' => 'application/x-www-form-urlencoded', + 'X-API-Key' => '${api_key}' + }, + form_param: 'form_data' + ) + .params( + 'name' => '${args.name}', + 'email' => '${args.email}', + 'message' => '${args.message}' + ) + .output( + SignalWire::Swaig::FunctionResult.new( + 'Form submitted successfully for ${args.name}' + ) + ) # --- Array processing with foreach --- search_tool = SignalWire::DataMap.new('search_results_tool') - .purpose('Search and format results from API') - .parameter('query', 'string', 'Search query', required: true) - .parameter('limit', 'string', 'Maximum results', required: false) - .webhook( - 'GET', 'https://search-api.example.com/search', - headers: { 'Authorization' => 'Bearer ${search_token}' } - ) - .params('q' => '${args.query}') - .foreach( - 'input_key' => 'results', - 'output_key' => 'formatted_results', - 'max' => 5, - 'append' => "Title: ${this.title}\n${this.summary}\nURL: ${this.url}\n\n" - ) - .output( - SignalWire::Swaig::FunctionResult.new( - 'Found results for "${args.query}":\n\n${formatted_results}' - ) - ) + .purpose('Search and format results from API') + .parameter('query', 'string', 'Search query', required: true) + .parameter('limit', 'string', 'Maximum results', required: false) + .webhook( + 'GET', 'https://search-api.example.com/search', + headers: { 'Authorization' => 'Bearer ${search_token}' } + ) + .params('q' => '${args.query}') + .foreach( + 'input_key' => 'results', + 'output_key' => 'formatted_results', + 'max' => 5, + 'append' => "Title: ${this.title}\n${this.summary}\nURL: ${this.url}\n\n" + ) + .output( + SignalWire::Swaig::FunctionResult.new( + 'Found results for "${args.query}":\n\n${formatted_results}' + ) + ) # --- Print all definitions --- demos = { - 'Expression Demo' => command_processor, + 'Expression Demo' => command_processor, 'Advanced Webhook Demo' => advanced_api, - 'Form Encoding Demo' => form_tool, + 'Form Encoding Demo' => form_tool, 'Array Processing Demo' => search_tool } diff --git a/examples/auto_vivified_example.rb b/examples/auto_vivified_example.rb index e491ff74..cd5e92b8 100644 --- a/examples/auto_vivified_example.rb +++ b/examples/auto_vivified_example.rb @@ -31,16 +31,16 @@ ivr.answer ivr.add_section('main_menu') ivr.add_verb_to_section('main_menu', 'prompt', - 'play' => 'say:Press 1 for sales, 2 for support, or 3 to leave a message.', - 'max_digits' => 1, - 'terminators' => '#', - 'digit_timeout' => 5.0) + 'play' => 'say:Press 1 for sales, 2 for support, or 3 to leave a message.', + 'max_digits' => 1, + 'terminators' => '#', + 'digit_timeout' => 5.0) ivr.add_verb_to_section('main_menu', 'switch', - 'variable' => 'prompt_digits', - 'case' => { - '1' => [{ 'transfer' => { 'dest' => 'sales' } }], - '2' => [{ 'transfer' => { 'dest' => 'support' } }] - }) + 'variable' => 'prompt_digits', + 'case' => { + '1' => [{ 'transfer' => { 'dest' => 'sales' } }], + '2' => [{ 'transfer' => { 'dest' => 'support' } }] + }) ivr.add_verb('transfer', 'dest' => 'main_menu') # --- Call Transfer Service --- @@ -49,12 +49,12 @@ transfer.answer transfer.add_verb('play', 'url' => 'say:Connecting you with the next available agent.') transfer.add_verb('connect', - 'from' => '+15551234567', - 'timeout' => 30, - 'parallel' => [ - { 'to' => '+15552223333' }, - { 'to' => '+15554445555' } - ]) + 'from' => '+15551234567', + 'timeout' => 30, + 'parallel' => [ + { 'to' => '+15552223333' }, + { 'to' => '+15554445555' } + ]) transfer.add_verb('record', 'format' => 'mp3', 'beep' => true, 'max_length' => 120) transfer.hangup diff --git a/examples/basic_swml_service.rb b/examples/basic_swml_service.rb index 169b8061..04b332f1 100644 --- a/examples/basic_swml_service.rb +++ b/examples/basic_swml_service.rb @@ -11,7 +11,7 @@ # --- Voicemail service --- voicemail = SignalWire::SWML::Service.new( - name: 'voicemail', + name: 'voicemail', route: '/voicemail' ) @@ -20,9 +20,9 @@ voicemail.sleep(1000) voicemail.play(url: 'https://example.com/beep.wav') voicemail.record( - format: 'mp3', - stereo: false, - beep: false, + format: 'mp3', + stereo: false, + beep: false, max_length: 120, terminators: '#' ) @@ -36,17 +36,17 @@ # --- Call recording service --- recording = SignalWire::SWML::Service.new( - name: 'recording', + name: 'recording', route: '/recording' ) recording.answer recording.record_call( control_id: 'call_recording', - format: 'mp3', - stereo: true, - direction: 'both', - beep: true + format: 'mp3', + stereo: true, + direction: 'both', + beep: true ) recording.play(url: 'say:This call is being recorded for quality and training purposes.') recording.play(url: 'say:Please tell us about your experience.') @@ -62,7 +62,7 @@ # --- Call transfer service --- transfer = SignalWire::SWML::Service.new( - name: 'transfer', + name: 'transfer', route: '/transfer' ) @@ -72,9 +72,9 @@ # `serial_parallel`. Without one the document is schema-invalid and the call # never dials anywhere. transfer.connect( - to: '+15559876543', - from: '+15551234567', - timeout: 30, + to: '+15559876543', + from: '+15551234567', + timeout: 30, answer_on_bridge: true ) transfer.play(url: 'say:We apologize, but all agents are busy. Please try again later.') diff --git a/examples/call_flow_and_actions_demo.rb b/examples/call_flow_and_actions_demo.rb index 655998b2..e7f96ca4 100644 --- a/examples/call_flow_and_actions_demo.rb +++ b/examples/call_flow_and_actions_demo.rb @@ -8,9 +8,9 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'call_flow_agent', - route: '/', - record_call: true, + name: 'call_flow_agent', + route: '/', + record_call: true, record_format: 'mp3', record_stereo: true ) @@ -27,27 +27,27 @@ # Play a whisper to the agent before connecting agent.add_pre_answer_verb('play', { - 'url' => 'say:New inbound call arriving' -}) + 'url' => 'say:New inbound call arriving' + }) # --- Post-answer verbs (after answer, before AI starts) --- # Play hold music while AI initialises agent.add_post_answer_verb('play', { - 'url' => 'https://cdn.example.com/hold-music.mp3', - 'max_length' => 5 -}) + 'url' => 'https://cdn.example.com/hold-music.mp3', + 'max_length' => 5 + }) # --- Post-AI verbs (after AI conversation ends) --- # Play a closing message after the AI hangs up agent.add_post_ai_verb('play', { - 'url' => 'say:Thank you for calling. Goodbye!' -}) + 'url' => 'say:Thank you for calling. Goodbye!' + }) # --- Debug events --- -agent.enable_debug_events(2) # Level 2 for detailed events +agent.enable_debug_events(2) # Level 2 for detailed events agent.on_debug_event(nil) do |event_type, event_data| puts "[DEBUG] #{event_type}: #{event_data.inspect}" @@ -56,10 +56,10 @@ # --- Tools --- agent.define_tool( - name: 'check_availability', + name: 'check_availability', description: 'Check room availability for given dates', - parameters: { - 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, + parameters: { + 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, 'check_out' => { 'type' => 'string', 'description' => 'Check-out date (YYYY-MM-DD)' }, 'room_type' => { 'type' => 'string', 'description' => 'Room type: standard, deluxe, suite' } }, handler: nil @@ -71,13 +71,13 @@ end agent.define_tool( - name: 'make_reservation', + name: 'make_reservation', description: 'Create a hotel reservation', - parameters: { + parameters: { 'guest_name' => { 'type' => 'string', 'description' => 'Guest full name' }, - 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, - 'check_out' => { 'type' => 'string', 'description' => 'Check-out date (YYYY-MM-DD)' }, - 'room_type' => { 'type' => 'string', 'description' => 'Room type' } + 'check_in' => { 'type' => 'string', 'description' => 'Check-in date (YYYY-MM-DD)' }, + 'check_out' => { 'type' => 'string', 'description' => 'Check-out date (YYYY-MM-DD)' }, + 'room_type' => { 'type' => 'string', 'description' => 'Room type' } }, handler: nil ) do |args, _raw_data| conf_num = "RES-#{rand(100_000..999_999)}" @@ -91,9 +91,9 @@ end agent.define_tool( - name: 'transfer_to_front_desk', + name: 'transfer_to_front_desk', description: 'Transfer the call to the front desk', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |_args, _raw_data| result = SignalWire::Swaig::FunctionResult.new( 'Transferring you to the front desk now.' diff --git a/examples/comprehensive_dynamic_agent.rb b/examples/comprehensive_dynamic_agent.rb index 30f87ec6..7c060aea 100644 --- a/examples/comprehensive_dynamic_agent.rb +++ b/examples/comprehensive_dynamic_agent.rb @@ -9,21 +9,21 @@ require 'signalwire' VOICE_OPTIONS = { - 'standard' => %w[elevenlabs.rachel elevenlabs.adam], - 'premium' => %w[elevenlabs.rachel elevenlabs.adam elevenlabs.josh], + 'standard' => %w[elevenlabs.rachel elevenlabs.adam], + 'premium' => %w[elevenlabs.rachel elevenlabs.adam elevenlabs.josh], 'enterprise' => %w[elevenlabs.rachel elevenlabs.adam elevenlabs.josh elevenlabs.bella] }.freeze INDUSTRY_CONFIGS = { - 'healthcare' => { 'compliance' => 'high', 'style' => 'professional' }, - 'finance' => { 'compliance' => 'high', 'style' => 'formal' }, - 'retail' => { 'compliance' => 'medium', 'style' => 'friendly' }, - 'general' => { 'compliance' => 'standard', 'style' => 'conversational' } + 'healthcare' => { 'compliance' => 'high', 'style' => 'professional' }, + 'finance' => { 'compliance' => 'high', 'style' => 'formal' }, + 'retail' => { 'compliance' => 'medium', 'style' => 'friendly' }, + 'general' => { 'compliance' => 'standard', 'style' => 'conversational' } }.freeze agent = SignalWire::AgentBase.new( - name: 'comprehensive_dynamic', - route: '/dynamic', + name: 'comprehensive_dynamic', + route: '/dynamic', record_call: true ) @@ -74,22 +74,22 @@ case industry when 'healthcare' ephemeral.prompt_add_section('Healthcare Guidelines', - 'Follow HIPAA compliance standards. Never provide medical diagnoses.', - bullets: ['Protect patient privacy', 'Direct medical questions to providers']) + 'Follow HIPAA compliance standards. Never provide medical diagnoses.', + bullets: ['Protect patient privacy', 'Direct medical questions to providers']) when 'finance' ephemeral.prompt_add_section('Financial Guidelines', - 'Adhere to financial regulations and maintain strict confidentiality.', - bullets: ['Never provide investment advice', 'Protect financial information']) + 'Adhere to financial regulations and maintain strict confidentiality.', + bullets: ['Never provide investment advice', 'Protect financial information']) when 'retail' ephemeral.prompt_add_section('Customer Service', - 'Focus on customer satisfaction and sales support.', - bullets: ['Maintain friendly demeanor', 'Handle complaints with empathy']) + 'Focus on customer satisfaction and sales support.', + bullets: ['Maintain friendly demeanor', 'Handle complaints with empathy']) end if %w[premium enterprise].include?(tier) ephemeral.prompt_add_section('Enhanced Capabilities', - "As a #{tier} service, you have access to advanced features:", - bullets: ['Extended memory', 'Priority processing', 'Specialised knowledge bases']) + "As a #{tier} service, you have access to advanced features:", + bullets: ['Extended memory', 'Priority processing', 'Specialised knowledge bases']) end # --- Global data --- @@ -98,9 +98,9 @@ features += %w[custom_integration dedicated_support] if tier == 'enterprise' ephemeral.set_global_data( - 'service_tier' => tier, - 'industry_focus' => industry, - 'test_group' => test_group, + 'service_tier' => tier, + 'industry_focus' => industry, + 'test_group' => test_group, 'features_enabled' => features, 'compliance_level' => config['compliance'] ) @@ -108,8 +108,8 @@ # --- Debug --- if debug_mode ephemeral.prompt_add_section('Debug Mode', - 'Debug mode is enabled. Show reasoning and feature availability.', - bullets: ['Include global data references', 'Explain tier-based features']) + 'Debug mode is enabled. Show reasoning and feature availability.', + bullets: ['Include global data references', 'Explain tier-based features']) ephemeral.add_hints(%w[debug verbose reasoning tier]) end @@ -117,8 +117,8 @@ if test_group == 'B' ephemeral.add_hints(%w[enhanced personalised proactive]) ephemeral.prompt_add_section('Enhanced Style', - 'Use an enhanced conversation style:', - bullets: ['Ask clarifying questions', 'Offer proactive suggestions']) + 'Use an enhanced conversation style:', + bullets: ['Ask clarifying questions', 'Offer proactive suggestions']) end end diff --git a/examples/concierge_agent_example.rb b/examples/concierge_agent_example.rb index f8633803..2bf3d041 100644 --- a/examples/concierge_agent_example.rb +++ b/examples/concierge_agent_example.rb @@ -6,7 +6,7 @@ # and service lookups, hours of operation, and custom welcome message. require 'signalwire' -require 'signalwire/prefabs/concierge' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/concierge' # opt-in subsystem (Python: from signalwire.prefabs import ...) # Build the concierge prefab concierge = SignalWire::Prefabs::Concierge.new( @@ -21,32 +21,32 @@ ], amenities: { 'infinity pool' => { - 'hours' => '7:00 AM - 10:00 PM', - 'location' => 'Main Level, Ocean View', + 'hours' => '7:00 AM - 10:00 PM', + 'location' => 'Main Level, Ocean View', 'description' => 'Heated infinity pool with poolside service.' }, 'spa' => { - 'hours' => '9:00 AM - 8:00 PM', - 'location' => 'Lower Level, East Wing', + 'hours' => '9:00 AM - 8:00 PM', + 'location' => 'Lower Level, East Wing', 'description' => 'Full-service luxury spa.', 'reservation' => 'Required' }, 'fitness center' => { - 'hours' => '24 hours', - 'location' => '2nd Floor, North Wing', + 'hours' => '24 hours', + 'location' => '2nd Floor, North Wing', 'description' => 'State-of-the-art fitness center.' }, 'beach access' => { - 'hours' => 'Dawn to Dusk', + 'hours' => 'Dawn to Dusk', 'location' => 'Southern Pathway', 'services' => 'Beach attendants, food and beverage' } }, hours_of_operation: { - 'check-in' => '3:00 PM', - 'check-out' => '11:00 AM', - 'front desk' => '24 hours', - 'concierge' => '7:00 AM - 11:00 PM', + 'check-in' => '3:00 PM', + 'check-out' => '11:00 AM', + 'front desk' => '24 hours', + 'concierge' => '7:00 AM - 11:00 PM', 'room service' => '24 hours' }, welcome_message: 'Welcome to Oceanview Resort! I am your virtual concierge, ' \ @@ -63,9 +63,9 @@ agent.global_data = concierge.global_data agent.define_tool( - name: 'get_amenity_info', + name: 'get_amenity_info', description: 'Get information about a resort amenity', - parameters: { + parameters: { 'amenity' => { 'type' => 'string', 'description' => 'Name of the amenity' } }, handler: nil ) do |args, raw_data| @@ -73,9 +73,9 @@ end agent.define_tool( - name: 'get_service_info', + name: 'get_service_info', description: 'Get information about a resort service', - parameters: { + parameters: { 'service' => { 'type' => 'string', 'description' => 'Name of the service' } }, handler: nil ) do |args, raw_data| diff --git a/examples/contexts_demo.rb b/examples/contexts_demo.rb index 86b090af..949f331c 100644 --- a/examples/contexts_demo.rb +++ b/examples/contexts_demo.rb @@ -33,11 +33,11 @@ new_claim = ctx.add_step('new_claim') new_claim.add_section('Instructions', 'Collect the following information for the new claim:') new_claim.add_bullets('Required Fields', [ - 'Type of claim (auto, home, health)', - 'Date of incident', - 'Brief description of what happened', - 'Estimated damage amount' -]) + 'Type of claim (auto, home, health)', + 'Date of incident', + 'Brief description of what happened', + 'Estimated damage amount' + ]) new_claim.set_step_criteria( 'All four required fields have been collected and confirmed with the caller.' ) @@ -67,9 +67,9 @@ # --- Tools --- agent.define_tool( - name: 'check_claim_status', + name: 'check_claim_status', description: 'Look up the status of an existing insurance claim', - parameters: { + parameters: { 'claim_number' => { 'type' => 'string', 'description' => 'The claim number to look up' } }, handler: nil ) do |args, _raw_data| @@ -81,13 +81,13 @@ end agent.define_tool( - name: 'submit_claim', + name: 'submit_claim', description: 'Submit a new insurance claim', - parameters: { - 'type' => { 'type' => 'string', 'description' => 'Claim type: auto, home, or health' }, - 'date' => { 'type' => 'string', 'description' => 'Date of incident (YYYY-MM-DD)' }, + parameters: { + 'type' => { 'type' => 'string', 'description' => 'Claim type: auto, home, or health' }, + 'date' => { 'type' => 'string', 'description' => 'Date of incident (YYYY-MM-DD)' }, 'description' => { 'type' => 'string', 'description' => 'Description of the incident' }, - 'amount' => { 'type' => 'number', 'description' => 'Estimated damage amount in USD' } + 'amount' => { 'type' => 'number', 'description' => 'Estimated damage amount in USD' } }, handler: nil ) do |args, _raw_data| claim_num = "CLM-#{rand(100_000..999_999)}" diff --git a/examples/custom_path_agent.rb b/examples/custom_path_agent.rb index 9ef38d8a..fb7b6280 100644 --- a/examples/custom_path_agent.rb +++ b/examples/custom_path_agent.rb @@ -10,8 +10,8 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'Chat Assistant', - route: '/chat', + name: 'Chat Assistant', + route: '/chat', record_call: true ) @@ -40,9 +40,9 @@ ephemeral.prompt_add_section('Communication Style', style) ephemeral.set_global_data( - 'user_name' => user_name, - 'topic' => topic, - 'mood' => mood, + 'user_name' => user_name, + 'topic' => topic, + 'mood' => mood, 'session_type' => 'chat' ) diff --git a/examples/datamap_demo.rb b/examples/datamap_demo.rb index 818f3369..f2b4df45 100644 --- a/examples/datamap_demo.rb +++ b/examples/datamap_demo.rb @@ -18,27 +18,27 @@ # --- DataMap Tool 1: Weather API --- weather = SignalWire::DataMap.new('get_weather') - .purpose('Get the current weather for a location') - .parameter('city', 'string', 'City name', required: true) - .parameter('units', 'string', 'Temperature units: metric or imperial', required: false) - .webhook('GET', 'https://api.weatherapi.com/v1/current.json?key=${global_data.weather_api_key}&q=${args.city}') - .output( - SignalWire::Swaig::FunctionResult.new( - 'Current weather in ${args.city}: ${response.current.temp_f}F ' \ - '(${response.current.temp_c}C), ${response.current.condition.text}. ' \ - 'Wind: ${response.current.wind_mph} mph.' - ) - ) + .purpose('Get the current weather for a location') + .parameter('city', 'string', 'City name', required: true) + .parameter('units', 'string', 'Temperature units: metric or imperial', required: false) + .webhook('GET', 'https://api.weatherapi.com/v1/current.json?key=${global_data.weather_api_key}&q=${args.city}') + .output( + SignalWire::Swaig::FunctionResult.new( + 'Current weather in ${args.city}: ${response.current.temp_f}F ' \ + '(${response.current.temp_c}C), ${response.current.condition.text}. ' \ + 'Wind: ${response.current.wind_mph} mph.' + ) + ) agent.register_swaig_function(weather.to_swaig_function) # --- DataMap Tool 2: Expression-based calculator --- calculator = SignalWire::DataMap.new('simple_math') - .purpose('Evaluate a simple math expression') - .parameter('expression', 'string', 'A math expression like "add", "subtract"', required: true) - .parameter('a', 'number', 'First number', required: true) - .parameter('b', 'number', 'Second number', required: true) + .purpose('Evaluate a simple math expression') + .parameter('expression', 'string', 'A math expression like "add", "subtract"', required: true) + .parameter('a', 'number', 'First number', required: true) + .parameter('b', 'number', 'Second number', required: true) calculator.expression( '${args.expression}', @@ -58,10 +58,10 @@ # --- DataMap Tool 3: Simple API tool (class method shortcut) --- joke = SignalWire::DataMap.create_simple_api_tool( - name: 'get_joke', - url: 'https://official-joke-api.appspot.com/random_joke', + name: 'get_joke', + url: 'https://official-joke-api.appspot.com/random_joke', response_template: 'Here is a joke: ${response.setup} ... ${response.punchline}', - method: 'GET' + method: 'GET' ) agent.register_swaig_function(joke.to_swaig_function) diff --git a/examples/datasphere.rb b/examples/datasphere.rb index b9e48ea7..512f5b72 100644 --- a/examples/datasphere.rb +++ b/examples/datasphere.rb @@ -19,7 +19,7 @@ agent.add_skill('datetime') agent.add_skill('math') puts 'Added datetime and math skills' -rescue => e +rescue StandardError => e puts "Skill load warning: #{e.message}" end @@ -27,48 +27,48 @@ example_config = { 'space_name' => 'your-space', 'project_id' => 'your-project-id', - 'token' => 'your-token' + 'token' => 'your-token' } # Instance 1: Drinks knowledge begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'drinks-doc-123', - 'tool_name' => 'search_drinks_knowledge', - 'tags' => %w[Drinks Bar Cocktails], - 'count' => 2, - 'distance' => 5.0, - 'no_results_message' => "I couldn't find drink info about '{query}'. Try a different cocktail." - )) + 'document_id' => 'drinks-doc-123', + 'tool_name' => 'search_drinks_knowledge', + 'tags' => %w[Drinks Bar Cocktails], + 'count' => 2, + 'distance' => 5.0, + 'no_results_message' => "I couldn't find drink info about '{query}'. Try a different cocktail." + )) puts 'Added drinks knowledge (tool: search_drinks_knowledge)' -rescue => e +rescue StandardError => e puts "Drinks DataSphere: #{e.message}" end # Instance 2: Food knowledge begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'food-doc-456', - 'tool_name' => 'search_food_knowledge', - 'tags' => %w[Food Recipes Cooking], - 'count' => 3, - 'distance' => 4.0, - 'no_results_message' => "I couldn't find recipes about '{query}'. Try a different dish." - )) + 'document_id' => 'food-doc-456', + 'tool_name' => 'search_food_knowledge', + 'tags' => %w[Food Recipes Cooking], + 'count' => 3, + 'distance' => 4.0, + 'no_results_message' => "I couldn't find recipes about '{query}'. Try a different dish." + )) puts 'Added food knowledge (tool: search_food_knowledge)' -rescue => e +rescue StandardError => e puts "Food DataSphere: #{e.message}" end # Instance 3: General knowledge (default tool name) begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'general-doc-789', - 'count' => 1, - 'distance' => 3.0 - )) + 'document_id' => 'general-doc-789', + 'count' => 1, + 'distance' => 3.0 + )) puts 'Added general knowledge (tool: search_knowledge)' -rescue => e +rescue StandardError => e puts "General DataSphere: #{e.message}" end diff --git a/examples/datasphere_multi_instance_demo.rb b/examples/datasphere_multi_instance_demo.rb index fa36fb15..49ec6c27 100644 --- a/examples/datasphere_multi_instance_demo.rb +++ b/examples/datasphere_multi_instance_demo.rb @@ -20,55 +20,55 @@ begin agent.add_skill('datetime') agent.add_skill('math') -rescue => e +rescue StandardError => e puts "Skill warning: #{e.message}" end example_config = { 'space_name' => 'your-space', 'project_id' => 'your-project-id', - 'token' => 'your-token' + 'token' => 'your-token' } # Instance 1: Drinks knowledge begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'drinks-doc-123', - 'tool_name' => 'search_drinks_knowledge', - 'count' => 2, - 'distance' => 5.0 - )) + 'document_id' => 'drinks-doc-123', + 'tool_name' => 'search_drinks_knowledge', + 'count' => 2, + 'distance' => 5.0 + )) puts 'Added drinks knowledge (tool: search_drinks_knowledge)' -rescue => e +rescue StandardError => e puts "Drinks DataSphere: #{e.message}" end # Instance 2: Food knowledge begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'food-doc-456', - 'tool_name' => 'search_food_knowledge', - 'count' => 3, - 'distance' => 4.0 - )) + 'document_id' => 'food-doc-456', + 'tool_name' => 'search_food_knowledge', + 'count' => 3, + 'distance' => 4.0 + )) puts 'Added food knowledge (tool: search_food_knowledge)' -rescue => e +rescue StandardError => e puts "Food DataSphere: #{e.message}" end # Instance 3: General knowledge (default tool name) begin agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'general-doc-789', - 'count' => 1, - 'distance' => 3.0 - )) + 'document_id' => 'general-doc-789', + 'count' => 1, + 'distance' => 3.0 + )) puts 'Added general knowledge (tool: search_knowledge)' -rescue => e +rescue StandardError => e puts "General DataSphere: #{e.message}" end puts "\nTools: search_drinks_knowledge, search_food_knowledge, search_knowledge" -puts "Note: Replace credentials with your actual DataSphere details." +puts 'Note: Replace credentials with your actual DataSphere details.' puts "Starting multi-datasphere agent on port #{agent.port}..." agent.run diff --git a/examples/datasphere_serverless_env.rb b/examples/datasphere_serverless_env.rb index f2814239..15b07622 100644 --- a/examples/datasphere_serverless_env.rb +++ b/examples/datasphere_serverless_env.rb @@ -9,7 +9,7 @@ require 'signalwire' def require_env(name) - value = ENV[name] + value = ENV.fetch(name, nil) abort("Error: Required environment variable #{name} is not set.") unless value && !value.empty? value end @@ -31,27 +31,27 @@ def require_env(name) begin agent.add_skill('datetime') agent.add_skill('math') -rescue => e +rescue StandardError => e puts "Skill warning: #{e.message}" end config = { 'document_id' => document_id, - 'count' => count, - 'distance' => distance + 'count' => count, + 'distance' => distance } -tags_str = ENV['DATASPHERE_TAGS'] +tags_str = ENV.fetch('DATASPHERE_TAGS', nil) config['tags'] = tags_str.split(',').map(&:strip) if tags_str && !tags_str.empty? begin agent.add_skill('datasphere', config) puts 'Added DataSphere serverless skill' -rescue => e +rescue StandardError => e puts "DataSphere error: #{e.message}" end -puts "DataSphere Serverless Environment Demo" +puts 'DataSphere Serverless Environment Demo' puts " Document: #{document_id}" puts " Count: #{count}, Distance: #{distance}" puts "Starting agent on port #{agent.port}..." diff --git a/examples/datasphere_webhook_env_demo.rb b/examples/datasphere_webhook_env_demo.rb index fdbe2eb7..5c0e967f 100644 --- a/examples/datasphere_webhook_env_demo.rb +++ b/examples/datasphere_webhook_env_demo.rb @@ -8,7 +8,7 @@ require 'signalwire' def require_env(name) - value = ENV[name] + value = ENV.fetch(name, nil) abort("Error: Required environment variable #{name} is not set.") unless value && !value.empty? value end @@ -29,18 +29,18 @@ def require_env(name) begin agent.add_skill('datetime') agent.add_skill('math') -rescue => e +rescue StandardError => e puts "Skill warning: #{e.message}" end begin agent.add_skill('datasphere', - 'document_id' => document_id, - 'count' => count, - 'distance' => distance, - 'mode' => 'webhook') + 'document_id' => document_id, + 'count' => count, + 'distance' => distance, + 'mode' => 'webhook') puts 'Added DataSphere webhook skill' -rescue => e +rescue StandardError => e puts "DataSphere error: #{e.message}" end diff --git a/examples/declarative_agent.rb b/examples/declarative_agent.rb index d26a648c..ed1edc9e 100644 --- a/examples/declarative_agent.rb +++ b/examples/declarative_agent.rb @@ -9,7 +9,7 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'declarative', + name: 'declarative', route: '/declarative' ) @@ -26,11 +26,11 @@ ) agent.prompt_add_section('Instructions', nil, bullets: [ - 'Be concise and direct in your responses.', - "If you don't know something, say so clearly.", - 'Use the get_time function when asked about the current time.', - 'Use the get_weather function when asked about the weather.' -]) + 'Be concise and direct in your responses.', + "If you don't know something, say so clearly.", + 'Use the get_time function when asked about the current time.', + 'Use the get_weather function when asked about the weather.' + ]) # --- Post-prompt for summary --- @@ -42,23 +42,23 @@ "follow_up_needed": true/false } PROMPT -) + ) # --- Tools --- agent.define_tool( - name: 'get_time', + name: 'get_time', description: 'Get the current time', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |_args, _raw_data| now = Time.now.strftime('%H:%M:%S') SignalWire::Swaig::FunctionResult.new("The current time is #{now}") end agent.define_tool( - name: 'get_weather', + name: 'get_weather', description: 'Get the current weather for a location', - parameters: { + parameters: { 'location' => { 'type' => 'string', 'description' => 'City or location' } }, handler: nil ) do |args, _raw_data| diff --git a/examples/dynamic_info_gatherer_example.rb b/examples/dynamic_info_gatherer_example.rb index ff11169b..6d278813 100644 --- a/examples/dynamic_info_gatherer_example.rb +++ b/examples/dynamic_info_gatherer_example.rb @@ -9,7 +9,7 @@ # /contact?set=onboarding require 'signalwire' -require 'signalwire/prefabs/info_gatherer' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/info_gatherer' # opt-in subsystem (Python: from signalwire.prefabs import ...) question_sets = { 'default' => [ @@ -40,8 +40,8 @@ agent = SignalWire::Prefabs::InfoGatherer.new( questions: nil, # dynamic mode - name: 'dynamic-intake', - route: '/contact' + name: 'dynamic-intake', + route: '/contact' ) # set_question_callback takes a callable (parity with Python's positional diff --git a/examples/dynamic_swml_service.rb b/examples/dynamic_swml_service.rb index c3e83bfd..c41f7f6f 100644 --- a/examples/dynamic_swml_service.rb +++ b/examples/dynamic_swml_service.rb @@ -10,7 +10,7 @@ require 'json' service = SignalWire::SWML::Service.new( - name: 'dynamic-greeting', + name: 'dynamic-greeting', route: '/greeting' ) @@ -37,13 +37,14 @@ service.register_routing_callback(nil, '/new') do |_request_data| doc = SignalWire::SWML::Document.new doc.add_verb('answer', {}) - doc.add_verb('play', { 'url' => 'say:Welcome to our service! Press 1 to learn about our products, 2 to speak with sales.' }) + doc.add_verb('play', + { 'url' => 'say:Welcome to our service! Press 1 to learn about our products, 2 to speak with sales.' }) doc.add_verb('hangup', {}) doc.to_h end puts "Starting dynamic SWML service on port #{service.port}..." -puts " GET/POST /greeting -- Default greeting" -puts " POST /greeting/vip -- VIP greeting" -puts " POST /greeting/new -- New customer greeting" +puts ' GET/POST /greeting -- Default greeting' +puts ' POST /greeting/vip -- VIP greeting' +puts ' POST /greeting/new -- New customer greeting' service.serve diff --git a/examples/faq_bot_agent.rb b/examples/faq_bot_agent.rb index d3d94e81..9339adc2 100644 --- a/examples/faq_bot_agent.rb +++ b/examples/faq_bot_agent.rb @@ -6,27 +6,27 @@ # pre-defined knowledge base and logs conversation summaries. require 'signalwire' -require 'signalwire/prefabs/faq_bot' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/faq_bot' # opt-in subsystem (Python: from signalwire.prefabs import ...) faqs = [ { 'question' => 'What is SignalWire?', - 'answer' => 'SignalWire is a communications platform providing APIs for voice, video, and messaging.' + 'answer' => 'SignalWire is a communications platform providing APIs for voice, video, and messaging.' }, { 'question' => 'How do I create an AI Agent?', - 'answer' => 'Use the SignalWire AI Agent SDK to build and deploy conversational AI agents.' + 'answer' => 'Use the SignalWire AI Agent SDK to build and deploy conversational AI agents.' }, { 'question' => 'What is SWML?', - 'answer' => 'SWML (SignalWire Markup Language) is a markup language for defining communications workflows.' + 'answer' => 'SWML (SignalWire Markup Language) is a markup language for defining communications workflows.' } ] faq_bot = SignalWire::Prefabs::FaqBot.new( - faqs: faqs, - name: 'signalwire_faq', - route: '/faq', + faqs: faqs, + name: 'signalwire_faq', + route: '/faq', persona: 'You are a helpful FAQ assistant for SignalWire.' ) @@ -38,17 +38,17 @@ end agent.prompt_add_section('Instructions', nil, bullets: [ - 'Only answer questions if the information is in the FAQ knowledge base.', - 'If you do not know the answer, politely say so and offer to help with something else.', - 'Be concise and direct in your responses.' -]) + 'Only answer questions if the information is in the FAQ knowledge base.', + 'If you do not know the answer, politely say so and offer to help with something else.', + 'Be concise and direct in your responses.' + ]) agent.global_data = faq_bot.global_data agent.define_tool( - name: 'search_faq', + name: 'search_faq', description: 'Search the FAQ knowledge base', - parameters: { + parameters: { 'query' => { 'type' => 'string', 'description' => 'Search query' } }, handler: nil ) do |args, raw_data| diff --git a/examples/gather_info_demo.rb b/examples/gather_info_demo.rb index cd2170e6..d28413a4 100644 --- a/examples/gather_info_demo.rb +++ b/examples/gather_info_demo.rb @@ -9,7 +9,7 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'Patient Intake Agent', + name: 'Patient Intake Agent', route: '/patient-intake' ) @@ -30,7 +30,7 @@ step1.text = 'Collect the patient\'s basic information.' step1.set_gather_info( output_key: 'patient_demographics', - prompt: 'Please collect the following patient information.' + prompt: 'Please collect the following patient information.' ) step1.add_gather_question(key: 'full_name', question: 'What is your full name?') step1.add_gather_question(key: 'date_of_birth', question: 'What is your date of birth?') @@ -43,11 +43,12 @@ step2.text = 'Ask about the patient\'s current symptoms and reason for visit.' step2.set_gather_info( output_key: 'patient_symptoms', - prompt: "Now let's talk about why you're visiting today." + prompt: "Now let's talk about why you're visiting today." ) step2.add_gather_question(key: 'reason_for_visit', question: 'What is the main reason for your visit today?') step2.add_gather_question(key: 'symptom_duration', question: 'How long have you been experiencing these symptoms?') -step2.add_gather_question(key: 'pain_level', question: 'On a scale of 1 to 10, how would you rate your discomfort?') +step2.add_gather_question(key: 'pain_level', + question: 'On a scale of 1 to 10, how would you rate your discomfort?') step2.valid_steps = %w[confirmation] # Step 3: Confirmation (normal step, not gather) diff --git a/examples/gather_per_question_functions_demo.rb b/examples/gather_per_question_functions_demo.rb index 6d5f097f..97bea3a5 100644 --- a/examples/gather_per_question_functions_demo.rb +++ b/examples/gather_per_question_functions_demo.rb @@ -30,7 +30,7 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'gather_per_question_functions_demo', + name: 'gather_per_question_functions_demo', route: '/' ) @@ -38,36 +38,36 @@ # questioning, they're all locked out unless they appear in a question's # `functions` whitelist. agent.define_tool( - name: 'validate_email', + name: 'validate_email', description: 'Validate that an email address is well-formed and deliverable', - parameters: { 'email' => { 'type' => 'string' } }, handler: nil + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'valid' } } agent.define_tool( - name: 'geocode_zip', + name: 'geocode_zip', description: 'Look up the city/state for a US ZIP code', - parameters: { 'zip' => { 'type' => 'string' } }, handler: nil + parameters: { 'zip' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => '{"city":"...","state":"..."}' } } agent.define_tool( - name: 'check_age_eligibility', + name: 'check_age_eligibility', description: 'Verify the customer is old enough for the product', - parameters: { 'age' => { 'type' => 'integer' } }, handler: nil + parameters: { 'age' => { 'type' => 'integer' } }, handler: nil ) { |_args, _raw| { 'response' => 'eligible' } } # These tools are NOT whitelisted on any gather question. They are # registered on the agent and active outside the gather, but during the # gather they cannot be called — gather mode locks them out. agent.define_tool( - name: 'escalate_to_human', + name: 'escalate_to_human', description: 'Transfer the conversation to a live agent', - parameters: {}, handler: nil + parameters: {}, handler: nil ) { |_args, _raw| { 'response' => 'transferred' } } agent.define_tool( - name: 'lookup_existing_account', + name: 'lookup_existing_account', description: 'Search for an existing account by email', - parameters: { 'email' => { 'type' => 'string' } }, handler: nil + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'not found' } } # Build a single-context agent with one onboarding step. @@ -75,21 +75,21 @@ onboard = ctx.add_step('onboard') onboard.set_text( - "Onboard a new customer by collecting their details. Use " \ - "gather_info to ask one question at a time. Each question may " \ - "unlock a specific validation tool — only that tool and " \ - "gather_submit are callable while answering it." + 'Onboard a new customer by collecting their details. Use ' \ + 'gather_info to ask one question at a time. Each question may ' \ + 'unlock a specific validation tool — only that tool and ' \ + 'gather_submit are callable while answering it.' ) onboard.set_functions(%w[ - escalate_to_human - lookup_existing_account -]) + escalate_to_human + lookup_existing_account + ]) # Outside of the gather (which is the entire step here), these would be # available. During the gather they are forcibly hidden in favor of the # per-question whitelists. onboard.set_gather_info( - output_key: 'customer', + output_key: 'customer', completion_action: 'next_step', prompt: "I'll need to collect a few details to set up your " \ "account. I'll ask one question at a time." @@ -97,24 +97,24 @@ # Question 1: email — only validate_email + gather_submit callable. onboard.add_gather_question( - key: 'email', - question: "What's your email address?", - confirm: true, + key: 'email', + question: "What's your email address?", + confirm: true, functions: %w[validate_email] ) # Question 2: zip — only geocode_zip + gather_submit callable. onboard.add_gather_question( - key: 'zip', - question: "What's your ZIP code?", + key: 'zip', + question: "What's your ZIP code?", functions: %w[geocode_zip] ) # Question 3: age — only check_age_eligibility + gather_submit callable. onboard.add_gather_question( - key: 'age', - question: 'How old are you?', - type: 'integer', + key: 'age', + question: 'How old are you?', + type: 'integer', functions: %w[check_age_eligibility] ) @@ -122,15 +122,15 @@ # callable. The model cannot validate, lookup, escalate — nothing. This # is the right pattern when a question needs no tools. onboard.add_gather_question( - key: 'referral_source', + key: 'referral_source', question: 'How did you hear about us?' ) # A simple confirmation step the gather auto-advances into. ctx.add_step('confirm') .set_text( - "Read the collected info back to the customer and confirm " \ - "everything is correct." + 'Read the collected info back to the customer and confirm ' \ + 'everything is correct.' ) .set_functions([]) .set_end(true) diff --git a/examples/info_gatherer_example.rb b/examples/info_gatherer_example.rb index 8a91df1b..ea7633bc 100644 --- a/examples/info_gatherer_example.rb +++ b/examples/info_gatherer_example.rb @@ -6,31 +6,31 @@ # a structured set of questions, confirms answers, and collects results. require 'signalwire' -require 'signalwire/prefabs/info_gatherer' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/info_gatherer' # opt-in subsystem (Python: from signalwire.prefabs import ...) # Create the InfoGatherer prefab gatherer = SignalWire::Prefabs::InfoGatherer.new( questions: [ { - 'key_name' => 'full_name', + 'key_name' => 'full_name', 'question_text' => 'What is your full name?' }, { - 'key_name' => 'email', + 'key_name' => 'email', 'question_text' => 'What is your email address?', - 'confirm' => true + 'confirm' => true }, { - 'key_name' => 'phone', + 'key_name' => 'phone', 'question_text' => 'What is the best phone number to reach you?', - 'confirm' => true + 'confirm' => true }, { - 'key_name' => 'reason', + 'key_name' => 'reason', 'question_text' => 'In a few words, what is the reason for your call today?' } ], - name: 'intake_form', + name: 'intake_form', route: '/intake' ) @@ -47,17 +47,17 @@ # Register the prefab's tool handlers agent.define_tool( - name: 'start_questions', + name: 'start_questions', description: 'Start the question sequence', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |args, raw_data| gatherer.handle_start(args, raw_data) end agent.define_tool( - name: 'submit_answer', + name: 'submit_answer', description: 'Submit an answer to the current question', - parameters: { + parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's answer" } }, handler: nil ) do |args, raw_data| diff --git a/examples/joke_agent.rb b/examples/joke_agent.rb index 2be05ba3..1489f679 100644 --- a/examples/joke_agent.rb +++ b/examples/joke_agent.rb @@ -7,7 +7,7 @@ require 'signalwire' -api_key = ENV['API_NINJAS_KEY'] +api_key = ENV.fetch('API_NINJAS_KEY', nil) unless api_key puts 'Error: API_NINJAS_KEY environment variable is required.' puts 'Get your free API key from https://api.api-ninjas.com/' @@ -16,7 +16,7 @@ end agent = SignalWire::AgentBase.new( - name: 'Joke Skill Demo', + name: 'Joke Skill Demo', route: '/joke-skill' ) @@ -26,10 +26,10 @@ ) agent.prompt_add_section('Instructions', nil, bullets: [ - 'When users ask for jokes, use your joke functions to provide them.', - 'Be enthusiastic and fun in your responses.', - 'You can tell both regular jokes and dad jokes.' -]) + 'When users ask for jokes, use your joke functions to provide them.', + 'Be enthusiastic and fun in your responses.', + 'You can tell both regular jokes and dad jokes.' + ]) # Add the built-in joke skill agent.add_skill('joke', 'api_key' => api_key) diff --git a/examples/joke_skill_demo.rb b/examples/joke_skill_demo.rb index 9db6f3a5..793b679e 100644 --- a/examples/joke_skill_demo.rb +++ b/examples/joke_skill_demo.rb @@ -9,9 +9,11 @@ require 'signalwire' -api_key = ENV['API_NINJAS_KEY'] -abort("Error: API_NINJAS_KEY environment variable is required.\n" \ - "Get your free API key from https://api.api-ninjas.com/") unless api_key +api_key = ENV.fetch('API_NINJAS_KEY', nil) +unless api_key + abort("Error: API_NINJAS_KEY environment variable is required.\n" \ + 'Get your free API key from https://api.api-ninjas.com/') +end agent = SignalWire::AgentBase.new(name: 'joke-skill-demo', route: '/joke-skill') @@ -23,10 +25,10 @@ ) agent.prompt_add_section('Instructions', nil, bullets: [ - 'When users ask for jokes, use your joke functions to provide them', - 'Be enthusiastic and fun in your responses', - 'You can tell both regular jokes and dad jokes' -]) + 'When users ask for jokes, use your joke functions to provide them', + 'Be enthusiastic and fun in your responses', + 'You can tell both regular jokes and dad jokes' + ]) agent.add_skill('joke', 'api_key' => api_key) diff --git a/examples/kubernetes_ready_agent.rb b/examples/kubernetes_ready_agent.rb index 48f75ba0..2fb45dc3 100644 --- a/examples/kubernetes_ready_agent.rb +++ b/examples/kubernetes_ready_agent.rb @@ -14,10 +14,10 @@ port = Integer(ENV.fetch('PORT', 8080)) agent = SignalWire::AgentBase.new( - name: 'k8s-agent', + name: 'k8s-agent', route: '/', - host: '0.0.0.0', - port: port + host: '0.0.0.0', + port: port ) agent.add_language('English', 'en-US', 'elevenlabs.rachel') @@ -29,9 +29,9 @@ ) agent.define_tool( - name: 'health_status', + name: 'health_status', description: 'Get the health status of this agent', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new( "Agent '#{agent.name}' is healthy, running on port #{agent.port} in Kubernetes." diff --git a/examples/lambda_agent.rb b/examples/lambda_agent.rb index 00dad3a7..56c2ee3e 100644 --- a/examples/lambda_agent.rb +++ b/examples/lambda_agent.rb @@ -25,7 +25,7 @@ require 'signalwire' AGENT = SignalWire::AgentBase.new( - name: 'lambda-agent', + name: 'lambda-agent', route: '/' ) @@ -37,15 +37,15 @@ ) AGENT.prompt_add_section('Instructions', nil, bullets: [ - 'Greet users warmly and offer help.', - 'Use the greet_user function when asked to greet someone.', - 'Use the get_time function when asked about the current time.' -]) + 'Greet users warmly and offer help.', + 'Use the greet_user function when asked to greet someone.', + 'Use the get_time function when asked about the current time.' + ]) AGENT.define_tool( - name: 'greet_user', + name: 'greet_user', description: 'Greet a user by name', - parameters: { + parameters: { 'name' => { 'type' => 'string', 'description' => 'Name to greet' } }, handler: nil ) do |args, _raw_data| @@ -54,9 +54,9 @@ end AGENT.define_tool( - name: 'get_time', + name: 'get_time', description: 'Get the current time', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("Current time: #{Time.now.iso8601}") end diff --git a/examples/llm_params_demo.rb b/examples/llm_params_demo.rb index 52e6d686..33cace2c 100644 --- a/examples/llm_params_demo.rb +++ b/examples/llm_params_demo.rb @@ -14,15 +14,15 @@ precise.prompt_add_section('Role', 'You are a precise technical assistant.') precise.prompt_add_section('Instructions', nil, bullets: [ - 'Provide accurate, factual information.', - 'Be concise and direct.', - 'If uncertain, say so clearly.' -]) + 'Provide accurate, factual information.', + 'Be concise and direct.', + 'If uncertain, say so clearly.' + ]) precise.set_prompt_llm_params( - temperature: 0.2, - top_p: 0.85, - presence_penalty: 0.0, + temperature: 0.2, + top_p: 0.85, + presence_penalty: 0.0, frequency_penalty: 0.1 ) @@ -43,15 +43,15 @@ creative.prompt_add_section('Role', 'You are a creative writing assistant.') creative.prompt_add_section('Instructions', nil, bullets: [ - 'Be imaginative and creative.', - 'Use varied vocabulary.', - 'Encourage creative thinking.' -]) + 'Be imaginative and creative.', + 'Use varied vocabulary.', + 'Encourage creative thinking.' + ]) creative.set_prompt_llm_params( - temperature: 0.8, - top_p: 0.95, - presence_penalty: 0.2, + temperature: 0.8, + top_p: 0.95, + presence_penalty: 0.2, frequency_penalty: 0.3 ) @@ -65,8 +65,8 @@ theme = args['theme'] || 'adventure' prompts = { 'adventure' => 'A map that only appears during thunderstorms', - 'mystery' => 'A photograph where people keep disappearing', - 'default' => 'An ordinary object with extraordinary powers' + 'mystery' => 'A photograph where people keep disappearing', + 'default' => 'An ordinary object with extraordinary powers' } SignalWire::Swaig::FunctionResult.new( "Story prompt for #{theme}: #{prompts.fetch(theme.downcase, prompts['default'])}" @@ -79,15 +79,15 @@ support.prompt_add_section('Role', 'You are a professional customer service representative.') support.prompt_add_section('Guidelines', nil, bullets: [ - 'Always be polite and empathetic.', - 'Listen carefully to customer concerns.', - 'Provide clear, helpful solutions.' -]) + 'Always be polite and empathetic.', + 'Listen carefully to customer concerns.', + 'Provide clear, helpful solutions.' + ]) support.set_prompt_llm_params( - temperature: 0.4, - top_p: 0.9, - presence_penalty: 0.1, + temperature: 0.4, + top_p: 0.9, + presence_penalty: 0.1, frequency_penalty: 0.1 ) diff --git a/examples/mcp_agent.rb b/examples/mcp_agent.rb old mode 100644 new mode 100755 index ac4abed1..756475d1 --- a/examples/mcp_agent.rb +++ b/examples/mcp_agent.rb @@ -43,8 +43,8 @@ # -- Agent Configuration ------------------------------------------------------ agent.prompt_add_section('Role', - 'You are a helpful customer support agent. ' \ - 'Use the available tools to look up information and assist the caller.') + 'You are a helpful customer support agent. ' \ + 'Use the available tools to look up information and assist the caller.') agent.params = { 'attention_timeout' => 15_000 } @@ -64,7 +64,7 @@ name: 'create_ticket', description: 'Create a support ticket for the customer', parameters: { - 'subject' => { 'type' => 'string', 'description' => 'Ticket subject' }, + 'subject' => { 'type' => 'string', 'description' => 'Ticket subject' }, 'description' => { 'type' => 'string', 'description' => 'Detailed description' } }, handler: nil ) do |args, _raw| diff --git a/examples/multi_agent_server.rb b/examples/multi_agent_server.rb index f5c9383b..e64afc2e 100644 --- a/examples/multi_agent_server.rb +++ b/examples/multi_agent_server.rb @@ -12,18 +12,18 @@ sales = SignalWire::AgentBase.new(name: 'sales', route: '/sales') sales.prompt_add_section('Role', 'You are a sales representative for TechCo.') sales.prompt_add_section('Guidelines', nil, bullets: [ - 'Be enthusiastic about our products.', - 'Offer to schedule a demo if the caller is interested.', - 'Never discuss competitor products.' -]) + 'Be enthusiastic about our products.', + 'Offer to schedule a demo if the caller is interested.', + 'Never discuss competitor products.' + ]) sales.add_hints(%w[pricing demo trial enterprise]) sales.define_tool( - name: 'schedule_demo', + name: 'schedule_demo', description: 'Schedule a product demo for the caller', - parameters: { + parameters: { 'email' => { 'type' => 'string', 'description' => 'Caller email address' }, - 'date' => { 'type' => 'string', 'description' => 'Preferred date (YYYY-MM-DD)' } + 'date' => { 'type' => 'string', 'description' => 'Preferred date (YYYY-MM-DD)' } }, handler: nil ) do |args, _raw_data| SignalWire::Swaig::FunctionResult.new( @@ -37,16 +37,16 @@ support = SignalWire::AgentBase.new(name: 'support', route: '/support') support.prompt_add_section('Role', 'You are a technical support agent for TechCo.') support.prompt_add_section('Guidelines', nil, bullets: [ - 'Ask for the ticket number first.', - 'Walk through troubleshooting steps methodically.', - 'Escalate to a human if the issue cannot be resolved.' -]) + 'Ask for the ticket number first.', + 'Walk through troubleshooting steps methodically.', + 'Escalate to a human if the issue cannot be resolved.' + ]) support.add_hints(%w[ticket error crash login password]) support.define_tool( - name: 'lookup_ticket', + name: 'lookup_ticket', description: 'Look up a support ticket by number', - parameters: { + parameters: { 'ticket_number' => { 'type' => 'string', 'description' => 'The support ticket number' } }, handler: nil ) do |args, _raw_data| @@ -61,18 +61,18 @@ receptionist = SignalWire::AgentBase.new(name: 'receptionist', route: '/reception') receptionist.prompt_add_section('Role', 'You are the main receptionist for TechCo.') receptionist.prompt_add_section('Guidelines', nil, bullets: [ - 'Greet callers warmly.', - 'Ask how you can direct their call.', - 'Transfer to the appropriate department.' -]) + 'Greet callers warmly.', + 'Ask how you can direct their call.', + 'Transfer to the appropriate department.' + ]) receptionist.add_hints(%w[sales support billing hours directions]) receptionist.define_tool( - name: 'transfer_call', + name: 'transfer_call', description: 'Transfer the caller to a department', - parameters: { + parameters: { 'department' => { - 'type' => 'string', + 'type' => 'string', 'description' => 'Department name: sales, support, or billing' } }, handler: nil diff --git a/examples/multi_endpoint_agent.rb b/examples/multi_endpoint_agent.rb index 51cefa51..6d571e67 100644 --- a/examples/multi_endpoint_agent.rb +++ b/examples/multi_endpoint_agent.rb @@ -17,10 +17,10 @@ voice = SignalWire::AgentBase.new(name: 'voice-assistant', route: '/voice') voice.prompt_add_section('Role', 'You are a helpful voice assistant.') voice.prompt_add_section('Instructions', nil, bullets: [ - 'Greet callers warmly.', - 'Be concise in your responses.', - 'Use the get_time function when asked about the current time.' -]) + 'Greet callers warmly.', + 'Be concise in your responses.', + 'Use the get_time function when asked about the current time.' + ]) voice.add_language('English', 'en-US', 'elevenlabs.rachel') voice.define_tool( @@ -35,10 +35,10 @@ info = SignalWire::AgentBase.new(name: 'info-desk', route: '/info') info.prompt_add_section('Role', 'You are an information desk assistant.') info.prompt_add_section('Guidelines', nil, bullets: [ - 'Provide accurate information about the building and services.', - 'Direct callers to the correct department.', - 'Be polite and professional.' -]) + 'Provide accurate information about the building and services.', + 'Direct callers to the correct department.', + 'Be polite and professional.' + ]) info.define_tool( name: 'get_directory', description: 'Look up a department', diff --git a/examples/quickstart_agent.rb b/examples/quickstart_agent.rb index b962c3e9..4580fa76 100644 --- a/examples/quickstart_agent.rb +++ b/examples/quickstart_agent.rb @@ -19,10 +19,10 @@ AGENT.prompt_add_section('Role', 'You are a helpful assistant.') AGENT.define_tool( - name: 'get_time', + name: 'get_time', description: 'Get the current time', - parameters: {}, - handler: nil # the block below is the handler + parameters: {}, + handler: nil # the block below is the handler ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("The time is #{Time.now.strftime('%H:%M:%S')}") end diff --git a/examples/quickstart_relay.rb b/examples/quickstart_relay.rb index c307a611..dbbc7c36 100644 --- a/examples/quickstart_relay.rb +++ b/examples/quickstart_relay.rb @@ -10,9 +10,9 @@ require 'signalwire/relay/client' client = SignalWire::Relay::Client.new( - project: 'your-project-id', - token: 'your-api-token', - space: 'example.signalwire.com', + project: 'your-project-id', + token: 'your-api-token', + space: 'example.signalwire.com', contexts: ['default'] ) diff --git a/examples/quickstart_rest.rb b/examples/quickstart_rest.rb index fc6b3630..b256d7f6 100644 --- a/examples/quickstart_rest.rb +++ b/examples/quickstart_rest.rb @@ -14,8 +14,8 @@ client = SignalWire::REST::RestClient.new( project: 'your-project-id', - token: 'your-api-token', - host: 'example.signalwire.com' + token: 'your-api-token', + host: 'example.signalwire.com' ) client.fabric.ai_agents.create(name: 'Support Bot', prompt: { 'text' => 'You are helpful.' }) diff --git a/examples/receptionist_agent_example.rb b/examples/receptionist_agent_example.rb index b65175e5..e6f4de8c 100644 --- a/examples/receptionist_agent_example.rb +++ b/examples/receptionist_agent_example.rb @@ -6,20 +6,20 @@ # custom greeting, and caller info collection. require 'signalwire' -require 'signalwire/prefabs/receptionist' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/receptionist' # opt-in subsystem (Python: from signalwire.prefabs import ...) departments = [ - { 'name' => 'sales', 'description' => 'Product inquiries and pricing', 'number' => '+15551235555' }, + { 'name' => 'sales', 'description' => 'Product inquiries and pricing', 'number' => '+15551235555' }, { 'name' => 'support', 'description' => 'Technical assistance and bug reports', 'number' => '+15551236666' }, - { 'name' => 'billing', 'description' => 'Payment questions and invoices', 'number' => '+15551237777' }, - { 'name' => 'general', 'description' => 'All other inquiries', 'number' => '+15551238888' } + { 'name' => 'billing', 'description' => 'Payment questions and invoices', 'number' => '+15551237777' }, + { 'name' => 'general', 'description' => 'All other inquiries', 'number' => '+15551238888' } ] receptionist = SignalWire::Prefabs::Receptionist.new( departments: departments, - name: 'acme-receptionist', - route: '/reception', - greeting: 'Hello, thank you for calling ACME Corporation. How may I direct your call today?' + name: 'acme-receptionist', + route: '/reception', + greeting: 'Hello, thank you for calling ACME Corporation. How may I direct your call today?' ) agent = SignalWire::AgentBase.new(name: receptionist.name, route: receptionist.route) @@ -41,9 +41,9 @@ # Register transfer tool agent.define_tool( - name: 'transfer_to_department', + name: 'transfer_to_department', description: 'Transfer the caller to a specific department', - parameters: { + parameters: { 'department' => { 'type' => 'string', 'description' => 'Department name' } }, handler: nil ) do |args, raw_data| diff --git a/examples/record_call_example.rb b/examples/record_call_example.rb index ebad28ad..f18d6114 100644 --- a/examples/record_call_example.rb +++ b/examples/record_call_example.rb @@ -13,8 +13,8 @@ puts '=== Basic Recording ===' basic = SignalWire::Swaig::FunctionResult.new('Starting basic call recording') - .record_call - .say('This call is now being recorded') + .record_call + .say('This call is now being recorded') puts JSON.pretty_generate(basic.to_h) puts @@ -22,16 +22,16 @@ puts '=== Advanced Recording ===' advanced = SignalWire::Swaig::FunctionResult.new('Starting advanced call recording') - .record_call( - control_id: 'support_call_001', - stereo: true, - format: 'mp3', - direction: 'both', - beep: true, - max_length: 600, - status_url: 'https://api.company.com/recording-webhook' - ) - .say('This call is being recorded for quality and training purposes') + .record_call( + control_id: 'support_call_001', + stereo: true, + format: 'mp3', + direction: 'both', + beep: true, + max_length: 600, + status_url: 'https://api.company.com/recording-webhook' + ) + .say('This call is being recorded for quality and training purposes') puts JSON.pretty_generate(advanced.to_h) puts @@ -39,16 +39,16 @@ puts '=== Voicemail Recording ===' voicemail = SignalWire::Swaig::FunctionResult.new('Please leave your message after the beep') - .record_call( - control_id: 'voicemail_123', - format: 'wav', - direction: 'speak', - beep: true, - initial_timeout: 5.0, - end_silence_timeout: 3.0, - max_length: 120 - ) - .set_end_of_speech_timeout(2000) + .record_call( + control_id: 'voicemail_123', + format: 'wav', + direction: 'speak', + beep: true, + initial_timeout: 5.0, + end_silence_timeout: 3.0, + max_length: 120 + ) + .set_end_of_speech_timeout(2000) puts JSON.pretty_generate(voicemail.to_h) puts @@ -56,8 +56,8 @@ puts '=== Stop Recording ===' stop_rec = SignalWire::Swaig::FunctionResult.new('Ending call recording') - .stop_record_call(control_id: 'support_call_001') - .say('Thank you for calling. Your feedback is important to us.') + .stop_record_call(control_id: 'support_call_001') + .say('Thank you for calling. Your feedback is important to us.') puts JSON.pretty_generate(stop_rec.to_h) puts @@ -66,25 +66,25 @@ puts '=== Customer Service Workflow ===' start_rec = SignalWire::Swaig::FunctionResult.new('Transferring you to an agent') - .record_call( - control_id: 'cs_transfer_001', - format: 'mp3', - direction: 'both', - beep: false, - max_length: 1800, - status_url: 'https://api.company.com/recording-status' - ) - .update_global_data('recording_id' => 'cs_transfer_001') - .say('Please hold while I connect you') + .record_call( + control_id: 'cs_transfer_001', + format: 'mp3', + direction: 'both', + beep: false, + max_length: 1800, + status_url: 'https://api.company.com/recording-status' + ) + .update_global_data('recording_id' => 'cs_transfer_001') + .say('Please hold while I connect you') puts 'Start recording:' puts JSON.pretty_generate(start_rec.to_h) puts end_rec = SignalWire::Swaig::FunctionResult.new('Call recording stopped') - .stop_record_call(control_id: 'cs_transfer_001') - .remove_global_data('recording_id') - .say('Thank you for calling. Have a wonderful day!') + .stop_record_call(control_id: 'cs_transfer_001') + .remove_global_data('recording_id') + .say('Thank you for calling. Have a wonderful day!') puts 'End recording:' puts JSON.pretty_generate(end_rec.to_h) diff --git a/examples/relay_answer_and_welcome.rb b/examples/relay_answer_and_welcome.rb index 9a27c9fa..efe5dc02 100644 --- a/examples/relay_answer_and_welcome.rb +++ b/examples/relay_answer_and_welcome.rb @@ -12,7 +12,7 @@ # SIGNALWIRE_SPACE - your SignalWire space require 'signalwire' -require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) +require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) client = SignalWire::Relay::Client.new(contexts: ['default']) @@ -27,9 +27,10 @@ # Play a welcome message action = call.play([ - { 'type' => 'tts', 'params' => { 'text' => 'Hello! Welcome to the SignalWire RELAY demo.' } }, - { 'type' => 'tts', 'params' => { 'text' => 'This call is being handled by the Ruby RELAY client.' } } - ]) + { 'type' => 'tts', 'params' => { 'text' => 'Hello! Welcome to the SignalWire RELAY demo.' } }, + { 'type' => 'tts', + 'params' => { 'text' => 'This call is being handled by the Ruby RELAY client.' } } + ]) action.wait # Record a short message @@ -43,8 +44,9 @@ # Play goodbye bye_action = call.play([ - { 'type' => 'tts', 'params' => { 'text' => 'Thank you for trying the RELAY demo. Goodbye!' } } - ]) + { 'type' => 'tts', + 'params' => { 'text' => 'Thank you for trying the RELAY demo. Goodbye!' } } + ]) bye_action.wait # Hang up diff --git a/examples/relay_audit_harness.rb b/examples/relay_audit_harness.rb old mode 100644 new mode 100755 index 7613d2b3..d33d847f --- a/examples/relay_audit_harness.rb +++ b/examples/relay_audit_harness.rb @@ -29,19 +29,19 @@ require 'signalwire/relay/client' require 'signalwire/relay/constants' -project = ENV['SIGNALWIRE_PROJECT_ID'] +project = ENV.fetch('SIGNALWIRE_PROJECT_ID', nil) project = 'audit' if project.nil? || project.empty? -token = ENV['SIGNALWIRE_API_TOKEN'] +token = ENV.fetch('SIGNALWIRE_API_TOKEN', nil) token = 'audit' if token.nil? || token.empty? -host = ENV['SIGNALWIRE_RELAY_HOST'] +host = ENV.fetch('SIGNALWIRE_RELAY_HOST', nil) host = 'audit.host' if host.nil? || host.empty? contexts = (ENV['SIGNALWIRE_CONTEXTS'] || 'audit_ctx') .split(',').map(&:strip).reject(&:empty?) client = SignalWire::Relay::Client.new( project: project, - token: token, - space: host, + token: token, + space: host, contexts: contexts ) @@ -62,12 +62,12 @@ client.send_json( 'jsonrpc' => '2.0', - 'id' => "dispatched-#{event_type}", - 'method' => SignalWire::Relay::METHOD_SIGNALWIRE_EVENT, - 'params' => { + 'id' => "dispatched-#{event_type}", + 'method' => SignalWire::Relay::METHOD_SIGNALWIRE_EVENT, + 'params' => { 'dispatched' => true, 'event_type' => event_type, - 'echoed' => event_params + 'echoed' => event_params } ) end @@ -78,11 +78,9 @@ # through to the reconnect loop, which is fine for the audit fixture # (the connection is supposed to succeed first try). run_thread = Thread.new do - begin - client.run - rescue => e - $stderr.puts "relay_audit_harness: client.run raised: #{e.message}" - end + client.run +rescue StandardError => e + warn "relay_audit_harness: client.run raised: #{e.message}" end # Wait for the client to authenticate (signalwire.connect completed @@ -96,16 +94,17 @@ # `signalwire.receive`). The fixture replies with `{contexts}`. begin client.execute('signalwire.subscribe', { 'contexts' => contexts }) -rescue => e - $stderr.puts "relay_audit_harness: subscribe failed: #{e.message}" +rescue StandardError => e + warn "relay_audit_harness: subscribe failed: #{e.message}" end # Wait up to 5 seconds for an inbound event to be dispatched. saw_event_mutex.synchronize do deadline = Time.now + 5 - while !saw_event + until saw_event remaining = deadline - Time.now break if remaining <= 0 + saw_event_cv.wait(saw_event_mutex, remaining) end end @@ -120,7 +119,7 @@ run_thread.join(2) unless got_event - $stderr.puts 'relay_audit_harness: no event arrived within 5s' + warn 'relay_audit_harness: no event arrived within 5s' exit 1 end diff --git a/examples/rest_demo.rb b/examples/rest_demo.rb index bf68b36d..15118312 100644 --- a/examples/rest_demo.rb +++ b/examples/rest_demo.rb @@ -11,7 +11,7 @@ # SIGNALWIRE_SPACE - your SignalWire space require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -19,7 +19,7 @@ puts 'Creating AI agent...' begin agent = client.fabric.ai_agents.create( - name: 'Ruby Demo Bot', + name: 'Ruby Demo Bot', prompt: { 'text' => 'You are a helpful assistant powered by Ruby.' } ) agent_id = agent['id'] diff --git a/examples/room_and_sip_example.rb b/examples/room_and_sip_example.rb index fc1618b4..30108857 100644 --- a/examples/room_and_sip_example.rb +++ b/examples/room_and_sip_example.rb @@ -12,8 +12,8 @@ puts '=== Basic Room Join ===' room = SignalWire::Swaig::FunctionResult.new('Joining the support team room') - .join_room('support_team_room') - .say('Welcome to the support team collaboration room') + .join_room('support_team_room') + .say('Welcome to the support team collaboration room') puts JSON.pretty_generate(room.to_h) puts @@ -21,14 +21,14 @@ puts '=== Conference Room ===' conf_room = SignalWire::Swaig::FunctionResult.new('Setting up daily standup meeting') - .join_room('daily_standup_room') - .set_metadata( - 'meeting_type' => 'daily_standup', - 'participant_id' => 'user_123', - 'role' => 'scrum_master' - ) - .update_global_data('meeting_active' => true, 'room_name' => 'daily_standup_room') - .say('You have joined the daily standup meeting') + .join_room('daily_standup_room') + .set_metadata( + 'meeting_type' => 'daily_standup', + 'participant_id' => 'user_123', + 'role' => 'scrum_master' + ) + .update_global_data('meeting_active' => true, 'room_name' => 'daily_standup_room') + .say('You have joined the daily standup meeting') puts JSON.pretty_generate(conf_room.to_h) puts @@ -36,8 +36,8 @@ puts '=== SIP REFER ===' sip = SignalWire::Swaig::FunctionResult.new('Transferring to support') - .say('Please hold while I transfer you') - .sip_refer('sip:support@company.com') + .say('Please hold while I transfer you') + .sip_refer('sip:support@company.com') puts JSON.pretty_generate(sip.to_h) puts @@ -45,8 +45,8 @@ puts '=== Join Conference ===' conference = SignalWire::Swaig::FunctionResult.new('Joining team conference') - .join_conference('daily_standup') - .say('Welcome to the daily standup conference') + .join_conference('daily_standup') + .say('Welcome to the daily standup conference') puts JSON.pretty_generate(conference.to_h) puts @@ -54,12 +54,12 @@ puts '=== Advanced Conference ===' adv_conf = SignalWire::Swaig::FunctionResult.new('Setting up recorded conference') - .join_conference( - 'customer_training_session', - record: 'record-from-start', - max_participants: 50, - status_callback: 'https://api.company.com/conference-events', - status_callback_event: 'start end join leave' - ) - .set_metadata('session_type' => 'customer_training', 'facilitator' => 'training_team') + .join_conference( + 'customer_training_session', + record: 'record-from-start', + max_participants: 50, + status_callback: 'https://api.company.com/conference-events', + status_callback_event: 'start end join leave' + ) + .set_metadata('session_type' => 'customer_training', 'facilitator' => 'training_team') puts JSON.pretty_generate(adv_conf.to_h) diff --git a/examples/session_and_state_demo.rb b/examples/session_and_state_demo.rb index d680e900..ddc8affc 100644 --- a/examples/session_and_state_demo.rb +++ b/examples/session_and_state_demo.rb @@ -41,18 +41,18 @@ # --- Global data (pre-populated per-call state) --- agent.set_global_data( - 'customer_name' => 'Jane Doe', - 'account_id' => 'ACCT-12345', - 'recent_orders' => %w[ORD-001 ORD-002 ORD-003], - 'preferences' => { 'delivery_window' => 'morning', 'sms_updates' => true } + 'customer_name' => 'Jane Doe', + 'account_id' => 'ACCT-12345', + 'recent_orders' => %w[ORD-001 ORD-002 ORD-003], + 'preferences' => { 'delivery_window' => 'morning', 'sms_updates' => true } ) # --- Tools --- agent.define_tool( - name: 'lookup_order', + name: 'lookup_order', description: 'Look up an order by order ID', - parameters: { + parameters: { 'order_id' => { 'type' => 'string', 'description' => 'The order ID to look up' } }, handler: nil ) do |args, _raw_data| @@ -64,11 +64,11 @@ end agent.define_tool( - name: 'update_preferences', + name: 'update_preferences', description: 'Update customer delivery preferences', - parameters: { + parameters: { 'delivery_window' => { 'type' => 'string', 'description' => 'Preferred window: morning, afternoon, evening' }, - 'sms_updates' => { 'type' => 'boolean', 'description' => 'Enable SMS delivery updates' } + 'sms_updates' => { 'type' => 'boolean', 'description' => 'Enable SMS delivery updates' } }, handler: nil ) do |args, _raw_data| result = SignalWire::Swaig::FunctionResult.new( @@ -79,7 +79,7 @@ result.update_global_data( 'preferences' => { 'delivery_window' => args['delivery_window'], - 'sms_updates' => args['sms_updates'] + 'sms_updates' => args['sms_updates'] } ) result diff --git a/examples/simple_agent.rb b/examples/simple_agent.rb index fd25c5e9..8ba993ae 100644 --- a/examples/simple_agent.rb +++ b/examples/simple_agent.rb @@ -30,9 +30,9 @@ # --- Tools --- agent.define_tool( - name: 'get_weather', + name: 'get_weather', description: 'Get the current weather for a city', - parameters: { + parameters: { 'city' => { 'type' => 'string', 'description' => 'The city to look up' } }, handler: nil ) do |args, _raw_data| @@ -44,9 +44,9 @@ end agent.define_tool( - name: 'get_forecast', + name: 'get_forecast', description: 'Get a 3-day forecast for a city', - parameters: { + parameters: { 'city' => { 'type' => 'string', 'description' => 'The city to look up' } }, handler: nil ) do |args, _raw_data| diff --git a/examples/simple_dynamic_agent.rb b/examples/simple_dynamic_agent.rb index 93c1a9c4..72d3c3cb 100644 --- a/examples/simple_dynamic_agent.rb +++ b/examples/simple_dynamic_agent.rb @@ -17,7 +17,7 @@ # Register a dynamic config callback. # This runs for every incoming SWML request, receiving an ephemeral copy # of the agent that you can safely modify. -agent.set_dynamic_config_callback(nil) do |query_params, body_params, headers, ephemeral| +agent.set_dynamic_config_callback(nil) do |query_params, _body_params, headers, ephemeral| # Customise based on query parameters tenant = query_params['tenant'] || 'default' @@ -47,16 +47,14 @@ # Customise based on a header lang = headers['accept-language'] - if lang && lang.start_with?('es') - ephemeral.add_language('Spanish', 'es-US', 'elevenlabs.antonio') - end + ephemeral.add_language('Spanish', 'es-US', 'elevenlabs.antonio') if lang && lang.start_with?('es') end # Define a tool that uses global_data set by the dynamic config agent.define_tool( - name: 'get_company_info', + name: 'get_company_info', description: 'Get information about the company', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |_args, _raw_data| # In production, global_data would be populated per-request SignalWire::Swaig::FunctionResult.new( diff --git a/examples/simple_dynamic_enhanced.rb b/examples/simple_dynamic_enhanced.rb index b513cb17..13c8949a 100644 --- a/examples/simple_dynamic_enhanced.rb +++ b/examples/simple_dynamic_enhanced.rb @@ -14,7 +14,7 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'Enhanced Dynamic Agent', + name: 'Enhanced Dynamic Agent', auto_answer: true, record_call: true ) @@ -36,16 +36,16 @@ # AI parameters clone.set_params( 'end_of_speech_timeout' => is_vip ? 300 : 500, - 'attention_timeout' => is_vip ? 20_000 : 15_000 + 'attention_timeout' => is_vip ? 20_000 : 15_000 ) # Hints hints = %w[SignalWire SWML API webhook SIP] - case department - when 'sales' then hints += %w[pricing enterprise upgrade] - when 'billing' then hints += %w[invoice payment charges] - else hints += %w[support troubleshoot help] - end + hints += case department + when 'sales' then %w[pricing enterprise upgrade] + when 'billing' then %w[invoice payment charges] + else %w[support troubleshoot help] + end clone.add_hints(hints) # Global data @@ -54,8 +54,11 @@ clone.global_data = global # Role prompt - role = customer_id.empty? ? 'You are a professional customer service representative.' \ - : "You are a customer service rep helping customer #{customer_id}." + role = if customer_id.empty? + 'You are a professional customer service representative.' + else + "You are a customer service rep helping customer #{customer_id}." + end role += ' This is a VIP customer who receives priority service.' if is_vip clone.prompt_add_section('Role and Purpose', role) @@ -63,30 +66,30 @@ case department when 'sales' clone.prompt_add_section('Sales Expertise', 'You specialize in sales:', bullets: [ - 'Present product features and benefits', - 'Handle pricing questions', - 'Process orders and upgrades' - ]) + 'Present product features and benefits', + 'Handle pricing questions', + 'Process orders and upgrades' + ]) when 'billing' clone.prompt_add_section('Billing Expertise', 'You specialize in billing:', bullets: [ - 'Explain statements and charges', - 'Process payment arrangements', - 'Handle dispute resolution' - ]) + 'Explain statements and charges', + 'Process payment arrangements', + 'Handle dispute resolution' + ]) else clone.prompt_add_section('Support Guidelines', 'Follow these principles:', bullets: [ - 'Listen carefully to customer needs', - 'Provide accurate information', - 'Escalate complex issues when appropriate' - ]) + 'Listen carefully to customer needs', + 'Provide accurate information', + 'Escalate complex issues when appropriate' + ]) end if is_vip clone.prompt_add_section('VIP Standards', 'Premium service:', bullets: [ - 'Provide immediate attention', - 'Offer exclusive options', - 'Ensure complete satisfaction' - ]) + 'Provide immediate attention', + 'Offer exclusive options', + 'Ensure complete satisfaction' + ]) end end diff --git a/examples/simple_static_agent.rb b/examples/simple_static_agent.rb index bd517077..ee2861da 100644 --- a/examples/simple_static_agent.rb +++ b/examples/simple_static_agent.rb @@ -9,7 +9,7 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'Simple Customer Service Agent', + name: 'Simple Customer Service Agent', record_call: true ) @@ -18,18 +18,18 @@ agent.add_language('English', 'en-US', 'elevenlabs.rachel') agent.set_params( - 'end_of_speech_timeout' => 500, - 'attention_timeout' => 15_000, - 'background_file_volume' => -20 + 'end_of_speech_timeout' => 500, + 'attention_timeout' => 15_000, + 'background_file_volume' => -20 ) agent.add_hints(%w[SignalWire SWML API webhook SIP]) agent.set_global_data( - 'agent_type' => 'customer_service', - 'service_level' => 'standard', - 'features_enabled' => %w[basic_conversation help_desk], - 'session_info' => { 'environment' => 'production', 'version' => '1.0' } + 'agent_type' => 'customer_service', + 'service_level' => 'standard', + 'features_enabled' => %w[basic_conversation help_desk], + 'session_info' => { 'environment' => 'production', 'version' => '1.0' } ) agent.prompt_add_section( @@ -61,6 +61,6 @@ ) puts 'Starting simple static agent...' -puts " Configuration: STATIC (set once at startup)" +puts ' Configuration: STATIC (set once at startup)' puts " Agent available at: http://localhost:#{agent.port}/" agent.run diff --git a/examples/skills_audit_harness.rb b/examples/skills_audit_harness.rb old mode 100644 new mode 100755 index 4b993c07..6c05e833 --- a/examples/skills_audit_harness.rb +++ b/examples/skills_audit_harness.rb @@ -39,13 +39,13 @@ require 'signalwire/skills/skill_registry' require 'signalwire/swaig/function_result' -skill_name = ENV['SKILL_NAME'] +skill_name = ENV.fetch('SKILL_NAME', nil) if skill_name.nil? || skill_name.empty? warn 'skills_audit_harness: SKILL_NAME required' exit 1 end -args_raw = ENV['SKILL_HANDLER_ARGS'] +args_raw = ENV.fetch('SKILL_HANDLER_ARGS', nil) args_raw = '{}' if args_raw.nil? || args_raw.empty? begin args = JSON.parse(args_raw) @@ -154,8 +154,8 @@ def execute_datamap(tool_defs, tool_name, args) exit 1 end - url = expand_template(webhook['url'] || webhook[:url], args) - method = (webhook['method'] || webhook[:method] || 'GET').upcase + url = expand_template(webhook['url'] || webhook[:url], args) + method = (webhook['method'] || webhook[:method] || 'GET').upcase headers = webhook['headers'] || webhook[:headers] || {} uri = URI(url) @@ -175,10 +175,10 @@ def execute_datamap(tool_defs, tool_name, args) resp = http.request(req) body = begin - JSON.parse(resp.body || '') - rescue JSON::ParserError - resp.body - end + JSON.parse(resp.body || '') + rescue JSON::ParserError + resp.body + end { 'status' => resp.code.to_i, 'url' => url, 'body' => body } end diff --git a/examples/step_function_inheritance_demo.rb b/examples/step_function_inheritance_demo.rb index e919ff1b..3e5859f6 100644 --- a/examples/step_function_inheritance_demo.rb +++ b/examples/step_function_inheritance_demo.rb @@ -38,28 +38,28 @@ require 'signalwire' agent = SignalWire::AgentBase.new( - name: 'step_function_inheritance_demo', + name: 'step_function_inheritance_demo', route: '/' ) # Register three SWAIG tools so we have something to whitelist. # In a real agent these would call out to webhooks; here they're stubs. agent.define_tool( - name: 'lookup_account', + name: 'lookup_account', description: 'Look up customer account details by account number', - parameters: { 'account_number' => { 'type' => 'string' } }, handler: nil + parameters: { 'account_number' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'looked up' } } agent.define_tool( - name: 'process_payment', + name: 'process_payment', description: 'Process a payment for the current customer', - parameters: { 'amount' => { 'type' => 'number' } }, handler: nil + parameters: { 'amount' => { 'type' => 'number' } }, handler: nil ) { |_args, _raw| { 'response' => 'payment processed' } } agent.define_tool( - name: 'send_receipt', + name: 'send_receipt', description: 'Email a receipt to the customer', - parameters: { 'email' => { 'type' => 'string' } }, handler: nil + parameters: { 'email' => { 'type' => 'string' } }, handler: nil ) { |_args, _raw| { 'response' => 'sent' } } # Build the contexts. @@ -69,8 +69,8 @@ # `lookup_account` is the only tool active in this step. ctx.add_step('step_lookup') .set_text( - "Greet the customer and ask for their account number. " \ - "Use lookup_account to fetch their details." + 'Greet the customer and ask for their account number. ' \ + 'Use lookup_account to fetch their details.' ) .set_functions(%w[lookup_account]) .valid_steps = %w[step_inherit] @@ -84,7 +84,7 @@ ctx.add_step('step_inherit') .set_text( "Confirm the customer's identity. (No set_functions here, so " \ - "lookup_account is still active — this is the inheritance trap.)" + 'lookup_account is still active — this is the inheritance trap.)' ) .valid_steps = %w[step_explicit] @@ -94,7 +94,7 @@ ctx.add_step('step_explicit') .set_text( "Take the customer's payment. Use process_payment. " \ - "lookup_account is no longer available." + 'lookup_account is no longer available.' ) .set_functions(%w[process_payment]) .valid_steps = %w[step_disabled] @@ -104,8 +104,8 @@ # navigation tools (next_step) are unaffected. ctx.add_step('step_disabled') .set_text( - "Thank the customer and wrap up. No tools are needed here, so " \ - "we lock everything down with set_functions([])." + 'Thank the customer and wrap up. No tools are needed here, so ' \ + 'we lock everything down with set_functions([]).' ) .set_functions([]) .set_end(true) diff --git a/examples/survey_agent_example.rb b/examples/survey_agent_example.rb index 570ed49d..d9f9e254 100644 --- a/examples/survey_agent_example.rb +++ b/examples/survey_agent_example.rb @@ -6,44 +6,44 @@ # different answer types (rating, open-ended, yes/no). require 'signalwire' -require 'signalwire/prefabs/survey' # opt-in subsystem (Python: from signalwire.prefabs import ...) +require 'signalwire/prefabs/survey' # opt-in subsystem (Python: from signalwire.prefabs import ...) # Create the Survey prefab survey = SignalWire::Prefabs::Survey.new( survey_name: 'Customer Satisfaction Survey', questions: [ { - 'id' => 'overall_satisfaction', - 'text' => 'On a scale of 1 to 5, how satisfied are you with our service?', - 'type' => 'rating', + 'id' => 'overall_satisfaction', + 'text' => 'On a scale of 1 to 5, how satisfied are you with our service?', + 'type' => 'rating', 'scale' => 5 }, { - 'id' => 'recommend', + 'id' => 'recommend', 'text' => 'Would you recommend us to a friend or colleague?', 'type' => 'yes_no' }, { - 'id' => 'best_feature', + 'id' => 'best_feature', 'text' => 'What is the best thing about our service?', 'type' => 'open_ended' }, { - 'id' => 'improvement', + 'id' => 'improvement', 'text' => 'What is one thing we could improve?', 'type' => 'open_ended' }, { - 'id' => 'likelihood_to_return', - 'text' => 'On a scale of 1 to 10, how likely are you to use our service again?', - 'type' => 'rating', + 'id' => 'likelihood_to_return', + 'text' => 'On a scale of 1 to 10, how likely are you to use our service again?', + 'type' => 'rating', 'scale' => 10 } ], introduction: 'Thank you for taking the time to complete our brief survey. ' \ 'Your feedback helps us improve. Let me ask you a few quick questions.', - conclusion: 'Thank you for your valuable feedback! We truly appreciate it. ' \ - 'Have a wonderful day!' + conclusion: 'Thank you for your valuable feedback! We truly appreciate it. ' \ + 'Have a wonderful day!' ) # Wrap it in an agent for serving @@ -59,17 +59,17 @@ # Register the survey's tool handlers agent.define_tool( - name: 'start_survey', + name: 'start_survey', description: 'Start the survey and present the first question', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |args, raw_data| survey.handle_start(args, raw_data) end agent.define_tool( - name: 'submit_survey_answer', + name: 'submit_survey_answer', description: 'Record the answer to the current survey question', - parameters: { + parameters: { 'answer' => { 'type' => 'string', 'description' => "The caller's response" } }, handler: nil ) do |args, raw_data| @@ -77,9 +77,9 @@ end agent.define_tool( - name: 'get_survey_summary', + name: 'get_survey_summary', description: 'Get the final survey summary and thank the caller', - parameters: {}, handler: nil + parameters: {}, handler: nil ) do |args, raw_data| survey.handle_summary(args, raw_data) end diff --git a/examples/swaig_features_agent.rb b/examples/swaig_features_agent.rb index 82594ec7..d0afc2ed 100644 --- a/examples/swaig_features_agent.rb +++ b/examples/swaig_features_agent.rb @@ -13,19 +13,19 @@ # Transfer a call transfer = SignalWire::Swaig::FunctionResult.new('Transferring you now.') - .connect('+15559876543') + .connect('+15559876543') puts "Transfer: #{JSON.pretty_generate(transfer.to_h)}" puts # Hang up hangup = SignalWire::Swaig::FunctionResult.new('Goodbye!') - .hangup + .hangup puts "Hangup: #{JSON.pretty_generate(hangup.to_h)}" puts # Hold hold = SignalWire::Swaig::FunctionResult.new('Placing you on hold.') - .hold(120) + .hold(120) puts "Hold: #{JSON.pretty_generate(hold.to_h)}" puts @@ -33,13 +33,13 @@ # Update global data state = SignalWire::Swaig::FunctionResult.new('Preferences saved.') - .update_global_data('delivery_window' => 'morning', 'sms_updates' => true) + .update_global_data('delivery_window' => 'morning', 'sms_updates' => true) puts "Global data: #{JSON.pretty_generate(state.to_h)}" puts # Set metadata meta = SignalWire::Swaig::FunctionResult.new('Session tracked.') - .set_metadata('interaction_type' => 'support', 'priority' => 'high') + .set_metadata('interaction_type' => 'support', 'priority' => 'high') puts "Metadata: #{JSON.pretty_generate(meta.to_h)}" puts @@ -47,13 +47,13 @@ # Say speak = SignalWire::Swaig::FunctionResult.new('Done.') - .say('Here is an important announcement.') + .say('Here is an important announcement.') puts "Say: #{JSON.pretty_generate(speak.to_h)}" puts # Play background file bg = SignalWire::Swaig::FunctionResult.new('Playing hold music.') - .play_background_file('https://cdn.example.com/hold-music.mp3') + .play_background_file('https://cdn.example.com/hold-music.mp3') puts "Background play: #{JSON.pretty_generate(bg.to_h)}" puts @@ -61,13 +61,13 @@ # Switch context ctx_switch = SignalWire::Swaig::FunctionResult.new('Switching context.') - .switch_context(system_prompt: 'You are now a billing assistant.') + .switch_context(system_prompt: 'You are now a billing assistant.') puts "Context switch: #{JSON.pretty_generate(ctx_switch.to_h)}" puts # Change step step = SignalWire::Swaig::FunctionResult.new('Moving to next step.') - .swml_change_step('review') + .swml_change_step('review') puts "Change step: #{JSON.pretty_generate(step.to_h)}" puts @@ -75,26 +75,26 @@ # Toggle functions toggle = SignalWire::Swaig::FunctionResult.new('Functions updated.') - .toggle_functions([ - { 'function' => 'get_weather', 'active' => false }, - { 'function' => 'get_time', 'active' => true } - ]) + .toggle_functions([ + { 'function' => 'get_weather', 'active' => false }, + { 'function' => 'get_time', 'active' => true } + ]) puts "Toggle functions: #{JSON.pretty_generate(toggle.to_h)}" puts # Send SMS sms = SignalWire::Swaig::FunctionResult.new('SMS sent.') - .send_sms( - to_number: '+15551234567', - from_number: '+15559876543', - body: 'Your appointment is confirmed for tomorrow at 10 AM.' - ) + .send_sms( + to_number: '+15551234567', + from_number: '+15559876543', + body: 'Your appointment is confirmed for tomorrow at 10 AM.' + ) puts "Send SMS: #{JSON.pretty_generate(sms.to_h)}" puts # Method chaining chained = SignalWire::Swaig::FunctionResult.new('Processing complete.') - .say('Let me transfer you now.') - .update_global_data('transfer_initiated' => true) - .connect('+15551112222') + .say('Let me transfer you now.') + .update_global_data('transfer_initiated' => true) + .connect('+15551112222') puts "Chained: #{JSON.pretty_generate(chained.to_h)}" diff --git a/examples/swml_service_example.rb b/examples/swml_service_example.rb old mode 100644 new mode 100755 index bb40554d..13a6bc82 --- a/examples/swml_service_example.rb +++ b/examples/swml_service_example.rb @@ -27,10 +27,10 @@ def example_using_service puts '=== Example using SWMLService directly ===' service = SignalWire::SWML::Service.new( - name: 'simple-swml-service', + name: 'simple-swml-service', route: '/simple', - host: '0.0.0.0', - port: 3001 + host: '0.0.0.0', + port: 3001 ) # Build the SWML document by calling auto-vivified verb methods. @@ -53,10 +53,10 @@ def example_using_builder puts '=== Example using auto-vivified verb methods ===' service = SignalWire::SWML::Service.new( - name: 'fluent-swml-service', + name: 'fluent-swml-service', route: '/fluent', - host: '0.0.0.0', - port: 3002 + host: '0.0.0.0', + port: 3002 ) # Each verb method appends to the document. The 38 verbs from the @@ -81,10 +81,10 @@ def example_using_ai puts '=== Example using AI verb ===' service = SignalWire::SWML::Service.new( - name: 'ai-swml-service', + name: 'ai-swml-service', route: '/ai', - host: '0.0.0.0', - port: 3003 + host: '0.0.0.0', + port: 3003 ) service.answer diff --git a/examples/swml_service_routing_example.rb b/examples/swml_service_routing_example.rb index 3e797e00..5d882ba3 100644 --- a/examples/swml_service_routing_example.rb +++ b/examples/swml_service_routing_example.rb @@ -10,7 +10,7 @@ require 'json' service = SignalWire::SWML::Service.new( - name: 'routing-example', + name: 'routing-example', route: '/main' ) @@ -50,7 +50,7 @@ end puts "Starting routing example on port #{service.port}..." -puts " /main -- Default greeting" -puts " /main/customer -- Customer service" -puts " /main/product -- Product info" +puts ' /main -- Default greeting' +puts ' /main/customer -- Customer service' +puts ' /main/product -- Product info' service.serve diff --git a/examples/swmlservice_ai_sidecar.rb b/examples/swmlservice_ai_sidecar.rb index ce548599..4edaaba1 100644 --- a/examples/swmlservice_ai_sidecar.rb +++ b/examples/swmlservice_ai_sidecar.rb @@ -27,10 +27,10 @@ class SalesSidecar < SignalWire::SWML::Service def initialize(public_url: 'https://your-host.example.com/sales-sidecar', host: '0.0.0.0', port: nil) super( - name: 'sales-sidecar', + name: 'sales-sidecar', route: '/sales-sidecar', - host: host, - port: port + host: host, + port: port ) # 1. Emit any SWML -- including ai_sidecar. Service#add_verb_to_section @@ -43,17 +43,17 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', 'main', 'ai_sidecar', { - 'prompt' => 'You are a real-time sales copilot. Listen to the ' \ - 'call and surface competitor pricing comparisons ' \ - 'when relevant.', - 'lang' => 'en-US', + 'prompt' => 'You are a real-time sales copilot. Listen to the ' \ + 'call and surface competitor pricing comparisons ' \ + 'when relevant.', + 'lang' => 'en-US', 'direction' => %w[remote-caller local-caller], # Where the sidecar POSTs lifecycle/transcription events. # Optional -- skip if you don't need an event sink. - 'url' => "#{public_url}/events", + 'url' => "#{public_url}/events", # Where the sidecar's LLM POSTs SWAIG tool calls. This service's # /swaig route answers them. SWAIG hash key is UPPERCASE per spec. - 'SWAIG' => { + 'SWAIG' => { 'defaults' => { 'web_hook_url' => "#{public_url}/swaig" } } } @@ -63,12 +63,12 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', # 2. Register tools the sidecar's LLM can call. Same `define_tool` # you'd use on AgentBase -- it lives on SWML::Service. define_tool( - name: 'lookup_competitor', + name: 'lookup_competitor', description: 'Look up competitor pricing by company name. The sidecar ' \ 'should call this whenever the caller mentions a competitor.', - parameters: { + parameters: { 'competitor' => { - 'type' => 'string', + 'type' => 'string', 'description' => "The competitor's company name, e.g. 'ACME'." } }, @@ -92,6 +92,4 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', end end -if __FILE__ == $PROGRAM_NAME - SalesSidecar.new.serve -end +SalesSidecar.new.serve if __FILE__ == $PROGRAM_NAME diff --git a/examples/swmlservice_swaig_standalone.rb b/examples/swmlservice_swaig_standalone.rb index 3e165db1..8eef4d56 100644 --- a/examples/swmlservice_swaig_standalone.rb +++ b/examples/swmlservice_swaig_standalone.rb @@ -30,10 +30,10 @@ class StandaloneSwaig < SignalWire::SWML::Service def initialize(host: '0.0.0.0', port: nil) super( - name: 'standalone-swaig', + name: 'standalone-swaig', route: '/standalone', - host: host, - port: port + host: host, + port: port ) # 1. Build a minimal SWML document. Any verbs are fine -- the SWAIG @@ -45,12 +45,12 @@ def initialize(host: '0.0.0.0', port: nil) # not just AgentBase. The handler block receives parsed arguments # plus the raw POST body. define_tool( - name: 'lookup_competitor', + name: 'lookup_competitor', description: 'Look up competitor pricing by company name. Use this ' \ "when the user asks how a competitor's price compares to ours.", - parameters: { + parameters: { 'competitor' => { - 'type' => 'string', + 'type' => 'string', 'description' => "The competitor's company name, e.g. 'ACME'." } }, @@ -62,6 +62,4 @@ def initialize(host: '0.0.0.0', port: nil) end end -if __FILE__ == $PROGRAM_NAME - StandaloneSwaig.new.serve -end +StandaloneSwaig.new.serve if __FILE__ == $PROGRAM_NAME diff --git a/examples/tap_example.rb b/examples/tap_example.rb index 17d5f408..eba86137 100644 --- a/examples/tap_example.rb +++ b/examples/tap_example.rb @@ -12,8 +12,8 @@ puts '=== Basic WebSocket Tap ===' ws_tap = SignalWire::Swaig::FunctionResult.new('Starting call monitoring') - .tap('wss://monitoring.company.com/audio-stream') - .say('Call monitoring is now active') + .tap('wss://monitoring.company.com/audio-stream') + .say('Call monitoring is now active') puts JSON.pretty_generate(ws_tap.to_h) puts @@ -21,8 +21,8 @@ puts '=== Basic RTP Tap ===' rtp_tap = SignalWire::Swaig::FunctionResult.new('Starting RTP monitoring') - .tap('rtp://192.168.1.100:5004') - .update_global_data('rtp_monitoring' => true) + .tap('rtp://192.168.1.100:5004') + .update_global_data('rtp_monitoring' => true) puts JSON.pretty_generate(rtp_tap.to_h) puts @@ -30,19 +30,19 @@ puts '=== Compliance Monitoring ===' compliance = SignalWire::Swaig::FunctionResult.new('Setting up compliance monitoring') - .tap( - 'wss://compliance.company.com/secure-stream', - control_id: 'compliance_tap_001', - direction: 'both', - codec: 'PCMA', - status_url: 'https://api.company.com/compliance-events' - ) - .set_metadata( - 'compliance_session' => true, - 'agent_id' => 'agent_123', - 'recording_purpose' => 'regulatory_compliance' - ) - .say('This call may be monitored for compliance purposes') + .tap( + 'wss://compliance.company.com/secure-stream', + control_id: 'compliance_tap_001', + direction: 'both', + codec: 'PCMA', + status_url: 'https://api.company.com/compliance-events' + ) + .set_metadata( + 'compliance_session' => true, + 'agent_id' => 'agent_123', + 'recording_purpose' => 'regulatory_compliance' + ) + .say('This call may be monitored for compliance purposes') puts JSON.pretty_generate(compliance.to_h) puts @@ -50,9 +50,9 @@ puts '=== Stop Tap ===' stop = SignalWire::Swaig::FunctionResult.new('Ending compliance monitoring') - .stop_tap(control_id: 'compliance_tap_001') - .update_global_data('compliance_session' => false) - .say('Compliance monitoring has been deactivated') + .stop_tap(control_id: 'compliance_tap_001') + .update_global_data('compliance_session' => false) + .say('Compliance monitoring has been deactivated') puts JSON.pretty_generate(stop.to_h) puts @@ -60,11 +60,11 @@ puts '=== Multi-Tap ===' multi = SignalWire::Swaig::FunctionResult.new('Initialising multi-stream monitoring') - .tap('wss://compliance.company.com/stream', control_id: 'compliance_stream', direction: 'both') - .tap('rtp://analytics.company.com:5006', control_id: 'analytics_stream', codec: 'PCMA') - .tap('wss://quality.company.com/monitoring', control_id: 'quality_stream', direction: 'speak') - .update_global_data( - 'active_streams' => %w[compliance analytics quality], - 'monitoring_level' => 'comprehensive' - ) + .tap('wss://compliance.company.com/stream', control_id: 'compliance_stream', direction: 'both') + .tap('rtp://analytics.company.com:5006', control_id: 'analytics_stream', codec: 'PCMA') + .tap('wss://quality.company.com/monitoring', control_id: 'quality_stream', direction: 'speak') + .update_global_data( + 'active_streams' => %w[compliance analytics quality], + 'monitoring_level' => 'comprehensive' + ) puts JSON.pretty_generate(multi.to_h) diff --git a/examples/web_search_agent.rb b/examples/web_search_agent.rb index 23e4db7c..fb922354 100644 --- a/examples/web_search_agent.rb +++ b/examples/web_search_agent.rb @@ -8,8 +8,8 @@ require 'signalwire' -api_key = ENV['GOOGLE_SEARCH_API_KEY'] -engine_id = ENV['GOOGLE_SEARCH_ENGINE_ID'] +api_key = ENV.fetch('GOOGLE_SEARCH_API_KEY', nil) +engine_id = ENV.fetch('GOOGLE_SEARCH_ENGINE_ID', nil) unless api_key && engine_id puts 'Missing required environment variables:' @@ -31,19 +31,19 @@ ) agent.prompt_add_section('Instructions', nil, bullets: [ - 'Always introduce yourself as Franklin.', - 'Use web search to find current information.', - 'Present results clearly with source URLs.' -]) + 'Always introduce yourself as Franklin.', + 'Use web search to find current information.', + 'Present results clearly with source URLs.' + ]) agent.add_skill('web_search', { - 'api_key' => api_key, - 'search_engine_id' => engine_id, - 'num_results' => 1, - 'delay' => 0, - 'max_content_length' => 3000, - 'no_results_message' => "I couldn't find anything about '{query}'. Try rephrasing?" -}) + 'api_key' => api_key, + 'search_engine_id' => engine_id, + 'num_results' => 1, + 'delay' => 0, + 'max_content_length' => 3000, + 'no_results_message' => "I couldn't find anything about '{query}'. Try rephrasing?" + }) puts "Loaded skills: #{agent.list_skills.join(', ')}" puts "Starting Web Search agent on port #{agent.port}..." diff --git a/examples/web_search_multi_instance_demo.rb b/examples/web_search_multi_instance_demo.rb index f634e176..00a4ecaf 100644 --- a/examples/web_search_multi_instance_demo.rb +++ b/examples/web_search_multi_instance_demo.rb @@ -9,8 +9,8 @@ require 'signalwire' -api_key = ENV['GOOGLE_SEARCH_API_KEY'] -engine_id = ENV['GOOGLE_SEARCH_ENGINE_ID'] +api_key = ENV.fetch('GOOGLE_SEARCH_API_KEY', nil) +engine_id = ENV.fetch('GOOGLE_SEARCH_ENGINE_ID', nil) agent = SignalWire::AgentBase.new(name: 'multi-search', route: '/multi-search') @@ -25,7 +25,7 @@ begin agent.add_skill('datetime') agent.add_skill('math') -rescue => e +rescue StandardError => e puts "Skill warning: #{e.message}" end @@ -33,7 +33,7 @@ begin agent.add_skill('wikipedia_search', 'num_results' => 2) puts 'Added Wikipedia search (tool: search_wiki)' -rescue => e +rescue StandardError => e puts "Wikipedia: #{e.message}" end @@ -44,37 +44,37 @@ # General web search (default tool name) begin agent.add_skill('web_search', - 'api_key' => api_key, - 'search_engine_id' => engine_id, - 'num_results' => 3) + 'api_key' => api_key, + 'search_engine_id' => engine_id, + 'num_results' => 3) puts 'Added general web search (tool: web_search)' - rescue => e + rescue StandardError => e puts "General search: #{e.message}" end # News search begin agent.add_skill('web_search', - 'api_key' => api_key, - 'search_engine_id' => engine_id, - 'tool_name' => 'search_news', - 'num_results' => 5, - 'delay' => 0.5) + 'api_key' => api_key, + 'search_engine_id' => engine_id, + 'tool_name' => 'search_news', + 'num_results' => 5, + 'delay' => 0.5) puts 'Added news search (tool: search_news)' - rescue => e + rescue StandardError => e puts "News search: #{e.message}" end # Quick single-result search begin agent.add_skill('web_search', - 'api_key' => api_key, - 'search_engine_id' => engine_id, - 'tool_name' => 'quick_search', - 'num_results' => 1, - 'delay' => 0) + 'api_key' => api_key, + 'search_engine_id' => engine_id, + 'tool_name' => 'quick_search', + 'num_results' => 1, + 'delay' => 0) puts 'Added quick search (tool: quick_search)' - rescue => e + rescue StandardError => e puts "Quick search: #{e.message}" end end diff --git a/examples/wikipedia_demo.rb b/examples/wikipedia_demo.rb index 21a121d3..f00a9603 100644 --- a/examples/wikipedia_demo.rb +++ b/examples/wikipedia_demo.rb @@ -15,19 +15,19 @@ begin agent.add_skill('datetime') puts 'Added datetime skill' -rescue => e +rescue StandardError => e puts "Failed to add datetime skill: #{e.message}" end # Add wikipedia search skill begin agent.add_skill('wikipedia_search', { - 'num_results' => 2, - 'no_results_message' => "I couldn't find any Wikipedia articles about '{query}'. " \ - 'Try different keywords or a related topic.' - }) + 'num_results' => 2, + 'no_results_message' => "I couldn't find any Wikipedia articles about '{query}'. " \ + 'Try different keywords or a related topic.' + }) puts 'Added Wikipedia search skill' -rescue => e +rescue StandardError => e puts "Failed to add Wikipedia skill: #{e.message}" exit 1 end diff --git a/relay/examples/relay_answer_and_welcome.rb b/relay/examples/relay_answer_and_welcome.rb index 77461bb2..417d8433 100644 --- a/relay/examples/relay_answer_and_welcome.rb +++ b/relay/examples/relay_answer_and_welcome.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) +require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) client = SignalWire::Relay::Client.new(contexts: ['default']) diff --git a/relay/examples/relay_dial_and_play.rb b/relay/examples/relay_dial_and_play.rb index 508de660..8a421bdb 100644 --- a/relay/examples/relay_dial_and_play.rb +++ b/relay/examples/relay_dial_and_play.rb @@ -10,7 +10,7 @@ # RELAY_TO_NUMBER - destination to call require 'signalwire' -require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) +require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) from_number = ENV.fetch('RELAY_FROM_NUMBER', '+15551230001') to_number = ENV.fetch('RELAY_TO_NUMBER', '+15551230002') diff --git a/relay/examples/relay_ivr_connect.rb b/relay/examples/relay_ivr_connect.rb index 9d9293bd..2dedde81 100644 --- a/relay/examples/relay_ivr_connect.rb +++ b/relay/examples/relay_ivr_connect.rb @@ -14,7 +14,7 @@ # SIGNALWIRE_SPACE - your SignalWire space require 'signalwire' -require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) +require 'signalwire/relay/client' # opt-in subsystem (Python: from signalwire.relay import RelayClient) AGENT_NUMBER = '+19184238080' @@ -69,9 +69,9 @@ def tts(text) devices: [[{ 'type' => 'phone', 'params' => { - 'to_number' => AGENT_NUMBER, + 'to_number' => AGENT_NUMBER, 'from_number' => from_number, - 'timeout' => 30 + 'timeout' => 30 } }]], ringback: [tts('Please wait while we connect your call.')] diff --git a/rest/examples/rest_10dlc_registration.rb b/rest/examples/rest_10dlc_registration.rb index 533f9bac..d9455bbc 100644 --- a/rest/examples/rest_10dlc_registration.rb +++ b/rest/examples/rest_10dlc_registration.rb @@ -11,7 +11,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -29,15 +29,15 @@ def safe(label) brand = safe('Register brand') do client.registry.brands.create( { - name: 'Acme Brand', - company_name: 'Acme Corp', - contact_email: 'brand_info@acme.example.com', - contact_phone: '+18995551212', + name: 'Acme Brand', + company_name: 'Acme Corp', + contact_email: 'brand_info@acme.example.com', + contact_phone: '+18995551212', ein_issuing_country: 'United States', - legal_entity_type: 'PRIVATE_PROFIT', - ein: '12-3456789', - company_address: '123 Brand St, Hill Valley CA, 91905', - company_website: 'www.acme.example.com' + legal_entity_type: 'PRIVATE_PROFIT', + ein: '12-3456789', + company_address: '123 Brand St, Hill Valley CA, 91905', + company_website: 'www.acme.example.com' } ) end @@ -65,8 +65,8 @@ def safe(label) client.registry.brands.create_campaign( brand_id, { - name: 'Customer Notifications', - brand_id: brand_id, + name: 'Customer Notifications', + brand_id: brand_id, csp_campaign_reference: 'C123456' } ) diff --git a/rest/examples/rest_bind_phone_to_swml_webhook.rb b/rest/examples/rest_bind_phone_to_swml_webhook.rb index 1aa49ea1..4be3b443 100644 --- a/rest/examples/rest_bind_phone_to_swml_webhook.rb +++ b/rest/examples/rest_bind_phone_to_swml_webhook.rb @@ -16,7 +16,7 @@ # SWML_WEBHOOK_URL - your backend's SWML endpoint require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) pn_sid = ENV.fetch('PHONE_NUMBER_SID', 'pn-00000000-0000-0000-0000-000000000000') webhook_url = ENV.fetch('SWML_WEBHOOK_URL', 'https://example.com/swml') @@ -39,7 +39,7 @@ pn = client.phone_numbers.get(pn_sid) puts " call_handler = #{pn['call_handler'].inspect}" puts " call_relay_script_url = #{pn['call_relay_script_url'].inspect}" -puts " calling_handler_resource_id (server-derived) = " \ +puts ' calling_handler_resource_id (server-derived) = ' \ "#{pn['calling_handler_resource_id'].inspect}" # To route to something other than an SWML webhook, use: diff --git a/rest/examples/rest_calling_ivr_and_ai.rb b/rest/examples/rest_calling_ivr_and_ai.rb index 29ee3344..286a7745 100644 --- a/rest/examples/rest_calling_ivr_and_ai.rb +++ b/rest/examples/rest_calling_ivr_and_ai.rb @@ -12,7 +12,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -37,7 +37,7 @@ def safe(label) client.calling.collect( CALL_ID, control_id: CONTROL_ID, - digits: { 'max' => 4, 'terminators' => '#' } + digits: { 'max' => 4, 'terminators' => '#' } ) end safe('Start input timers') { client.calling.collect_start_input_timers(CALL_ID, control_id: CONTROL_ID) } @@ -65,7 +65,7 @@ def safe(label) safe('Tap start') do client.calling.tap( CALL_ID, - tap: { 'type' => 'audio', 'direction' => 'both' }, + tap: { 'type' => 'audio', 'direction' => 'both' }, device: { 'type' => 'rtp', 'addr' => '192.168.1.100', 'port' => 9000 } ) end @@ -93,6 +93,6 @@ def safe(label) # 10. Transfer and disconnect puts "\nTransfer and disconnect..." -safe('Transfer') { client.calling.transfer(CALL_ID, dest: '+15559999999') } +safe('Transfer') { client.calling.transfer(CALL_ID, dest: '+15559999999') } safe('Update call') { client.calling.update(id: CALL_ID, status: 'completed') } safe('Disconnect') { client.calling.disconnect(CALL_ID) } diff --git a/rest/examples/rest_calling_play_and_record.rb b/rest/examples/rest_calling_play_and_record.rb index 39b360c0..95ddf03e 100644 --- a/rest/examples/rest_calling_play_and_record.rb +++ b/rest/examples/rest_calling_play_and_record.rb @@ -12,7 +12,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -21,8 +21,8 @@ begin call = client.calling.dial( from: '+15559876543', - to: '+15551234567', - url: 'https://example.com/call-handler' + to: '+15551234567', + url: 'https://example.com/call-handler' ) call_id = call.fetch('id', 'demo-call-id') puts " Call initiated: #{call_id}" @@ -51,12 +51,10 @@ ['Volume +2dB', -> { client.calling.play_volume(call_id, control_id: play_ctl, volume: 2.0) }], ['Stop', -> { client.calling.play_stop(call_id, control_id: play_ctl) }] ].each do |label, action| - begin - action.call - puts " #{label}: OK" - rescue SignalWire::REST::SignalWireRestError => e - puts " #{label}: failed (#{e.status_code})" - end + action.call + puts " #{label}: OK" +rescue SignalWire::REST::SignalWireRestError => e + puts " #{label}: failed (#{e.status_code})" end # 4. Record the call @@ -77,12 +75,10 @@ ['Resume', -> { client.calling.record_resume(call_id, control_id: record_ctl) }], ['Stop', -> { client.calling.record_stop(call_id, control_id: record_ctl) }] ].each do |label, action| - begin - action.call - puts " #{label}: OK" - rescue SignalWire::REST::SignalWireRestError => e - puts " #{label}: failed (#{e.status_code})" - end + action.call + puts " #{label}: OK" +rescue SignalWire::REST::SignalWireRestError => e + puts " #{label}: failed (#{e.status_code})" end # 6. Transcribe the call diff --git a/rest/examples/rest_datasphere_search.rb b/rest/examples/rest_datasphere_search.rb index 75bee89e..6488aecd 100644 --- a/rest/examples/rest_datasphere_search.rb +++ b/rest/examples/rest_datasphere_search.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -18,7 +18,7 @@ puts 'Uploading document to Datasphere...' doc = client.datasphere.documents.create( { - url: 'https://filesamples.com/samples/document/txt/sample3.txt', + url: 'https://filesamples.com/samples/document/txt/sample3.txt', tags: %w[support demo] } ) @@ -36,7 +36,7 @@ puts "\nSearching Datasphere..." results = client.datasphere.documents.search( query_string: 'lorem ipsum dolor sit amet', - count: 3 + count: 3 ) (results['chunks'] || []).each do |chunk| puts " - #{(chunk['text'] || '')[0, 100]}..." diff --git a/rest/examples/rest_fabric_conferences_and_routing.rb b/rest/examples/rest_fabric_conferences_and_routing.rb index ce9eb6a7..9d6531bf 100644 --- a/rest/examples/rest_fabric_conferences_and_routing.rb +++ b/rest/examples/rest_fabric_conferences_and_routing.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -42,7 +42,7 @@ def safe(label) puts "\nCreating cXML script..." cxml = client.fabric.cxml_scripts.create( display_name: 'Hold Music Script', - contents: 'Please hold.https://example.com/hold.mp3' + contents: 'Please hold.https://example.com/hold.mp3' ) cxml_id = cxml['id'] puts " Created cXML script: #{cxml_id}" diff --git a/rest/examples/rest_fabric_subscribers_and_sip.rb b/rest/examples/rest_fabric_subscribers_and_sip.rb index 76ea5629..11b5953f 100644 --- a/rest/examples/rest_fabric_subscribers_and_sip.rb +++ b/rest/examples/rest_fabric_subscribers_and_sip.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -24,9 +24,9 @@ def safe(label) # 1. Create a subscriber puts 'Creating subscriber...' subscriber = client.fabric.subscribers.create( - email: 'alice@example.com', - first_name: 'Alice', - last_name: 'Johnson', + email: 'alice@example.com', + first_name: 'Alice', + last_name: 'Johnson', display_name: 'Alice Johnson' ) sub_id = subscriber['id'] @@ -58,11 +58,11 @@ def safe(label) # 5. Create a standalone SIP gateway puts "\nCreating SIP gateway..." gateway = client.fabric.sip_gateways.create( - name: 'Office PBX Gateway', - uri: 'sip:pbx.example.com', + name: 'Office PBX Gateway', + uri: 'sip:pbx.example.com', encryption: 'required', - ciphers: ['AES_256_CM_HMAC_SHA1_80'], - codecs: %w[PCMU PCMA] + ciphers: ['AES_256_CM_HMAC_SHA1_80'], + codecs: %w[PCMU PCMA] ) gw_id = gateway['id'] puts " Created SIP gateway: #{gw_id}" diff --git a/rest/examples/rest_fabric_swml_and_callflows.rb b/rest/examples/rest_fabric_swml_and_callflows.rb index d33d68e4..a3583f52 100644 --- a/rest/examples/rest_fabric_swml_and_callflows.rb +++ b/rest/examples/rest_fabric_swml_and_callflows.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -24,7 +24,7 @@ def safe(label) # 1. Create a SWML script puts 'Creating SWML script...' swml = client.fabric.swml_scripts.create( - name: 'Greeting Script', + name: 'Greeting Script', contents: { 'sections' => { 'main' => [{ 'play' => { 'url' => 'say:Hello from SignalWire' } }] } } ) swml_id = swml['id'] @@ -76,7 +76,7 @@ def list_rows(resp) # 7. Create a SWML webhook as an alternative approach puts "\nCreating SWML webhook..." webhook = client.fabric.swml_webhooks.create( - name: 'External Handler', + name: 'External Handler', primary_request_url: 'https://example.com/swml-handler' ) webhook_id = webhook['id'] diff --git a/rest/examples/rest_manage_resources.rb b/rest/examples/rest_manage_resources.rb index d08504e1..5a401d90 100644 --- a/rest/examples/rest_manage_resources.rb +++ b/rest/examples/rest_manage_resources.rb @@ -8,14 +8,14 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new # 1. Create an AI agent puts 'Creating AI agent...' agent = client.fabric.ai_agents.create( - name: 'Demo Support Bot', + name: 'Demo Support Bot', prompt: { 'text' => 'You are a friendly support agent for Acme Corp.' } ) agent_id = agent['id'] @@ -40,8 +40,8 @@ begin result = client.calling.dial( from: '+15559876543', - to: '+15551234567', - url: 'https://example.com/call-handler' + to: '+15551234567', + url: 'https://example.com/call-handler' ) puts " Call initiated: #{result}" rescue SignalWire::REST::SignalWireRestError => e diff --git a/rest/examples/rest_phone_number_management.rb b/rest/examples/rest_phone_number_management.rb index b1f3126a..9fdf0983 100644 --- a/rest/examples/rest_phone_number_management.rb +++ b/rest/examples/rest_phone_number_management.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -61,7 +61,7 @@ def safe(label) # 5. Create a number group puts "\nCreating number group..." -group_id = nil +nil group = safe('Create group') { client.number_groups.create(name: 'Sales Pool') } group_id = group && group['id'] @@ -122,18 +122,18 @@ def safe(label) # 11. Create an address puts "\nCreating address..." -addr_id = nil +nil addr = safe('Create address') do client.addresses.create( - label: 'HQ Address', - country: 'US', - first_name: 'Jane', - last_name: 'Doe', + label: 'HQ Address', + country: 'US', + first_name: 'Jane', + last_name: 'Doe', street_number: '123', - street_name: 'Main St', - city: 'Austin', - state: 'TX', - postal_code: '78701' + street_name: 'Main St', + city: 'Austin', + state: 'TX', + postal_code: '78701' ) end addr_id = addr && addr['id'] diff --git a/rest/examples/rest_queues_mfa_and_recordings.rb b/rest/examples/rest_queues_mfa_and_recordings.rb index 02204cc2..205a63b6 100644 --- a/rest/examples/rest_queues_mfa_and_recordings.rb +++ b/rest/examples/rest_queues_mfa_and_recordings.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -25,7 +25,7 @@ def safe(label) # 1. Create a queue puts 'Creating call queue...' -queue_id = nil +nil queue = safe('Create queue') { client.queues.create(name: 'Support Queue', max_size: 50) } queue_id = queue && queue['id'] @@ -84,9 +84,9 @@ def safe(label) request_id = nil begin sms_result = client.mfa.sms( - to: '+15551234567', - from: '+15559876543', - message: 'Your code is {{code}}', + to: '+15551234567', + from: '+15559876543', + message: 'Your code is {{code}}', token_length: 6 ) request_id = sms_result['id'] || sms_result['request_id'] @@ -99,9 +99,9 @@ def safe(label) puts "\nSending MFA voice code..." begin voice_result = client.mfa.call( - to: '+15551234567', - from: '+15559876543', - message: 'Your verification code is {{code}}', + to: '+15551234567', + from: '+15559876543', + message: 'Your verification code is {{code}}', token_length: 6 ) puts " MFA call sent: #{voice_result['id'] || voice_result['request_id']}" diff --git a/rest/examples/rest_video_rooms.rb b/rest/examples/rest_video_rooms.rb index 9c21908a..64179290 100644 --- a/rest/examples/rest_video_rooms.rb +++ b/rest/examples/rest_video_rooms.rb @@ -8,7 +8,7 @@ # SIGNALWIRE_SPACE - your SignalWire space (e.g. example.signalwire.com) require 'signalwire' -require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) +require 'signalwire/rest/rest_client' # opt-in subsystem (Python: from signalwire.rest import Client) client = SignalWire::REST::RestClient.new @@ -26,10 +26,10 @@ def safe(label) # 1. Create a video room puts 'Creating video room...' room = client.video.rooms.create( - name: 'daily-standup', + name: 'daily-standup', display_name: 'Daily Standup', - max_members: 10, - layout: 'grid-responsive' + max_members: 10, + layout: 'grid-responsive' ) room_id = room['id'] puts " Created room: #{room_id}" @@ -45,8 +45,8 @@ def safe(label) puts "\nGenerating room token..." safe('Room token') do token = client.video.room_tokens.create( - room_name: 'daily-standup', - user_name: 'alice', + room_name: 'daily-standup', + user_name: 'alice', permissions: %w[room.self.audio_mute room.self.video_mute] ) puts " Token: #{token.fetch('token', '')[0, 40]}..." @@ -100,7 +100,7 @@ def safe(label) # 7. Create a video conference puts "\nCreating video conference..." -conf_id = nil +nil conf = safe('Create conference') do client.video.conferences.create(name: 'all-hands-stream', display_name: 'All Hands Meeting') end From 30b48ab55feaebf32c3b276645bfe5c55475e309 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:09:28 -0400 Subject: [PATCH 59/90] lint(examples): decompose skills_audit_harness's DataMap path execute_datamap carried AbcSize 58.9/17 and CyclomaticComplexity 26/7 -- by far the worst complexity in the newly-linted tree -- almost all of it the `h['k'] || h[:k]` string-or-symbol dance repeated eleven times and two inlined "find it or warn+exit" blocks. Extracted `either/2` (the string-or-symbol read), `require_present/2` (the find-or-die), `datamap_webhook`, `datamap_request`, `datamap_fetch`, and `expand_placeholder` (one iteration of the `%{args.NAME}` scanner). No cop was suppressed; the complexity was real and it decomposed. Behavior is byte-identical: the harness was driven against a loopback HTTP fixture for both DataMap skills (api_ninjas_trivia, weather_api) before and after, and the emitted JSON matches exactly (host:port normalized). One subtlety preserved deliberately: the original `out << v.to_s if v` made a FALSY arg expand to nothing, so `%{args.missing}` vanishes rather than becoming "false". expand_placeholder keeps that and says so in a comment. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- examples/skills_audit_harness.rb | 134 +++++++++++++++++-------------- 1 file changed, 75 insertions(+), 59 deletions(-) diff --git a/examples/skills_audit_harness.rb b/examples/skills_audit_harness.rb index 6c05e833..8adfdcf2 100755 --- a/examples/skills_audit_harness.rb +++ b/examples/skills_audit_harness.rb @@ -94,84 +94,88 @@ exit 1 end +# Read a key that may be present in either the String or the Symbol spelling +# (the tool-def / DataMap tree mixes both depending on how the skill built it). +def either(hash, key) + hash[key.to_s] || hash[key.to_sym] +end + +# +value+, or a fatal "skills_audit_harness: " exit when it is absent. +def require_present(value, what) + return value if value + + warn "skills_audit_harness: #{what}" + exit 1 +end + # Dispatch logic differs for handler-based vs DataMap-based skills. def dispatch_handler(tool_defs, tool_name, args) - td = tool_defs.find { |t| (t[:name] || t['name']) == tool_name } - unless td - warn "skills_audit_harness: tool '#{tool_name}' not registered" - exit 1 - end - handler = td[:handler] || td['handler'] - unless handler - warn "skills_audit_harness: tool '#{tool_name}' has no handler" - exit 1 - end + td = require_present(tool_defs.find { |t| either(t, :name) == tool_name }, + "tool '#{tool_name}' not registered") + handler = require_present(either(td, :handler), + "tool '#{tool_name}' has no handler") handler.call(args, {}) end +# Substitute one `%{args.NAME}` placeholder starting at +idx+. Returns +# [text_to_append, next_index], or nil when +idx+ does not open a placeholder. +def expand_placeholder(template, args, idx) + return nil unless template[idx] == '%' && template[idx + 1] == '{' + + close = template.index('}', idx + 2) + return nil unless close + + key = template[(idx + 2)...close] + return [template[idx..close], close + 1] unless key.start_with?('args.') + + # A falsy arg expands to the empty string (the original `<< v.to_s if v`), + # so `%{args.missing}` disappears rather than becoming "" / "false". + value = args[key.sub('args.', '')] + [value ? value.to_s : '', close + 1] +end + def expand_template(template, args) - out = String.new + out = +'' i = 0 while i < template.length - if template[i] == '%' && template[i + 1] == '{' - close = template.index('}', i + 2) - if close - key = template[(i + 2)...close] - if key.start_with?('args.') - v = args[key.sub('args.', '')] - out << v.to_s if v - else - out << template[i..close] - end - i = close + 1 - next - end - end - out << template[i] - i += 1 + expansion = expand_placeholder(template, args, i) + text, i = expansion || [template[i], i + 1] + out << text end out end -def execute_datamap(tool_defs, tool_name, args) - # DataMap skills register definitions under :datamap (Ruby) — find - # the matching one, extract its first webhook URL, and execute the - # request the same way the SignalWire platform would. - td = tool_defs.find do |t| - dm = t[:datamap] || t['datamap'] - dm && (dm['function'] == tool_name || dm[:function] == tool_name) - end - unless td - warn "skills_audit_harness: DataMap tool '#{tool_name}' not registered" - exit 1 - end - dm = td[:datamap] || td['datamap'] - - webhook = (dm['data_map'] || dm[:data_map] || {})['webhooks']&.first || - (dm['data_map'] || dm[:data_map] || {})[:webhooks]&.first - unless webhook - warn "skills_audit_harness: DataMap tool '#{tool_name}' has no webhook" - exit 1 - end - - url = expand_template(webhook['url'] || webhook[:url], args) - method = (webhook['method'] || webhook[:method] || 'GET').upcase - headers = webhook['headers'] || webhook[:headers] || {} - - uri = URI(url) - http = Net::HTTP.new(uri.host, uri.port) - http.use_ssl = (uri.scheme == 'https') +# Locate the registered DataMap for +tool_name+ and return its first webhook. +def datamap_webhook(tool_defs, tool_name) + td = require_present( + tool_defs.find { |t| (dm = either(t, :datamap)) && either(dm, :function) == tool_name }, + "DataMap tool '#{tool_name}' not registered" + ) + data_map = either(either(td, :datamap), :data_map) || {} + require_present(either(data_map, :webhooks)&.first, + "DataMap tool '#{tool_name}' has no webhook") +end +# Build the Net::HTTP request the SignalWire platform would issue for +webhook+. +def datamap_request(webhook, url, method) req = case method - when 'GET' then Net::HTTP::Get.new(uri) - when 'POST' then Net::HTTP::Post.new(uri) + when 'GET' then Net::HTTP::Get.new(URI(url)) + when 'POST' then Net::HTTP::Post.new(URI(url)) else warn "skills_audit_harness: unsupported method '#{method}'" exit 1 end - headers.each { |k, v| req[k.to_s] = v.to_s } + (either(webhook, :headers) || {}).each { |k, v| req[k.to_s] = v.to_s } req.body = '' if method == 'POST' + req +end + +# Issue +req+ to +url+ and return [status, parsed-or-raw body]. +def datamap_fetch(url, req) + uri = URI(url) + http = Net::HTTP.new(uri.host, uri.port) + http.use_ssl = uri.scheme == 'https' resp = http.request(req) body = begin @@ -179,7 +183,19 @@ def execute_datamap(tool_defs, tool_name, args) rescue JSON::ParserError resp.body end - { 'status' => resp.code.to_i, 'url' => url, 'body' => body } + [resp.code.to_i, body] +end + +def execute_datamap(tool_defs, tool_name, args) + # DataMap skills register definitions under :datamap (Ruby) — find + # the matching one, extract its first webhook URL, and execute the + # request the same way the SignalWire platform would. + webhook = datamap_webhook(tool_defs, tool_name) + url = expand_template(either(webhook, :url), args) + method = (either(webhook, :method) || 'GET').upcase + + status, body = datamap_fetch(url, datamap_request(webhook, url, method)) + { 'status' => status, 'url' => url, 'body' => body } end result = From 3bc703ac52832a3b65995b37d78e06fa31dbec4f Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:21:16 -0400 Subject: [PATCH 60/90] lint(examples): clear the 13 Layout/LineLength offenses (13 -> 0) Twelve of the thirteen were caused by the FLUENT-CHAIN ALIGNMENT, not by the code: rubocop aligns `.method` continuations under the receiver, so a `SignalWire::Swaig::FunctionResult.new(...)` receiver pushed every subsequent line 40+ columns right and a normal-length argument list overflowed 120. Fixed by binding the receiver first and chaining from column 2 -- which is both shorter and easier to read. This is safe because every mutator in these builders (DataMap#purpose/parameter/webhook/webhook_expressions, FunctionResult#join_room/set_metadata/tap/...) mutates the receiver in place and returns self, so the discarded chain result is irrelevant. The other two were long string literals, split with `\` continuation (concatenation verified to produce the identical string). Verified, not assumed: for every rebound chain the emitted structure is BYTE-IDENTICAL before vs after (703/745/1057/384/410/617 bytes across datamap_demo, advanced_datamap_demo, room_and_sip_example, tap_example), and all seven touched examples produce identical stdout under SIGNALWIRE_SUPPRESS_RUN (timestamp + autogenerated-auth-UUID normalized). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- examples/advanced_datamap_demo.rb | 58 ++++++++++++++++--------------- examples/datamap_demo.rb | 9 ++--- examples/datasphere.rb | 34 +++++++++--------- examples/faq_bot_agent.rb | 3 +- examples/room_and_sip_example.rb | 34 +++++++++--------- examples/swml_service_example.rb | 3 +- examples/tap_example.rb | 15 ++++---- 7 files changed, 83 insertions(+), 73 deletions(-) diff --git a/examples/advanced_datamap_demo.rb b/examples/advanced_datamap_demo.rb index 731f2b5a..51581a91 100644 --- a/examples/advanced_datamap_demo.rb +++ b/examples/advanced_datamap_demo.rb @@ -12,9 +12,10 @@ # --- Expression-based command processor --- command_processor = SignalWire::DataMap.new('command_processor') - .purpose('Process user commands with pattern matching') - .parameter('command', 'string', 'User command to process', required: true) - .parameter('target', 'string', 'Optional target for the command', required: false) +command_processor + .purpose('Process user commands with pattern matching') + .parameter('command', 'string', 'User command to process', required: true) + .parameter('target', 'string', 'Optional target for the command', required: false) command_processor.expression( '${args.command}', '^start', @@ -35,31 +36,32 @@ # --- Advanced webhook tool --- advanced_api = SignalWire::DataMap.new('advanced_api_tool') - .purpose('API tool with advanced webhook features') - .parameter('action', 'string', 'Action to perform', required: true) - .parameter('data', 'string', 'Data to send', required: false) - .webhook( - 'POST', 'https://api.example.com/advanced', - headers: { - 'Authorization' => 'Bearer ${token}', - 'User-Agent' => 'SignalWire-Agent/1.0' - }, - input_args_as_params: true, - require_args: ['action'], - form_param: 'payload' - ) - .webhook_expressions([ - { - 'string' => '${response.status}', - 'pattern' => '^success$', - 'output' => { 'response' => 'Operation completed successfully' } - }, - { - 'string' => '${response.error_code}', - 'pattern' => '^(404|500)$', - 'output' => { 'response' => 'API Error: ${response.error_message}' } - } - ]) +advanced_api + .purpose('API tool with advanced webhook features') + .parameter('action', 'string', 'Action to perform', required: true) + .parameter('data', 'string', 'Data to send', required: false) + .webhook( + 'POST', 'https://api.example.com/advanced', + headers: { + 'Authorization' => 'Bearer ${token}', + 'User-Agent' => 'SignalWire-Agent/1.0' + }, + input_args_as_params: true, + require_args: ['action'], + form_param: 'payload' + ) + .webhook_expressions([ + { + 'string' => '${response.status}', + 'pattern' => '^success$', + 'output' => { 'response' => 'Operation completed successfully' } + }, + { + 'string' => '${response.error_code}', + 'pattern' => '^(404|500)$', + 'output' => { 'response' => 'API Error: ${response.error_message}' } + } + ]) # Fallback webhook advanced_api.webhook( diff --git a/examples/datamap_demo.rb b/examples/datamap_demo.rb index f2b4df45..fd9106e1 100644 --- a/examples/datamap_demo.rb +++ b/examples/datamap_demo.rb @@ -35,10 +35,11 @@ # --- DataMap Tool 2: Expression-based calculator --- calculator = SignalWire::DataMap.new('simple_math') - .purpose('Evaluate a simple math expression') - .parameter('expression', 'string', 'A math expression like "add", "subtract"', required: true) - .parameter('a', 'number', 'First number', required: true) - .parameter('b', 'number', 'Second number', required: true) +calculator + .purpose('Evaluate a simple math expression') + .parameter('expression', 'string', 'A math expression like "add", "subtract"', required: true) + .parameter('a', 'number', 'First number', required: true) + .parameter('b', 'number', 'Second number', required: true) calculator.expression( '${args.expression}', diff --git a/examples/datasphere.rb b/examples/datasphere.rb index 512f5b72..e4cfa84c 100644 --- a/examples/datasphere.rb +++ b/examples/datasphere.rb @@ -32,14 +32,15 @@ # Instance 1: Drinks knowledge begin - agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'drinks-doc-123', - 'tool_name' => 'search_drinks_knowledge', - 'tags' => %w[Drinks Bar Cocktails], - 'count' => 2, - 'distance' => 5.0, - 'no_results_message' => "I couldn't find drink info about '{query}'. Try a different cocktail." - )) + drinks = example_config.merge( + 'document_id' => 'drinks-doc-123', + 'tool_name' => 'search_drinks_knowledge', + 'tags' => %w[Drinks Bar Cocktails], + 'count' => 2, + 'distance' => 5.0, + 'no_results_message' => "I couldn't find drink info about '{query}'. Try a different cocktail." + ) + agent.add_skill('datasphere', drinks) puts 'Added drinks knowledge (tool: search_drinks_knowledge)' rescue StandardError => e puts "Drinks DataSphere: #{e.message}" @@ -47,14 +48,15 @@ # Instance 2: Food knowledge begin - agent.add_skill('datasphere', example_config.merge( - 'document_id' => 'food-doc-456', - 'tool_name' => 'search_food_knowledge', - 'tags' => %w[Food Recipes Cooking], - 'count' => 3, - 'distance' => 4.0, - 'no_results_message' => "I couldn't find recipes about '{query}'. Try a different dish." - )) + food = example_config.merge( + 'document_id' => 'food-doc-456', + 'tool_name' => 'search_food_knowledge', + 'tags' => %w[Food Recipes Cooking], + 'count' => 3, + 'distance' => 4.0, + 'no_results_message' => "I couldn't find recipes about '{query}'. Try a different dish." + ) + agent.add_skill('datasphere', food) puts 'Added food knowledge (tool: search_food_knowledge)' rescue StandardError => e puts "Food DataSphere: #{e.message}" diff --git a/examples/faq_bot_agent.rb b/examples/faq_bot_agent.rb index 9339adc2..5399d0ba 100644 --- a/examples/faq_bot_agent.rb +++ b/examples/faq_bot_agent.rb @@ -57,7 +57,8 @@ # Post-prompt for conversation summary agent.post_prompt = - 'Provide a JSON summary: {"question_type": "CATEGORY", "answered_from_kb": true/false, "follow_up_needed": true/false}' + 'Provide a JSON summary: {"question_type": "CATEGORY", ' \ + '"answered_from_kb": true/false, "follow_up_needed": true/false}' agent.on_summary(nil) do |summary, _raw_data| puts "FAQ Bot summary: #{summary.inspect}" diff --git a/examples/room_and_sip_example.rb b/examples/room_and_sip_example.rb index 30108857..e0aef32d 100644 --- a/examples/room_and_sip_example.rb +++ b/examples/room_and_sip_example.rb @@ -21,14 +21,15 @@ puts '=== Conference Room ===' conf_room = SignalWire::Swaig::FunctionResult.new('Setting up daily standup meeting') - .join_room('daily_standup_room') - .set_metadata( - 'meeting_type' => 'daily_standup', - 'participant_id' => 'user_123', - 'role' => 'scrum_master' - ) - .update_global_data('meeting_active' => true, 'room_name' => 'daily_standup_room') - .say('You have joined the daily standup meeting') +conf_room + .join_room('daily_standup_room') + .set_metadata( + 'meeting_type' => 'daily_standup', + 'participant_id' => 'user_123', + 'role' => 'scrum_master' + ) + .update_global_data('meeting_active' => true, 'room_name' => 'daily_standup_room') + .say('You have joined the daily standup meeting') puts JSON.pretty_generate(conf_room.to_h) puts @@ -54,12 +55,13 @@ puts '=== Advanced Conference ===' adv_conf = SignalWire::Swaig::FunctionResult.new('Setting up recorded conference') - .join_conference( - 'customer_training_session', - record: 'record-from-start', - max_participants: 50, - status_callback: 'https://api.company.com/conference-events', - status_callback_event: 'start end join leave' - ) - .set_metadata('session_type' => 'customer_training', 'facilitator' => 'training_team') +adv_conf + .join_conference( + 'customer_training_session', + record: 'record-from-start', + max_participants: 50, + status_callback: 'https://api.company.com/conference-events', + status_callback_event: 'start end join leave' + ) + .set_metadata('session_type' => 'customer_training', 'facilitator' => 'training_team') puts JSON.pretty_generate(adv_conf.to_h) diff --git a/examples/swml_service_example.rb b/examples/swml_service_example.rb index 13a6bc82..9e778195 100755 --- a/examples/swml_service_example.rb +++ b/examples/swml_service_example.rb @@ -90,7 +90,8 @@ def example_using_ai service.answer service.ai( 'prompt' => { - 'text' => 'You are a friendly receptionist. Greet the caller, ask how you can help, and answer questions about our company.' + 'text' => 'You are a friendly receptionist. Greet the caller, ask how ' \ + 'you can help, and answer questions about our company.' }, 'params' => { 'temperature' => 0.7 }, 'languages' => [ diff --git a/examples/tap_example.rb b/examples/tap_example.rb index eba86137..0f982836 100644 --- a/examples/tap_example.rb +++ b/examples/tap_example.rb @@ -60,11 +60,12 @@ puts '=== Multi-Tap ===' multi = SignalWire::Swaig::FunctionResult.new('Initialising multi-stream monitoring') - .tap('wss://compliance.company.com/stream', control_id: 'compliance_stream', direction: 'both') - .tap('rtp://analytics.company.com:5006', control_id: 'analytics_stream', codec: 'PCMA') - .tap('wss://quality.company.com/monitoring', control_id: 'quality_stream', direction: 'speak') - .update_global_data( - 'active_streams' => %w[compliance analytics quality], - 'monitoring_level' => 'comprehensive' - ) +multi + .tap('wss://compliance.company.com/stream', control_id: 'compliance_stream', direction: 'both') + .tap('rtp://analytics.company.com:5006', control_id: 'analytics_stream', codec: 'PCMA') + .tap('wss://quality.company.com/monitoring', control_id: 'quality_stream', direction: 'speak') + .update_global_data( + 'active_streams' => %w[compliance analytics quality], + 'monitoring_level' => 'comprehensive' + ) puts JSON.pretty_generate(multi.to_h) From 671802cb36135937aa2a4bcc49aa07a2411e9ed6 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:25:08 -0400 Subject: [PATCH 61/90] lint: clear the last non-Metrics offenses in bin/*-dump + examples/ Six sites, each a real (if small) improvement rather than a suppression: * bin/secret-scrub-dump -- Style/FileOpen was pointing at a GENUINE LATENT FD LEAK. `capture = File.open(path, 'w')` sat on its own line, then `$stdout.dup` and `$stderr.dup` ran BEFORE the begin/ensure that owned `capture.close` -- so a raise from either dup leaked the descriptor. Moved to the block form (with_fds_captured), which closes it structurally, and split the client push into push_authorization_state. * bin/relay-liveness-dump -- Lint/ShadowedException: `rescue EOFError, IOError` had a dead first arm (EOFError IS an IOError). Errno::ECONNRESET is a SystemCallError, not an IOError, and stays listed. Also hoisted the `%i[text binary]` literal out of the frame-read loop (Performance/CollectionLiteralInLoop) into a frozen constant. * bin/state-dump -- Naming/MethodParameterName on `ig`; renamed to `gatherer` and folded the each/break scan into a `find(...)&.fetch(...) || {}`. * bin/swml-dump -- Style/ReduceToHash: each_with_object -> to_h. * bin/wait-liveness-dump + examples/simple_dynamic_agent.rb -- Style/SafeNavigation. 45 offenses remain, all Metrics/* (size + complexity), handled next. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/relay-liveness-dump | 11 ++++- bin/secret-scrub-dump | 73 +++++++++++++++++++------------- bin/state-dump | 15 +++---- bin/swml-dump | 2 +- bin/wait-liveness-dump | 2 +- examples/simple_dynamic_agent.rb | 2 +- 6 files changed, 60 insertions(+), 45 deletions(-) diff --git a/bin/relay-liveness-dump b/bin/relay-liveness-dump index 25f94624..85eda67b 100755 --- a/bin/relay-liveness-dump +++ b/bin/relay-liveness-dump @@ -63,6 +63,10 @@ AUTH_REQUIRED_CODE = -32_002 # outgoing) so it needs no async runtime. # ====================================================================== class ControllableWsServer + # Frame types read_ws_message treats as a message payload. Hoisted out of the + # read loop so the array literal is allocated once, not once per frame. + DATA_FRAME_TYPES = %i[text binary].freeze + attr_reader :port # fault: :auth_reject | :dead_peer | :black_hole | :reconnect @@ -184,11 +188,14 @@ class ControllableWsServer loop do @frame_parser << sock.readpartial(4096) while (frame = @frame_parser.next) - return frame.to_s if %i[text binary].include?(frame.type) + return frame.to_s if DATA_FRAME_TYPES.include?(frame.type) return nil if frame.type == :close end end - rescue EOFError, IOError, Errno::ECONNRESET + # EOFError is an IOError subclass, so the previous `rescue EOFError, IOError` + # had a dead first arm. Errno::ECONNRESET is a SystemCallError, NOT an + # IOError, so it must stay listed. + rescue IOError, Errno::ECONNRESET nil end diff --git a/bin/secret-scrub-dump b/bin/secret-scrub-dump index 3912be4b..692c237a 100755 --- a/bin/secret-scrub-dump +++ b/bin/secret-scrub-dump @@ -50,6 +50,48 @@ REAL_STDOUT = $stdout.dup # Drive connect + an inbound authorization.state event at debug, capturing every # byte the SDK writes to stdout+stderr into +capture_path+. +# Run the block with BOTH real fds redirected to +capture_path+, restoring them +# afterwards. The block form of File.open is load-bearing here: the previous +# explicit `File.open` + `ensure capture.close` leaked the descriptor if either +# `$stdout.dup` / `$stderr.dup` between them raised, because those two lines sat +# OUTSIDE the begin/ensure that owned the close. +def with_fds_captured(capture_path) + File.open(capture_path, 'w') do |capture| + orig_out = $stdout.dup + orig_err = $stderr.dup + begin + $stdout.reopen(capture) + $stderr.reopen(capture) + yield + ensure + $stdout.reopen(orig_out) + $stderr.reopen(orig_err) + end + end +end + +# Connect + push one inbound authorization.state event, then tear the client down. +def push_authorization_state + require_relative '../tests/relay/mock_test' + SignalWire::Logging.reset! + + handle = RelayMockTest.client(project: PROJECT_SENTINEL, token: TOKEN_SENTINEL) + begin + # Inbound re-auth blob — the << frame-log site's payload. + handle[:mock].push( + 'jsonrpc' => '2.0', + 'method' => 'signalwire.event', + 'params' => { + 'event_type' => 'signalwire.authorization.state', + 'params' => { 'authorization_state' => AUTHSTATE_SENTINEL } + } + ) + sleep 0.2 # let the inbound frame be read + dispatched (+ logged, if it were) + ensure + RelayMockTest.shutdown_client(handle) + end +end + def drive_and_capture(capture_path) ENV['SIGNALWIRE_LOG_MODE'] = 'debug' ENV['SIGNALWIRE_LOG_LEVEL'] = 'debug' @@ -57,36 +99,7 @@ def drive_and_capture(capture_path) # Redirect BOTH real fds to the capture file so the SDK's Logger (bound to # $stderr at construction) + any Kernel#warn land in the capture, then build # the client so its logger captures the redirected stream. - capture = File.open(capture_path, 'w') - orig_out = $stdout.dup - orig_err = $stderr.dup - $stdout.reopen(capture) - $stderr.reopen(capture) - - begin - require_relative '../tests/relay/mock_test' - SignalWire::Logging.reset! - - handle = RelayMockTest.client(project: PROJECT_SENTINEL, token: TOKEN_SENTINEL) - begin - # Inbound re-auth blob — the << frame-log site's payload. - handle[:mock].push( - 'jsonrpc' => '2.0', - 'method' => 'signalwire.event', - 'params' => { - 'event_type' => 'signalwire.authorization.state', - 'params' => { 'authorization_state' => AUTHSTATE_SENTINEL } - } - ) - sleep 0.2 # let the inbound frame be read + dispatched (+ logged, if it were) - ensure - RelayMockTest.shutdown_client(handle) - end - ensure - $stdout.reopen(orig_out) - $stderr.reopen(orig_err) - capture.close - end + with_fds_captured(capture_path) { push_authorization_state } end def main diff --git a/bin/state-dump b/bin/state-dump index 27b515f3..915a09d5 100755 --- a/bin/state-dump +++ b/bin/state-dump @@ -53,16 +53,11 @@ end # to the observable delta (mirrors diff_port_state submit_answer_delta): the # set_global_data action's question_index + answers, plus a `done` flag derived # from the completion message. -def submit_answer_delta(ig, args, raw_data) - result = ig.handle_submit(args, raw_data) - h = result.to_h - gd = {} - Array(h['action']).each do |action| - if action.is_a?(Hash) && action.key?('set_global_data') - gd = action['set_global_data'] - break - end - end +def submit_answer_delta(gatherer, args, raw_data) + h = gatherer.handle_submit(args, raw_data).to_h + gd = Array(h['action']) + .find { |action| action.is_a?(Hash) && action.key?('set_global_data') } + &.fetch('set_global_data') || {} { 'question_index' => gd['question_index'], 'answers' => gd['answers'], diff --git a/bin/swml-dump b/bin/swml-dump index 011833af..986d543e 100755 --- a/bin/swml-dump +++ b/bin/swml-dump @@ -64,7 +64,7 @@ end def pick(frag, keys) return frag unless frag.is_a?(Hash) - keys.each_with_object({}) { |k, acc| acc[k] = frag[k] } + keys.to_h { |k| [k, frag[k]] } end # swaig_field selects one SWAIG function by name from a functions list, then diff --git a/bin/wait-liveness-dump b/bin/wait-liveness-dump index f098e648..c94be2ac 100755 --- a/bin/wait-liveness-dump +++ b/bin/wait-liveness-dump @@ -154,7 +154,7 @@ def run_case(handle, kase) begin event = action.wait(timeout: DEADLINE_S) t_return = Process.clock_gettime(Process::CLOCK_MONOTONIC) - completed_state = (event && event.params ? event.params['state'].to_s : '') + completed_state = event&.params ? event.params['state'].to_s : '' rescue SignalWire::Relay::ActionTimeoutError, Timeout::Error timed_out = true end diff --git a/examples/simple_dynamic_agent.rb b/examples/simple_dynamic_agent.rb index 72d3c3cb..2a132281 100644 --- a/examples/simple_dynamic_agent.rb +++ b/examples/simple_dynamic_agent.rb @@ -47,7 +47,7 @@ # Customise based on a header lang = headers['accept-language'] - ephemeral.add_language('Spanish', 'es-US', 'elevenlabs.antonio') if lang && lang.start_with?('es') + ephemeral.add_language('Spanish', 'es-US', 'elevenlabs.antonio') if lang&.start_with?('es') end # Define a tool that uses global_data set by the dynamic config From e0e13adf2f337d6f3988ceb80157e06ebb7e3fb1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:30:02 -0400 Subject: [PATCH 62/90] lint(bin): decompose swml-dump / wait-liveness-dump / secret-scrub-dump Metrics/* burn for three Layer-D dump programs, by extraction only -- no cop suppressed, no per-file exclude added. The shipped lib/ tree already meets MethodLength <= 10 across its whole surface with exactly ONE per-file exception, so that is the demonstrated bar, not an aspiration. bin/swml-dump extract/9-cyclo -> ai_verb + extract bin/wait-liveness-dump run_case/AbcSize-39 -> answered_call + arm_answerer + await_action + measure_wait + run_case_isolated; classify's early-return literal hoisted to a constant bin/secret-scrub-dump with_fds_pointed_at split out of with_fds_captured; drive_into split out of captured_output; the inbound authorization.state frame hoisted to AUTHSTATE_EVENT Every extraction preserves the exact semantics, including the two subtle ones: measure_wait's `timed_out` is still true on BOTH the rescue path and the returned-nil-event path, and swml-dump's ai_verb still yields nil when the 'ai' key is present but nil. Verified live, not by reading: the porting-sdk behavioral suite passes all four rules that actually EXECUTE these programs -- BEHAVIORAL-SWML / WAIT-LIVENESS / SECRET-SCRUB / SECRET-SCRUB-LIVE. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/secret-scrub-dump | 78 +++++++++++++++-------------- bin/swml-dump | 14 +++--- bin/wait-liveness-dump | 111 ++++++++++++++++++++++------------------- 3 files changed, 109 insertions(+), 94 deletions(-) diff --git a/bin/secret-scrub-dump b/bin/secret-scrub-dump index 692c237a..df002823 100755 --- a/bin/secret-scrub-dump +++ b/bin/secret-scrub-dump @@ -55,21 +55,30 @@ REAL_STDOUT = $stdout.dup # explicit `File.open` + `ensure capture.close` leaked the descriptor if either # `$stdout.dup` / `$stderr.dup` between them raised, because those two lines sat # OUTSIDE the begin/ensure that owned the close. -def with_fds_captured(capture_path) - File.open(capture_path, 'w') do |capture| - orig_out = $stdout.dup - orig_err = $stderr.dup - begin - $stdout.reopen(capture) - $stderr.reopen(capture) - yield - ensure - $stdout.reopen(orig_out) - $stderr.reopen(orig_err) - end - end +def with_fds_pointed_at(capture) + orig = [$stdout.dup, $stderr.dup] + $stdout.reopen(capture) + $stderr.reopen(capture) + yield +ensure + $stdout.reopen(orig[0]) + $stderr.reopen(orig[1]) +end + +def with_fds_captured(capture_path, &block) + File.open(capture_path, 'w') { |capture| with_fds_pointed_at(capture, &block) } end +# Inbound re-auth blob — the << frame-log site's payload. +AUTHSTATE_EVENT = { + 'jsonrpc' => '2.0', + 'method' => 'signalwire.event', + 'params' => { + 'event_type' => 'signalwire.authorization.state', + 'params' => { 'authorization_state' => AUTHSTATE_SENTINEL } + } +}.freeze + # Connect + push one inbound authorization.state event, then tear the client down. def push_authorization_state require_relative '../tests/relay/mock_test' @@ -77,15 +86,7 @@ def push_authorization_state handle = RelayMockTest.client(project: PROJECT_SENTINEL, token: TOKEN_SENTINEL) begin - # Inbound re-auth blob — the << frame-log site's payload. - handle[:mock].push( - 'jsonrpc' => '2.0', - 'method' => 'signalwire.event', - 'params' => { - 'event_type' => 'signalwire.authorization.state', - 'params' => { 'authorization_state' => AUTHSTATE_SENTINEL } - } - ) + handle[:mock].push(AUTHSTATE_EVENT) sleep 0.2 # let the inbound frame be read + dispatched (+ logged, if it were) ensure RelayMockTest.shutdown_client(handle) @@ -102,24 +103,27 @@ def drive_and_capture(capture_path) with_fds_captured(capture_path) { push_authorization_state } end -def main +# Everything the SDK wrote to stdout+stderr during one debug-level drive. A +# drive failure is NOT fatal: whatever was captured before the failure still +# answers "did a sentinel leak?", and the failure itself goes to the real stderr. +def drive_into(capture_path) + drive_and_capture(capture_path) +rescue StandardError => e + warn "[secret-scrub-dump] drive failed: #{e.class}: #{e.message}" +end + +def captured_output capture = Tempfile.new(['secret-scrub-capture', '.log']) - capture_path = capture.path capture.close + drive_into(capture.path) + File.read(capture.path) +ensure + capture&.unlink +end - begin - drive_and_capture(capture_path) - rescue StandardError => e - warn "[secret-scrub-dump] drive failed: #{e.class}: #{e.message}" - end - - captured = File.read(capture_path) - capture.unlink - - out = {} - CORPUS.each do |kase| - out[kase['id']] = { 'leaked' => captured.include?(kase['sentinel']) } - end +def main + captured = captured_output + out = CORPUS.to_h { |kase| [kase['id'], { 'leaked' => captured.include?(kase['sentinel']) }] } REAL_STDOUT.puts(JSON.generate(out)) REAL_STDOUT.flush diff --git a/bin/swml-dump b/bin/swml-dump index 986d543e..988382a5 100755 --- a/bin/swml-dump +++ b/bin/swml-dump @@ -43,14 +43,16 @@ end # extract walks a dotted path into a rendered SWML doc. "ai.prompt" means: find # the ai verb in sections.main, then index into it — the Ruby mirror of # diff_port_swml._extract. -def extract(doc, path) - ai = nil +def ai_verb(doc) sections = doc['sections'] main = sections.is_a?(Hash) ? sections['main'] : nil - if main.is_a?(Array) - found = main.find { |sec| sec.is_a?(Hash) && sec.key?('ai') } - ai = found['ai'] if found - end + return nil unless main.is_a?(Array) + + main.find { |sec| sec.is_a?(Hash) && sec.key?('ai') }&.fetch('ai', nil) +end + +def extract(doc, path) + ai = ai_verb(doc) node = ai.nil? ? doc : { 'ai' => ai } path.split('.').each do |part| return nil unless node.is_a?(Hash) diff --git a/bin/wait-liveness-dump b/bin/wait-liveness-dump index c94be2ac..a0e85c0e 100755 --- a/bin/wait-liveness-dump +++ b/bin/wait-liveness-dump @@ -85,19 +85,19 @@ VERB_METHOD = { # Derive the deterministic liveness classification from the measured instants. # Mirrors classify_liveness() in the differ byte-for-byte. +TIMED_OUT_CLASSIFICATION = { + 'blocked_until_event' => false, + 'returned_after_event' => false, + 'completed_state' => '', + 'timed_out' => true +}.freeze + def classify(delay_ms, t_wait_start, t_return, completed_state, timed_out) - if timed_out || t_return.nil? - return { - 'blocked_until_event' => false, - 'returned_after_event' => false, - 'completed_state' => '', - 'timed_out' => true - } - end + return TIMED_OUT_CLASSIFICATION.dup if timed_out || t_return.nil? + elapsed_ms = (t_return - t_wait_start) * 1000.0 - blocked = elapsed_ms >= (delay_ms - BLOCK_TOL_MS) { - 'blocked_until_event' => blocked, + 'blocked_until_event' => elapsed_ms >= (delay_ms - BLOCK_TOL_MS), 'returned_after_event' => true, 'completed_state' => completed_state, 'timed_out' => false @@ -117,66 +117,75 @@ def start_action(call, verb, kwargs) end end -# Drive ONE liveness case against the real mock and return its classification. -def run_case(handle, kase) - client = handle[:client] - mock = handle[:mock] - delay_ms = kase['delay_ms'].to_i - terminal = kase['terminal'] - verb = kase['verb'] - method = VERB_METHOD.fetch(verb) - - # Establish an answered inbound call (mirrors RelayActionsTestBase helper). - captured = Queue.new - done = Queue.new +# Answer the next inbound call, pushing it onto +captured+ once answered. +def arm_answerer(client, captured, done) client.on_call(nil) do |call| captured.push(call) call.answer done.push(true) end +end + +# Establish an answered inbound call (mirrors RelayActionsTestBase helper). +def answered_call(client, mock, verb) + captured = Queue.new + done = Queue.new + arm_answerer(client, captured, done) mock.inbound_call(call_id: "live-#{verb}", auto_states: ['created']) Timeout.timeout(DEADLINE_S) { done.pop } - call = Timeout.timeout(DEADLINE_S) { captured.pop } - call.state = 'answered' + Timeout.timeout(DEADLINE_S) { captured.pop }.tap { |call| call.state = 'answered' } +end + +# Block on +action+, returning [t_return_or_nil, completing_event_or_nil]. +def await_action(action) + event = action.wait(timeout: DEADLINE_S) + [Process.clock_gettime(Process::CLOCK_MONOTONIC), event] +rescue SignalWire::Relay::ActionTimeoutError, Timeout::Error + [nil, nil] +end + +# Block on +action+ and report [t_wait_start, t_return, completed_state, +# timed_out] — the four measured instants classify() consumes. +def measure_wait(action) + t_wait_start = Process.clock_gettime(Process::CLOCK_MONOTONIC) + t_return, event = await_action(action) + # A wait() that returns nil (no event) within the deadline is a no-op / hung + # equivalent: treat a nil return as timed_out so the classification is honest. + timed_out = t_return.nil? || event.nil? + [t_wait_start, t_return, event&.params ? event.params['state'].to_s : '', timed_out] +end + +# Drive ONE liveness case against the real mock and return its classification. +def run_case(handle, kase) + verb = kase['verb'] + delay_ms = kase['delay_ms'].to_i + call = answered_call(handle[:client], handle[:mock], verb) # Arm the DEFERRED completing event: the mock emits {state: terminal.state} # for this method after delay_ms, delivered through the SDK's real socket-read # event-dispatch path. A no-op / non-pumping wait() cannot observe it. - mock.arm_method(method, [{ 'emit' => { 'state' => terminal['state'] }, 'delay_ms' => delay_ms }]) + handle[:mock].arm_method( + VERB_METHOD.fetch(verb), + [{ 'emit' => { 'state' => kase['terminal']['state'] }, 'delay_ms' => delay_ms }] + ) action = start_action(call, verb, kase['kwargs'] || {}) + classify(delay_ms, *measure_wait(action)) +end - t_wait_start = Process.clock_gettime(Process::CLOCK_MONOTONIC) - timed_out = false - t_return = nil - completed_state = '' - event = nil +# A fresh client/session per case so a scoped scenario/journal never crosses +# between cases (mirrors the per-test client isolation in actions_mock_test.rb). +def run_case_isolated(kase) + handle = RelayMockTest.client begin - event = action.wait(timeout: DEADLINE_S) - t_return = Process.clock_gettime(Process::CLOCK_MONOTONIC) - completed_state = event&.params ? event.params['state'].to_s : '' - rescue SignalWire::Relay::ActionTimeoutError, Timeout::Error - timed_out = true + run_case(handle, kase) + ensure + RelayMockTest.shutdown_client(handle) if handle end - # A wait() that returns nil (no event) within the deadline is a no-op / hung - # equivalent: treat a nil return as timed_out so the classification is honest. - timed_out = true if t_return && event.nil? - - classify(delay_ms, t_wait_start, t_return, completed_state, timed_out) end def main - out = {} - # A fresh client/session per case so a scoped scenario/journal never crosses - # between cases (mirrors the per-test client isolation in actions_mock_test.rb). - CORPUS.each do |kase| - handle = RelayMockTest.client - begin - out[kase['id']] = run_case(handle, kase) - ensure - RelayMockTest.shutdown_client(handle) if handle - end - end + out = CORPUS.to_h { |kase| [kase['id'], run_case_isolated(kase)] } REAL_STDOUT.puts(JSON.generate(out)) 0 end From e6c4ca6c63be73bc0cebff018e4681f3136a2bf8 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:37:25 -0400 Subject: [PATCH 63/90] lint(bin): split relay-liveness-dump's transport from its fault policy 15 Metrics offenses -> 0, all by extraction. The load-bearing change is a real separation of concerns rather than a size trick: * NEW module WsFraming holds the pure WebSocket TRANSPORT -- upgrade handshake, read-one-message, write text/close frame, close quietly -- with zero fault knowledge. ControllableWsServer includes it and is now only the fault policy (125-line class -> under the limit as a side effect). * with_fault_server(fault) captures the skeleton every connect-level driver repeated verbatim: stand up the server, point a fresh client at it, run, then tear BOTH down in an ensure. Four drivers + probe_auth_raise collapsed onto it, so the teardown can no longer be forgotten in a new one. * main's ten hand-written `out[...] = drive_x` lines became a FIXTURES ordered hash of id -> driver lambda, consumed by transform_values. Adding a fixture is now one line and cannot skip the emit. * probe_dead_peer / probe_execute_outcome / await_reconnect / construction_argument_error / offer_inbound_call / send_auth_reject / drop_post_auth / close_quietly extracted from their oversized callers. Verified live: the porting-sdk RELAY-LIVENESS behavioral rule -- which executes this exact program against the differ's golden and structurally compares all ten fixtures' classification maps -- PASSES. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/relay-liveness-dump | 418 ++++++++++++++++++++-------------------- 1 file changed, 208 insertions(+), 210 deletions(-) diff --git a/bin/relay-liveness-dump b/bin/relay-liveness-dump index 85eda67b..ea26ddf4 100755 --- a/bin/relay-liveness-dump +++ b/bin/relay-liveness-dump @@ -56,6 +56,74 @@ require_relative '../lib/signalwire/relay/client' # The RELAY error code a server sends to reject connect credentials. AUTH_REQUIRED_CODE = -32_002 +# ====================================================================== +# WsFraming — the pure WebSocket TRANSPORT half of the fault server: upgrade +# handshake, read one message, write a text/close frame, close quietly. Holds no +# fault knowledge, so ControllableWsServer below is only the fault policy. +# ====================================================================== +module WsFraming + # Frame types read_ws_message treats as a message payload. Hoisted out of the + # read loop so the array literal is allocated once, not once per frame. + DATA_FRAME_TYPES = %i[text binary].freeze + + # Perform the WebSocket upgrade handshake using the `websocket` gem. + def ws_handshake(sock) + handshake = WebSocket::Handshake::Server.new + until handshake.finished? + line = sock.gets + return false if line.nil? + + handshake << line + end + sock.write(handshake.to_s) + @frame_parser = WebSocket::Frame::Incoming::Server.new(version: handshake.version) + true + end + + # Read ONE text WebSocket message (handles fragmentation via the parser). + def read_ws_message(sock) + loop do + @frame_parser << sock.readpartial(4096) + while (frame = @frame_parser.next) + return frame.to_s if DATA_FRAME_TYPES.include?(frame.type) + return nil if frame.type == :close + end + end + # EOFError is an IOError subclass, so the previous `rescue EOFError, IOError` + # had a dead first arm. Errno::ECONNRESET is a SystemCallError, NOT an + # IOError, so it must stay listed. + rescue IOError, Errno::ECONNRESET + nil + end + + def send_ws(sock, text) + write_frame(sock, WebSocket::Frame::Outgoing::Server.new( + data: text, type: :text, version: @frame_parser.version + )) + end + + # Send a WebSocket CLOSE frame so the client's gem fires its :close callback + # (a raw TCP close alone may not surface as a clean close to the reader). + def send_ws_close(sock) + write_frame(sock, WebSocket::Frame::Outgoing::Server.new( + type: :close, version: @frame_parser.version + )) + end + + def write_frame(sock, frame) + sock.write(frame.to_s) + sock.flush + rescue StandardError + nil + end + + def close_quietly(sock) + sock.close + rescue StandardError + nil + end +end + # ====================================================================== # ControllableWsServer — a minimal single-connection WebSocket server that # speaks ruby's signalwire.connect handshake, then injects one fault. Built on @@ -63,9 +131,7 @@ AUTH_REQUIRED_CODE = -32_002 # outgoing) so it needs no async runtime. # ====================================================================== class ControllableWsServer - # Frame types read_ws_message treats as a message payload. Hoisted out of the - # read loop so the array literal is allocated once, not once per frame. - DATA_FRAME_TYPES = %i[text binary].freeze + include WsFraming attr_reader :port @@ -108,30 +174,11 @@ class ControllableWsServer return unless ws_handshake(sock) @mutex.synchronize { @connects += 1 } - drop_after_auth = @fault == :reconnect && connect_count == 1 - serve_frames(sock, drop_after_auth) + serve_frames(sock, @fault == :reconnect && connect_count == 1) rescue StandardError nil ensure - begin - sock.close - rescue StandardError - nil - end - end - - # Perform the WebSocket upgrade handshake using the `websocket` gem. - def ws_handshake(sock) - handshake = WebSocket::Handshake::Server.new - until handshake.finished? - line = sock.gets - return false if line.nil? - - handshake << line - end - sock.write(handshake.to_s) - @frame_parser = WebSocket::Frame::Incoming::Server.new(version: handshake.version) - true + close_quietly(sock) end # Read frames; when a signalwire.connect arrives, inject the fault. @@ -149,31 +196,38 @@ class ControllableWsServer end end + def send_auth_reject(sock, id) + send_ws(sock, JSON.generate('jsonrpc' => '2.0', 'id' => id, + 'error' => { 'code' => AUTH_REQUIRED_CODE, + 'message' => @auth_message })) + end + + # First connection drops shortly after a SUCCESSFUL auth (let the client enter + # its read loop first, so the drop is a post-auth transient loss — the client + # must then reconnect). Later connections stay up. + def drop_post_auth(sock) + sock.flush + sleep 0.3 + send_ws_close(sock) + sock.close + end + + # Inject this server's fault at the signalwire.connect frame: + # :auth_reject answer with the AUTH_REQUIRED error the client must surface + # :black_hole never answer at all — the client's request await must time out + # :dead_peer answer, then ignore everything (incl. pings) forever + # :reconnect answer, then drop the FIRST connection post-auth def handle_client_frame(sock, msg, drop_after_auth) return unless msg['method'] == 'signalwire.connect' id = msg['id'] case @fault - when :auth_reject - send_ws(sock, JSON.generate('jsonrpc' => '2.0', 'id' => id, - 'error' => { 'code' => AUTH_REQUIRED_CODE, - 'message' => @auth_message })) - when :black_hole - # Never answer the connect — the client's request await must time out. - when :dead_peer - send_connect_ok(sock, id) - # After a successful connect, ignore everything (incl. pings) forever. + when :auth_reject then send_auth_reject(sock, id) + when :black_hole then nil + when :dead_peer then send_connect_ok(sock, id) when :reconnect send_connect_ok(sock, id) - # First connection drops shortly after a SUCCESSFUL auth (let the client - # enter its read loop first, so the drop is a post-auth transient loss — - # the client must then reconnect). Later connections stay up. - if drop_after_auth - sock.flush - sleep 0.3 - send_ws_close(sock) - sock.close - end + drop_post_auth(sock) if drop_after_auth end end @@ -182,189 +236,135 @@ class ControllableWsServer 'result' => { 'protocol' => 'relay_proto_test', 'sessionid' => 'sess-test' })) end - - # Read ONE text WebSocket message (handles fragmentation via the parser). - def read_ws_message(sock) - loop do - @frame_parser << sock.readpartial(4096) - while (frame = @frame_parser.next) - return frame.to_s if DATA_FRAME_TYPES.include?(frame.type) - return nil if frame.type == :close - end - end - # EOFError is an IOError subclass, so the previous `rescue EOFError, IOError` - # had a dead first arm. Errno::ECONNRESET is a SystemCallError, NOT an - # IOError, so it must stay listed. - rescue IOError, Errno::ECONNRESET - nil - end - - def send_ws(sock, text) - out = WebSocket::Frame::Outgoing::Server.new(data: text, type: :text, - version: @frame_parser.version) - sock.write(out.to_s) - sock.flush - rescue StandardError - nil - end - - # Send a WebSocket CLOSE frame so the client's gem fires its :close callback - # (a raw TCP close alone may not surface as a clean close to the reader). - def send_ws_close(sock) - out = WebSocket::Frame::Outgoing::Server.new(type: :close, - version: @frame_parser.version) - sock.write(out.to_s) - sock.flush - rescue StandardError - nil - end end # ====================================================================== # Fixture drivers — each returns its classification map. # ====================================================================== +# Every fault driver has the same skeleton: stand up a ControllableWsServer with +# one fault, point a fresh client at it, do something, then tear BOTH down no +# matter how the body exits. Yields the client and the server. +def with_fault_server(fault, auth_message: nil) + srv = ControllableWsServer.new(fault: fault, auth_message: auth_message) + point_client_at(srv.port) + client = new_fault_client + yield(client, srv) +ensure + safe_stop(client) + srv.stop +end + # cred_missing: constructing a client with an empty credential must fail # PRE-CONNECT (no socket) with a per-variable actionable message naming the env var. +def construction_argument_error(**) + SignalWire::Relay::Client.new(**) + nil +rescue ArgumentError => e + e.message +rescue StandardError + nil +end + def drive_cred_missing(omit, expect_contains) clear_relay_env kwargs = { project: 'p', token: 't', host: 'relay.example.test' } kwargs[omit] = '' - failed = false - msg = '' - begin - SignalWire::Relay::Client.new(**kwargs) - rescue ArgumentError => e - failed = true - msg = e.message - rescue StandardError - failed = false - end - actionable = expect_contains.all? { |w| msg.include?(w) } - { 'failed_preconnect_on_missing' => failed && actionable } + msg = construction_argument_error(**kwargs) + { 'failed_preconnect_on_missing' => !msg.nil? && expect_contains.all? { |w| msg.include?(w) } } end # cred_auth_reject: a 401-class connect rejection must RAISE the server message, # never infinite-reconnect. def drive_cred_auth_reject(server_message) - srv = ControllableWsServer.new(fault: :auth_reject, auth_message: server_message) - out = { 'raised_after_bounded_retry' => false, 'infinite_reconnect' => false, - 'server_message_surfaced' => false } - point_client_at(srv.port) - client = new_fault_client - begin - Timeout.timeout(12) do - client.connect # blocking; connect_and_run_guarded rescues the raise internally - end + infinite = with_fault_server(:auth_reject, auth_message: server_message) do |client| + # blocking; connect_and_run_guarded rescues the raise internally + Timeout.timeout(12) { client.connect } + false rescue Timeout::Error - out['infinite_reconnect'] = true + true end # connect() swallows the raise inside connect_and_run_guarded, so probe the # surfaced error by re-driving the raising path directly. raised, surfaced = probe_auth_raise(server_message) - out['raised_after_bounded_retry'] = raised - out['server_message_surfaced'] = surfaced - out -ensure - safe_stop(client) - srv.stop + { 'raised_after_bounded_retry' => raised, 'infinite_reconnect' => infinite, + 'server_message_surfaced' => surfaced } end # Re-drive the connect handshake through the RAISING path (execute) to observe # the surfaced RelayError message, since connect() itself rescues internally. def probe_auth_raise(server_message) - srv = ControllableWsServer.new(fault: :auth_reject, auth_message: server_message) - point_client_at(srv.port) - client = new_fault_client - raised = false - surfaced = false - begin + with_fault_server(:auth_reject, auth_message: server_message) do |client| Timeout.timeout(12) { client.send(:connect_and_run) } + [false, false] rescue SignalWire::Relay::RelayError => e - raised = true - surfaced = e.message.include?(server_message) + [true, e.message.include?(server_message)] rescue StandardError - raised = false + [false, false] end - [raised, surfaced] -ensure - safe_stop(client) - srv.stop end # dead_peer: connect succeeds, then the peer ignores pings/requests. A subsequent # request must time out (bounded), never hang forever. -def drive_dead_peer - srv = ControllableWsServer.new(fault: :dead_peer) - point_client_at(srv.port) - client = new_fault_client - detected = false - begin - Timeout.timeout(15) do - client.send(:connect_and_run_guarded) # brings socket up + authenticates - # A request against the now-silent peer must bounded-timeout (10s await). - client.execute('calling.play', { 'control_id' => 'x' }) - end - rescue SignalWire::Relay::RelayError - detected = true # bounded error surfaced (request timed out) - rescue Timeout::Error - detected = false # exceeded even our generous outer bound => hung +def probe_dead_peer(client) + Timeout.timeout(15) do + client.send(:connect_and_run_guarded) # brings socket up + authenticates + # A request against the now-silent peer must bounded-timeout (10s await). + client.execute('calling.play', { 'control_id' => 'x' }) end + false +rescue SignalWire::Relay::RelayError + true # bounded error surfaced (request timed out) +rescue Timeout::Error + false # exceeded even our generous outer bound => hung +end + +def drive_dead_peer + detected = with_fault_server(:dead_peer) { |client| probe_dead_peer(client) } { 'detected_bounded' => detected, 'hung' => !detected } -ensure - safe_stop(client) - srv.stop end # black_hole: connect frame is never answered. The client's connect request must # bounded-error within its await deadline, never hang. def drive_black_hole - srv = ControllableWsServer.new(fault: :black_hole) - point_client_at(srv.port) - client = new_fault_client - bounded = false - begin + bounded = with_fault_server(:black_hole) do |client| Timeout.timeout(15) { client.send(:connect_and_run) } - rescue SignalWire::Relay::RelayError - bounded = true # the connect request timed out (bounded), surfaced as an error + false rescue Timeout::Error - bounded = false # never returned => unbounded hang + false # never returned => unbounded hang rescue StandardError - bounded = true # any surfaced transport error is still bounded + # A RelayError means the connect request bounded-errored; any other + # surfaced transport error is still bounded. Both count as bounded. + true end { 'bounded_error' => bounded, 'unbounded_hang' => !bounded } -ensure - safe_stop(client) - srv.stop end # reconnect: the first socket drops right after auth. A REAL second connect+auth # must happen; pending callers faulted (not hung); no zombie. +# True once the fault server has seen a SECOND connect (i.e. a real reconnect +# happened) within the deadline; false if it never does. +def await_reconnect(srv) + Timeout.timeout(20) do + sleep 0.1 until srv.connect_count >= 2 + true + end +rescue Timeout::Error + false +end + def drive_reconnect - srv = ControllableWsServer.new(fault: :reconnect) - point_client_at(srv.port) - client = new_fault_client - run_thread = Thread.new { client.run } - reconnected = false - begin - Timeout.timeout(20) do - sleep 0.1 until srv.connect_count >= 2 - reconnected = true - end - rescue Timeout::Error - reconnected = false + with_fault_server(:reconnect) do |client, srv| + run_thread = Thread.new { client.run } + reconnected = await_reconnect(srv) + # A pending caller across the drop is faulted (RelayError), never hung: prove + # the wiring by seeding a pending entry and rejecting all pending. + faulted = probe_pending_faulted(client) + client.stop + run_thread.join(3) + { 'reconnected' => reconnected, 'pending_faulted_not_hung' => faulted, + 'zombie' => run_thread.alive? } end - # A pending caller across the drop is faulted (RelayError), never hung: prove - # the wiring by seeding a pending entry and rejecting all pending. - faulted = probe_pending_faulted(client) - client.stop - run_thread.join(3) - zombie = run_thread.alive? - { 'reconnected' => reconnected, 'pending_faulted_not_hung' => faulted, - 'zombie' => zombie } -ensure - safe_stop(client) - srv.stop end # Seed a pending request, reject all pending, and assert it faulted (not hung). @@ -379,39 +379,39 @@ end # relay_contract: drive the REAL mock (rpc_code capability) + Call._execute. # 500 must RAISE; 404/410 swallowed. +def probe_execute_outcome(call, verb) + call._execute(verb, { 'control_id' => 'ctl-relay-live-1', + 'play' => [{ 'type' => 'tts', 'params' => { 'text' => 'hi' } }] }) + { 'raised' => false, 'swallowed' => true } +rescue SignalWire::Relay::RelayError + { 'raised' => true, 'swallowed' => false } +end + def drive_relay_contract(verb, code) require_relative '../tests/relay/mock_test' handle = RelayMockTest.client - out = { 'raised' => false, 'swallowed' => false } begin handle[:mock].arm_method("calling.#{verb}", [{ 'rpc_code' => code }]) - call = build_answered_call(handle) - begin - call._execute(verb, { 'control_id' => 'ctl-relay-live-1', - 'play' => [{ 'type' => 'tts', 'params' => { 'text' => 'hi' } }] }) - out['swallowed'] = true - rescue SignalWire::Relay::RelayError - out['raised'] = true - end + probe_execute_outcome(build_answered_call(handle), verb) ensure RelayMockTest.shutdown_client(handle) end - out end # max_active_calls: with cap=N, the N+1th inbound call is dropped (not accepted). +def offer_inbound_call(client, index) + client.send(:handle_inbound_call, + 'params' => { 'call_id' => "c#{index}", 'node_id' => 'node-relay-live', + 'direction' => 'inbound', 'call_state' => 'created' }) +end + def drive_max_active_calls(cap) clear_relay_env client = SignalWire::Relay::Client.new(project: 'p', token: 't', host: 'x', max_active_calls: cap) client.on_call(nil) { |_call| sleep 5 } # keep each accepted call "active" - (cap + 1).times do |i| - client.send(:handle_inbound_call, - 'params' => { 'call_id' => "c#{i}", 'node_id' => 'node-relay-live', - 'direction' => 'inbound', 'call_state' => 'created' }) - end - calls = client.instance_variable_get(:@calls) - { 'cap_enforced' => (calls.size == cap) } + (cap + 1).times { |i| offer_inbound_call(client, i) } + { 'cap_enforced' => client.instance_variable_get(:@calls).size == cap } end # ====================================================================== @@ -440,37 +440,35 @@ end # Establish an answered inbound call against the real mock (for relay_contract). def build_answered_call(handle) - client = handle[:client] - mock = handle[:mock] captured = Queue.new - client.on_call(nil) do |call| + handle[:client].on_call(nil) do |call| call.answer captured.push(call) end - mock.inbound_call(call_id: 'call-relay-live', auto_states: ['created']) - call = Timeout.timeout(10) { captured.pop } - call.state = 'answered' - call + handle[:mock].inbound_call(call_id: 'call-relay-live', auto_states: ['created']) + Timeout.timeout(10) { captured.pop }.tap { |call| call.state = 'answered' } end # ====================================================================== # main # ====================================================================== -def main - out = {} - out['cred_missing_project'] = - drive_cred_missing(:project, %w[project SIGNALWIRE_PROJECT_ID]) - out['cred_missing_token'] = - drive_cred_missing(:token, %w[token SIGNALWIRE_API_TOKEN]) - out['cred_auth_reject'] = drive_cred_auth_reject('auth rejected: bad token') - out['relay_contract_500'] = drive_relay_contract('play', '500') - out['relay_contract_404'] = drive_relay_contract('play', '404') - out['relay_contract_410'] = drive_relay_contract('play', '410') - out['dead_peer_half_open'] = drive_dead_peer - out['black_hole_silent_peer'] = drive_black_hole - out['reconnect_after_drop'] = drive_reconnect - out['max_active_calls_cap'] = drive_max_active_calls(2) +# fixture-id -> the driver that produces its classification map. Insertion order +# is the emission order (mirrors relay_liveness_corpus.py). +FIXTURES = { + 'cred_missing_project' => -> { drive_cred_missing(:project, %w[project SIGNALWIRE_PROJECT_ID]) }, + 'cred_missing_token' => -> { drive_cred_missing(:token, %w[token SIGNALWIRE_API_TOKEN]) }, + 'cred_auth_reject' => -> { drive_cred_auth_reject('auth rejected: bad token') }, + 'relay_contract_500' => -> { drive_relay_contract('play', '500') }, + 'relay_contract_404' => -> { drive_relay_contract('play', '404') }, + 'relay_contract_410' => -> { drive_relay_contract('play', '410') }, + 'dead_peer_half_open' => -> { drive_dead_peer }, + 'black_hole_silent_peer' => -> { drive_black_hole }, + 'reconnect_after_drop' => -> { drive_reconnect }, + 'max_active_calls_cap' => -> { drive_max_active_calls(2) } +}.freeze +def main + out = FIXTURES.transform_values(&:call) REAL_STDOUT.puts(JSON.generate(out)) REAL_STDOUT.flush 0 From 844ef9618dc24a6d5f20574a655fff5ef587a893 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:43:36 -0400 Subject: [PATCH 64/90] =?UTF-8?q?lint(bin):=20finish=20the=20Metrics=20bur?= =?UTF-8?q?n=20=E2=80=94=20bin/=20is=20now=20rubocop-clean?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Five dump programs, extraction only: ai-chat-dump run/47-lines-AbcSize-44.7 -> create_and_chat_steps + lifecycle_steps + summarize_failed_step + error_step + bool_step + short_error_type. Call ORDER is preserved (the differ compares an ordered artifact): merge's receiver chain and each hash literal evaluate left-to-right. envelope-dump the 49-line top-level CORPUS block -> run_case + case_client + arm_case_scenario + drive_case + issue_request + journalled_request_count, driven by CORPUS.to_h. Also split as_hash_body out of decode_body_error_code. http-dump the SAME json-parse-with-raw-fallback was inlined twice (observe_response and reduce_lambda); extracted once as parse_json_or_raw. pagination-dump main's three copy-pasted fresh-client blocks -> a FIXTURES table; the fresh MockTest.client per fixture is now structural instead of a convention main had to remember. secure-default-dump the two inline A1 cases -> named methods. Verified live: BEHAVIORAL-HTTP, ERROR-ENVELOPE, PAGINATION-WIRED, PAGINATION-CORPUS, SECURE-DEFAULT all PASS, plus the AI-CHAT gate (diff_port_ai_chat.py) -- "client speaks the AI Chat protocol per the vendored spec". Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- bin/ai-chat-dump | 108 +++++++++++++++-------------- bin/envelope-dump | 147 +++++++++++++++++++++++----------------- bin/http-dump | 29 +++----- bin/pagination-dump | 18 +++-- bin/secure-default-dump | 25 ++++--- 5 files changed, 172 insertions(+), 155 deletions(-) diff --git a/bin/ai-chat-dump b/bin/ai-chat-dump index 8bf970a1..c1b8abc4 100755 --- a/bin/ai-chat-dump +++ b/bin/ai-chat-dump @@ -66,69 +66,67 @@ def force_error_id(code) "__err_#{code}" end -def run(url) - out = {} - client = SignalWire::AIChatClient.new(url: url) +def short_error_type(err) + err.class.name.split('::').last +end - # ── success steps ────────────────────────────────────────────────── +# create + chat: the two calls that return a decoded payload object. +def create_and_chat_steps(client) info = client.create_conversation('conv-1', config_url: 'http://cfg', timeout: 30, reinit: true) - out['create'] = { - 'wire_method' => 'create_conversation', - 'decoded' => { 'status' => info.status, 'id' => info.id, 'initial_message' => info.initial_message } - } - reply = client.chat('conv-1', 'hello', timeout: 30, reinit: true) - out['chat'] = { - 'wire_method' => 'chat', - 'decoded' => { 'response' => reply.text, 'user_event' => reply.user_event } - } - - # end/delete return bool idiomatically; the wire result also carries the - # conversation id (the caller's own input, echoed). Report both the derived - # status and the id operated on — mirroring the reference dump. - ended = client.end('conv-1') - out['end'] = { - 'wire_method' => 'end_conversation', - 'decoded' => { 'status' => ended ? 'ended' : '?', 'id' => 'conv-1' } + { + 'create' => { 'wire_method' => 'create_conversation', + 'decoded' => { 'status' => info.status, 'id' => info.id, + 'initial_message' => info.initial_message } }, + 'chat' => { 'wire_method' => 'chat', + 'decoded' => { 'response' => reply.text, 'user_event' => reply.user_event } } } +end - deleted = client.delete('conv-1') - out['delete'] = { - 'wire_method' => 'delete', - 'decoded' => { 'status' => deleted ? 'deleted' : '?', 'id' => 'conv-1' } - } +# end/delete return bool idiomatically; the wire result also carries the +# conversation id (the caller's own input, echoed). Report both the derived +# status and the id operated on — mirroring the reference dump. +def bool_step(wire_method, succeeded, done_word) + { 'wire_method' => wire_method, + 'decoded' => { 'status' => succeeded ? done_word : '?', 'id' => 'conv-1' } } +end +def lifecycle_steps(client) + ended = bool_step('end_conversation', client.end('conv-1'), 'ended') + deleted = bool_step('delete', client.delete('conv-1'), 'deleted') chat_log = client.log('conv-1') - out['log'] = { - 'wire_method' => 'chat_log', - 'decoded' => { 'chat_log' => chat_log.messages, 'call_timeline' => chat_log.call_timeline } - } + { 'end' => ended, 'delete' => deleted, + 'log' => { 'wire_method' => 'chat_log', + 'decoded' => { 'chat_log' => chat_log.messages, + 'call_timeline' => chat_log.call_timeline } } } +end + +# The summarize one_of {error} branch must SURFACE, not swallow. +def summarize_failed_step(client) + swallowed = client.summarize(SUMMARIZE_ERROR_ID) + { 'wire_method' => 'summarize', 'raised' => false, 'decoded' => { 'summary' => swallowed } } +rescue SignalWire::AIChat::SummaryError => e + { 'wire_method' => 'summarize', 'raised' => true, + 'error_type' => short_error_type(e), 'message' => e.server_message } +end - summary = client.summarize('conv-1') - out['summarize'] = { 'wire_method' => 'summarize', 'decoded' => { 'summary' => summary } } - - # ── summarize one_of {error} branch: must SURFACE, not swallow ─────── - begin - swallowed = client.summarize(SUMMARIZE_ERROR_ID) - out['summarize_failed'] = { - 'wire_method' => 'summarize', 'raised' => false, 'decoded' => { 'summary' => swallowed } - } - rescue SignalWire::AIChat::SummaryError => e - out['summarize_failed'] = { - 'wire_method' => 'summarize', 'raised' => true, - 'error_type' => e.class.name.split('::').last, 'message' => e.server_message - } - end - - # ── error-code steps (JSON-RPC error object) ───────────────────────── - ERROR_STEPS.each do |step, code| - client.chat(force_error_id(code), 'x') - out[step] = { 'raised' => false } - rescue SignalWire::AIChat::AIChatError => e - out[step] = { 'raised' => true, 'error_code' => e.code, 'error_type' => e.class.name.split('::').last } - end - - out +# Each error step drives a sentinel id the mock answers with a JSON-RPC error +# object, and records whether the port raised with the mandated code. +def error_step(client, code) + client.chat(force_error_id(code), 'x') + { 'raised' => false } +rescue SignalWire::AIChat::AIChatError => e + { 'raised' => true, 'error_code' => e.code, 'error_type' => short_error_type(e) } +end + +def run(url) + client = SignalWire::AIChatClient.new(url: url) + create_and_chat_steps(client) + .merge(lifecycle_steps(client)) + .merge('summarize' => { 'wire_method' => 'summarize', + 'decoded' => { 'summary' => client.summarize('conv-1') } }, + 'summarize_failed' => summarize_failed_step(client)) + .merge(ERROR_STEPS.to_h { |step, code| [step, error_step(client, code)] }) end url = ENV.fetch('MOCK_AI_CHAT_URL', nil) diff --git a/bin/envelope-dump b/bin/envelope-dump index 2d7cfc87..bcdbbb23 100755 --- a/bin/envelope-dump +++ b/bin/envelope-dump @@ -127,17 +127,23 @@ CORPUS = [ # of diff_port_envelope._decode_body_error_code. The Ruby REST client already # json-parses a JSON body (Hash) and leaves a non-JSON body a String, so parse a # String body if it is JSON, then read errors[0].code. -def decode_body_error_code(body) - if body.is_a?(String) - begin - body = JSON.parse(body) - rescue JSON::ParserError, TypeError - return nil - end +def as_hash_body(body) + return body if body.is_a?(Hash) + return nil unless body.is_a?(String) + + begin + parsed = JSON.parse(body) + rescue JSON::ParserError, TypeError + return nil end - return nil unless body.is_a?(Hash) + parsed.is_a?(Hash) ? parsed : nil +end - errs = body['errors'] +def decode_body_error_code(body) + hash = as_hash_body(body) + return nil unless hash + + errs = hash['errors'] return nil unless errs.is_a?(Array) && errs.first.is_a?(Hash) code = errs.first['code'] @@ -191,71 +197,86 @@ base_client = harness[:client] mock = harness[:mock] mock_url = mock.url -out = {} +NO_ERROR_ARTIFACT = { + 'raised' => false, + 'error_kind' => nil, + 'status_code' => nil, + 'body_error_code' => nil, + 'request_count' => 0 +}.freeze -CORPUS.each do |case_spec| - cid = case_spec[:id] +# The client a case drives. A :transport case gets a FRESH client pointed at a +# DEAD port (connection refused): nothing reaches a server, so request_count +# stays 0 and the mock is never armed or journalled. +def case_client(case_spec, harness, base_client, mock, mock_url) + if case_spec[:transport] + return SignalWire::REST::RestClient.new( + project: harness[:project], token: MockTest::REST_TOKEN, + base_url: "http://127.0.0.1:#{dead_port}" + ) + end + + arm_case_scenario(case_spec, mock, mock_url) + base_client +end + +# scenario_repeat arms the SAME override N times (FIFO) so a retry-armed case +# sees the failure on every attempt. +def arm_case_scenario(case_spec, mock, mock_url) scenario = case_spec[:scenario] - transport = case_spec[:transport] || false - request_options = build_request_options(case_spec[:request_options]) - scenario_repeat = case_spec[:scenario_repeat] || 1 - post = case_spec[:method] == 'POST' - call_path = post ? CREATE_PATH : CALL_PATH - endpoint = post ? CREATE_ENDPOINT : ENDPOINT - - artifact = { - 'raised' => false, - 'error_kind' => nil, - 'status_code' => nil, - 'body_error_code' => nil, - 'request_count' => 0 - } + return unless scenario + + endpoint = case_spec[:method] == 'POST' ? CREATE_ENDPOINT : ENDPOINT + (case_spec[:scenario_repeat] || 1).times do + arm_scenario(mock_url, mock.auth_header, endpoint, scenario) + end +end + +def issue_request(client, case_spec, request_options) + if case_spec[:method] == 'POST' + client.http.post(CREATE_PATH, CREATE_BODY, request_options: request_options) + else + client.http.get(CALL_PATH, nil, request_options: request_options) + end +end + +# Drive the case's one request and report how it failed (or that it did not). +def drive_case(client, case_spec, request_options) + issue_request(client, case_spec, request_options) + {} +rescue SignalWire::REST::SignalWireRestError => e + { 'raised' => true, 'error_kind' => 'typed', 'status_code' => e.status_code, + 'body_error_code' => decode_body_error_code(e.body) } +rescue StandardError => e + # A BARE error -> the wrong-type contract violation (records the class name). + { 'raised' => true, 'error_kind' => "bare:#{e.class.name}", + 'status_code' => (e.respond_to?(:status_code) ? e.status_code : nil) } +end +def journalled_request_count(mock_url, call_path) + journal = JSON.parse(Net::HTTP.get(URI("#{mock_url}/__mock__/journal"))) + journal.count { |j| j['path'] == call_path } +end + +def run_case(case_spec, harness, base_client, mock, mock_url) # Fresh journal + scenarios per case so request_count is exact (mirrors the # oracle, which resets both before every case). Safe here: the dump runs as a # single standalone process, so a global reset races nothing. mock_post(mock_url, '/__mock__/journal/reset') mock_post(mock_url, '/__mock__/scenarios/reset') - if transport - # Point a fresh client at a DEAD port: connection refused. Nothing reaches a - # server, so request_count stays 0 and the mock is never armed/journalled. - client = SignalWire::REST::RestClient.new( - project: harness[:project], token: MockTest::REST_TOKEN, - base_url: "http://127.0.0.1:#{dead_port}" - ) - else - client = base_client - if scenario - # scenario_repeat arms the SAME override N times (FIFO) so a retry-armed - # case sees the failure on every attempt. - scenario_repeat.times { arm_scenario(mock_url, mock.auth_header, endpoint, scenario) } - end - end + client = case_client(case_spec, harness, base_client, mock, mock_url) + artifact = NO_ERROR_ARTIFACT.merge( + drive_case(client, case_spec, build_request_options(case_spec[:request_options])) + ) + return artifact if case_spec[:transport] - begin - if post - client.http.post(call_path, CREATE_BODY, request_options: request_options) - else - client.http.get(call_path, nil, request_options: request_options) - end - rescue SignalWire::REST::SignalWireRestError => e - artifact['raised'] = true - artifact['error_kind'] = 'typed' - artifact['status_code'] = e.status_code - artifact['body_error_code'] = decode_body_error_code(e.body) - rescue StandardError => e - # A BARE error -> the wrong-type contract violation (records the class name). - artifact['raised'] = true - artifact['error_kind'] = "bare:#{e.class.name}" - artifact['status_code'] = (e.respond_to?(:status_code) ? e.status_code : nil) - end + call_path = case_spec[:method] == 'POST' ? CREATE_PATH : CALL_PATH + artifact.merge('request_count' => journalled_request_count(mock_url, call_path)) +end - unless transport - journal = JSON.parse(Net::HTTP.get(URI("#{mock_url}/__mock__/journal"))) - artifact['request_count'] = journal.count { |j| j['path'] == call_path } - end - out[cid] = artifact +out = CORPUS.to_h do |case_spec| + [case_spec[:id], run_case(case_spec, harness, base_client, mock, mock_url)] end REAL_STDOUT.puts(JSON.generate(out)) diff --git a/bin/http-dump b/bin/http-dump index 40303348..466181e1 100755 --- a/bin/http-dump +++ b/bin/http-dump @@ -59,21 +59,19 @@ end # observe_response reduces a (status, headers, body) triple to a comparable # artifact — the Ruby mirror of diff_port_http._observe_response. +# Parse a body as JSON, falling back to the raw string when it is not JSON. +def parse_json_or_raw(body_str) + JSON.parse(body_str) +rescue JSON::ParserError + body_str +end + def observe_response(status, headers, body_str, kind) out = { 'status' => status, 'header_keys' => headers.keys.sort } out['location'] = headers['Location'] if headers.key?('Location') out['www_authenticate'] = headers['WWW-Authenticate'] if headers.key?('WWW-Authenticate') if kind == 'response_full' - out['body'] = - if body_str.nil? || body_str.empty? - '' - else - begin - JSON.parse(body_str) - rescue JSON::ParserError - body_str - end - end + out['body'] = body_str.nil? || body_str.empty? ? '' : parse_json_or_raw(body_str) end out end @@ -105,16 +103,7 @@ end # parsed as JSON — mirroring the oracle's serverless_result observer. def reduce_lambda(resp) body = resp['body'] - parsed = - if body.is_a?(String) && !body.empty? - begin - JSON.parse(body) - rescue JSON::ParserError - body - end - else - body - end + parsed = body.is_a?(String) && !body.empty? ? parse_json_or_raw(body) : body { 'status' => resp['statusCode'], 'body' => parsed } end diff --git a/bin/pagination-dump b/bin/pagination-dump index 95870655..57fb831e 100755 --- a/bin/pagination-dump +++ b/bin/pagination-dump @@ -99,16 +99,20 @@ def run_exhaustion(client, mock) { 'terminated' => (ids == %w[x-1 x-2 x-3 x-4 x-5]), 'total_items' => ids.length } end +# fixture-id -> the runner that drives it, in emission order. +FIXTURES = { + 'empty_page_with_next' => method(:run_empty_page_with_next), + 'repeating_cursor_guard' => method(:run_repeating_cursor_guard), + 'exhaustion' => method(:run_exhaustion) +}.freeze + def main - out = {} # A fresh client (fresh auth-scoped scenario view) per fixture so an armed FIFO # sequence never crosses between fixtures. - h = MockTest.client - out['empty_page_with_next'] = run_empty_page_with_next(h[:client], h[:mock]) - h = MockTest.client - out['repeating_cursor_guard'] = run_repeating_cursor_guard(h[:client], h[:mock]) - h = MockTest.client - out['exhaustion'] = run_exhaustion(h[:client], h[:mock]) + out = FIXTURES.to_h do |id, runner| + h = MockTest.client + [id, runner.call(h[:client], h[:mock])] + end REAL_STDOUT.puts(JSON.generate(out)) REAL_STDOUT.flush diff --git a/bin/secure-default-dump b/bin/secure-default-dump index 5e344f59..a0ec22dd 100755 --- a/bin/secure-default-dump +++ b/bin/secure-default-dump @@ -119,23 +119,28 @@ def emit(tool_name) { 'secure_default_true' => recorded_secure, 'rendered' => redact_entry(entry) } end -def main - out = {} - - # A1 (a): a tool defined with NO explicit secure: must default to SECURE → - # its rendered entry carries its own web_hook_url with a __token query param. - out['define_tool_default_is_secure'] = emit('sd_default_secure') do |a| +# A1 (a): a tool defined with NO explicit secure: must default to SECURE → its +# rendered entry carries its own web_hook_url with a __token query param. +def default_secure_case + emit('sd_default_secure') do |a| a.define_tool(name: 'sd_default_secure', description: 'A default-secure tool', parameters: { 'q' => { 'type' => 'string' } }, handler: nil) { |_args, _raw| nil } end +end - # A1 (b): a tool defined with secure: false must be INSECURE → NO per-tool - # web_hook_url key at all (it falls back to SWAIG.defaults.web_hook_url). - out['define_tool_explicit_insecure'] = emit('sd_explicit_insecure') do |a| +# A1 (b): a tool defined with secure: false must be INSECURE → NO per-tool +# web_hook_url key at all (it falls back to SWAIG.defaults.web_hook_url). +def explicit_insecure_case + emit('sd_explicit_insecure') do |a| a.define_tool(name: 'sd_explicit_insecure', description: 'An explicitly-insecure tool', - parameters: { 'q' => { 'type' => 'string' } }, secure: false, handler: nil) { |_args, _raw| nil } + parameters: { 'q' => { 'type' => 'string' } }, secure: false, + handler: nil) { |_args, _raw| nil } end +end +def main + out = { 'define_tool_default_is_secure' => default_secure_case, + 'define_tool_explicit_insecure' => explicit_insecure_case } REAL_STDOUT.puts(JSON.generate(out)) REAL_STDOUT.flush 0 From c15f3b1feb441ad78cfe97be101fd8cad61a2f65 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:57:34 -0400 Subject: [PATCH 65/90] fix(examples): relay_ivr_connect crashed on its first play_and_collect REAL BUG, found by putting relay/examples under the lint for the first time. relay/examples/relay_ivr_connect.rb called call.play_and_collect(media: [...], collect: {...}) but Call#play_and_collect's signature is def play_and_collect(media, collect, volume: nil, control_id: nil, ...) `media` and `collect` are POSITIONAL. Passing them as keywords sends both into **kwargs and leaves the two required positionals unfilled, so the call raises ArgumentError: wrong number of arguments (given 0, expected 2) on the very first thing the example does with an answered call. Anyone following this IVR example hit an immediate crash. Why it survived: relay/examples/ is explicitly excluded from tests/examples_file_mode_smoke_test.rb (those files open a live WebSocket on load, so they are not file-mode targets) AND was excluded from rubocop -- so the directory had NO coverage of any kind. tests/relay/actions_mock_test.rb uses the correct positional form throughout, which confirms the SDK is right and the example was wrong. The fix is one line. The test is the valuable part: a new tests/relay_examples_arity_test.rb statically parses every relay/examples file with Ripper, finds each `.(...)` naming a public Relay::Call method, and asserts the call supplies at least as many POSITIONAL arguments as the method requires. Static parsing is what makes it runnable with no socket, so relay/examples finally has a guard that runs in the normal suite. RED before (against the shipped example): relay_ivr_connect.rb: play_and_collect needs 2 positional arg(s), example supplies 0 GREEN after: 1 runs, 5 assertions, 0 failures. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- tests/relay_examples_arity_test.rb | 117 +++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 tests/relay_examples_arity_test.rb diff --git a/tests/relay_examples_arity_test.rb b/tests/relay_examples_arity_test.rb new file mode 100644 index 00000000..d2015991 --- /dev/null +++ b/tests/relay_examples_arity_test.rb @@ -0,0 +1,117 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'ripper' + +# The RELAY examples under relay/examples/ are excluded from +# tests/examples_file_mode_smoke_test.rb (they open a live WebSocket to the +# platform on load, so they are not file-mode/introspection targets). That left +# them with NO coverage at all, and a real defect survived there unnoticed: +# +# relay/examples/relay_ivr_connect.rb called +# call.play_and_collect(media: [...], collect: {...}) +# but Call#play_and_collect's signature is +# def play_and_collect(media, collect, volume: nil, control_id: nil, ...) +# +# `media:`/`collect:` are NOT the parameter names -- they are POSITIONAL. The +# keywords fall into **kwargs, the two required positionals get nothing, and the +# call raises ArgumentError ("wrong number of arguments (given 0, expected 2)") +# on the very first thing the example does with a call. Anyone following it hit +# an immediate crash. +# +# This test statically checks the arity of every Relay Call method a +# relay/examples file calls: parse the example, find each `.(...)` +# whose method exists on SignalWire::Relay::Call, and assert the call supplies at +# least as many POSITIONAL arguments as the method requires. Static parsing (not +# execution) is what makes this runnable without a live socket. +class RelayExamplesArityTest < Minitest::Test + REPO = File.expand_path('..', __dir__) + + def setup + require 'signalwire' + require 'signalwire/relay/client' + end + + def example_files + Dir[File.join(REPO, 'relay', 'examples', '*.rb')] + end + + # Required positional arity for a public instance method of Call, or nil when + # the name is not one. + def required_positionals(name) + return nil unless SignalWire::Relay::Call.public_method_defined?(name) + + SignalWire::Relay::Call.instance_method(name).parameters + .count { |kind, _| kind == :req } + end + + # Walk the sexp for `command_call` / `method_add_arg` nodes and yield + # [method_name, positional_arg_count] for each call with an explicit receiver. + def each_receiver_call(node, &block) + return unless node.is_a?(Array) + + emit_call(node, &block) + node.each { |child| each_receiver_call(child, &block) if child.is_a?(Array) } + end + + def emit_call(node) + return unless node[0] == :method_add_arg + return unless node[1].is_a?(Array) && node[1][0] == :call + + name = extract_ident(node[1][3]) + return if name.nil? + + yield(name, positional_count(node[2])) + end + + def extract_ident(node) + return nil unless node.is_a?(Array) && %i[@ident @const].include?(node[0]) + + node[1] + end + + # Unwrap arg_paren -> args_add_block -> the argument list, or nil. + def argument_list(arg_paren) + return nil unless arg_paren.is_a?(Array) && arg_paren[0] == :arg_paren + + args = arg_paren[1] + return nil unless args.is_a?(Array) && args[0] == :args_add_block + return nil unless args[1].is_a?(Array) + + args[1] + end + + # Count the POSITIONAL arguments. A bare hash / keyword list + # (bare_assoc_hash) is NOT positional for a method whose params are declared + # positional -- which is exactly the defect this test exists to catch. + def positional_count(arg_paren) + list = argument_list(arg_paren) + return 0 if list.nil? + + list.count { |a| !(a.is_a?(Array) && a[0] == :bare_assoc_hash) } + end + + def underfilled_calls(path) + sexp = Ripper.sexp(File.read(path)) + + refute_nil sexp, "#{File.basename(path)} did not parse" + found = [] + each_receiver_call(sexp) do |name, given| + required = required_positionals(name) + next if required.nil? || given >= required + + found << "#{File.basename(path)}: #{name} needs #{required} positional " \ + "arg(s), example supplies #{given}" + end + found + end + + def test_relay_examples_pass_enough_positional_args_to_call_methods + violations = example_files.flat_map { |path| underfilled_calls(path) } + + assert_empty violations, + 'relay/examples calls a Relay::Call method with too few positional ' \ + "arguments (it would raise ArgumentError at runtime):\n " + + violations.join("\n ") + end +end From 9b4c2e41de5743800ec924c7cb183075f407c9cb Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 05:59:13 -0400 Subject: [PATCH 66/90] lint: burn the last Metrics offenses in examples/ + doc_wire_runner (75 -> 0) The whole repo is now rubocop-clean at the SHIPPED bar (`bundle exec rubocop` exit 0, 0 offenses in 1461 files) with vendor/ as the only directory exclusion. The two dynamic-config agents were the bulk: a 75-line and a 58-line callback block, each a straight-line wall doing six unrelated things to an ephemeral agent copy. Both now read the query string once into a `profile` hash and call named per-concern methods (apply_language / apply_tier_params / apply_industry_prompts / apply_global_data / apply_debug_and_ab), with the if/elsif/case ladders over department, industry and tier folded into frozen lookup tables. Adding a tier is now a table row. Also: swml_service_example's three near-identical example bodies share one `example(banner, name:, route:, port:) { |service| ... }` frame; swmlservice_ai_sidecar's and swmlservice_swaig_standalone's oversized constructors split into build_document / register_* / mount_event_sink; relay_ivr_connect's IVR block became collect_menu_digit + say_and_wait + connect_to_agent + a case over the digit; doc_wire_runner's linear replay split into three per-doc-region methods. One correctness detail worth naming: apply_tier_params dups the frozen TIER_PARAMS row before the test-group-B adjustment, because the original built a fresh hash per request and then mutated it -- without the dup the constant would be mutated across requests. Verified, not assumed. For the two dynamic agents, the callback was driven over a 22-combination query-param matrix covering every branch (tier x industry x language x locale x test_group x debug) and the RENDERED SWML compared HEAD vs working tree: 15602B and 16067B, byte-identical. For the two SWML::Service subclasses, both the rendered document AND the registered SWAIG tool defs are byte-identical (736B / 358B). All probes carry a size floor so an empty artifact fails loudly instead of passing vacuously. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- examples/comprehensive_dynamic_agent.rb | 168 +++++++++++++---------- examples/simple_dynamic_enhanced.rb | 118 ++++++++-------- examples/swml_service_example.rb | 108 ++++++--------- examples/swmlservice_ai_sidecar.rb | 96 +++++++------ examples/swmlservice_swaig_standalone.rb | 31 +++-- relay/examples/relay_ivr_connect.rb | 112 +++++++-------- scripts/doc_wire_runner.rb | 70 ++++++---- 7 files changed, 378 insertions(+), 325 deletions(-) diff --git a/examples/comprehensive_dynamic_agent.rb b/examples/comprehensive_dynamic_agent.rb index 7c060aea..33adc9de 100644 --- a/examples/comprehensive_dynamic_agent.rb +++ b/examples/comprehensive_dynamic_agent.rb @@ -27,99 +27,117 @@ record_call: true ) -agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| - tier = (query_params['tier'] || 'standard').downcase - industry = (query_params['industry'] || 'general').downcase - language = (query_params['language'] || 'en').downcase - locale = (query_params['locale'] || 'us').downcase - test_group = (query_params['test_group'] || 'A').upcase - debug_mode = query_params['debug'] == 'true' - - # --- Voice & language --- - voices = VOICE_OPTIONS.fetch(tier, VOICE_OPTIONS['standard']) - voice = voices.first - - case language - when 'en' - code = locale == 'ca' ? 'en-CA' : 'en-US' - ephemeral.add_language('English', code, voice) - when 'es' - code = locale == 'mx' ? 'es-MX' : 'es-ES' - ephemeral.add_language('Spanish', code, voice) - else - ephemeral.add_language('English', 'en-US', voice) +PREMIUM_TIERS = %w[premium enterprise].freeze + +# The per-request knobs this agent reads off the query string. +def request_profile(query_params) + { + tier: (query_params['tier'] || 'standard').downcase, + industry: (query_params['industry'] || 'general').downcase, + language: (query_params['language'] || 'en').downcase, + locale: (query_params['locale'] || 'us').downcase, + test_group: (query_params['test_group'] || 'A').upcase, + debug: query_params['debug'] == 'true' + } +end + +def apply_language(ephemeral, profile) + voice = VOICE_OPTIONS.fetch(profile[:tier], VOICE_OPTIONS['standard']).first + case profile[:language] + when 'en' then ephemeral.add_language('English', profile[:locale] == 'ca' ? 'en-CA' : 'en-US', voice) + when 'es' then ephemeral.add_language('Spanish', profile[:locale] == 'mx' ? 'es-MX' : 'es-ES', voice) + else ephemeral.add_language('English', 'en-US', voice) end +end + +TIER_PARAMS = { + 'enterprise' => { 'end_of_speech_timeout' => 800, 'attention_timeout' => 25_000 }, + 'premium' => { 'end_of_speech_timeout' => 600, 'attention_timeout' => 20_000 } +}.freeze +DEFAULT_TIER_PARAMS = { 'end_of_speech_timeout' => 400, 'attention_timeout' => 15_000 }.freeze - # --- Tier-based AI params --- - params = case tier - when 'enterprise' - { 'end_of_speech_timeout' => 800, 'attention_timeout' => 25_000 } - when 'premium' - { 'end_of_speech_timeout' => 600, 'attention_timeout' => 20_000 } - else - { 'end_of_speech_timeout' => 400, 'attention_timeout' => 15_000 } - end - - params['end_of_speech_timeout'] = (params['end_of_speech_timeout'] * 1.2).to_i if test_group == 'B' +def apply_tier_params(ephemeral, profile) + params = TIER_PARAMS.fetch(profile[:tier], DEFAULT_TIER_PARAMS).dup + # Test group B gets a 20% longer end-of-speech window. + params['end_of_speech_timeout'] = (params['end_of_speech_timeout'] * 1.2).to_i if profile[:test_group] == 'B' ephemeral.params = params +end + +# industry -> [section title, body, bullets]. Industries without an entry get +# only the generic Role and Purpose section. +INDUSTRY_SECTIONS = { + 'healthcare' => ['Healthcare Guidelines', + 'Follow HIPAA compliance standards. Never provide medical diagnoses.', + ['Protect patient privacy', 'Direct medical questions to providers']], + 'finance' => ['Financial Guidelines', + 'Adhere to financial regulations and maintain strict confidentiality.', + ['Never provide investment advice', 'Protect financial information']], + 'retail' => ['Customer Service', 'Focus on customer satisfaction and sales support.', + ['Maintain friendly demeanor', 'Handle complaints with empathy']] +}.freeze - # --- Industry-specific prompts --- - config = INDUSTRY_CONFIGS.fetch(industry, INDUSTRY_CONFIGS['general']) +ENHANCED_BULLETS = ['Extended memory', 'Priority processing', + 'Specialised knowledge bases'].freeze + +def apply_role_prompt(ephemeral, profile, config) ephemeral.prompt_add_section( 'Role and Purpose', - "You are a professional AI assistant specialised in #{industry} services. " \ + "You are a professional AI assistant specialised in #{profile[:industry]} services. " \ "Maintain #{config['style']} communication standards." ) +end - case industry - when 'healthcare' - ephemeral.prompt_add_section('Healthcare Guidelines', - 'Follow HIPAA compliance standards. Never provide medical diagnoses.', - bullets: ['Protect patient privacy', 'Direct medical questions to providers']) - when 'finance' - ephemeral.prompt_add_section('Financial Guidelines', - 'Adhere to financial regulations and maintain strict confidentiality.', - bullets: ['Never provide investment advice', 'Protect financial information']) - when 'retail' - ephemeral.prompt_add_section('Customer Service', - 'Focus on customer satisfaction and sales support.', - bullets: ['Maintain friendly demeanor', 'Handle complaints with empathy']) - end +def apply_industry_prompts(ephemeral, profile, config) + apply_role_prompt(ephemeral, profile, config) + section = INDUSTRY_SECTIONS[profile[:industry]] + ephemeral.prompt_add_section(section[0], section[1], bullets: section[2]) if section + return unless PREMIUM_TIERS.include?(profile[:tier]) - if %w[premium enterprise].include?(tier) - ephemeral.prompt_add_section('Enhanced Capabilities', - "As a #{tier} service, you have access to advanced features:", - bullets: ['Extended memory', 'Priority processing', 'Specialised knowledge bases']) - end + ephemeral.prompt_add_section('Enhanced Capabilities', + "As a #{profile[:tier]} service, you have access to advanced features:", + bullets: ENHANCED_BULLETS) +end - # --- Global data --- +def apply_global_data(ephemeral, profile, config) features = %w[basic_conversation function_calling] - features += %w[extended_memory priority_processing] if %w[premium enterprise].include?(tier) - features += %w[custom_integration dedicated_support] if tier == 'enterprise' + features += %w[extended_memory priority_processing] if PREMIUM_TIERS.include?(profile[:tier]) + features += %w[custom_integration dedicated_support] if profile[:tier] == 'enterprise' ephemeral.set_global_data( - 'service_tier' => tier, - 'industry_focus' => industry, - 'test_group' => test_group, - 'features_enabled' => features, + 'service_tier' => profile[:tier], 'industry_focus' => profile[:industry], + 'test_group' => profile[:test_group], 'features_enabled' => features, 'compliance_level' => config['compliance'] ) +end - # --- Debug --- - if debug_mode - ephemeral.prompt_add_section('Debug Mode', - 'Debug mode is enabled. Show reasoning and feature availability.', - bullets: ['Include global data references', 'Explain tier-based features']) - ephemeral.add_hints(%w[debug verbose reasoning tier]) - end +DEBUG_BULLETS = ['Include global data references', 'Explain tier-based features'].freeze +AB_BULLETS = ['Ask clarifying questions', 'Offer proactive suggestions'].freeze - # --- A/B testing --- - if test_group == 'B' - ephemeral.add_hints(%w[enhanced personalised proactive]) - ephemeral.prompt_add_section('Enhanced Style', - 'Use an enhanced conversation style:', - bullets: ['Ask clarifying questions', 'Offer proactive suggestions']) - end +def apply_debug_prompt(ephemeral) + ephemeral.prompt_add_section('Debug Mode', + 'Debug mode is enabled. Show reasoning and feature availability.', + bullets: DEBUG_BULLETS) + ephemeral.add_hints(%w[debug verbose reasoning tier]) +end + +def apply_debug_and_ab(ephemeral, profile) + apply_debug_prompt(ephemeral) if profile[:debug] + return unless profile[:test_group] == 'B' + + ephemeral.add_hints(%w[enhanced personalised proactive]) + ephemeral.prompt_add_section('Enhanced Style', 'Use an enhanced conversation style:', + bullets: AB_BULLETS) +end + +agent.set_dynamic_config_callback(nil) do |query_params, _body, _headers, ephemeral| + profile = request_profile(query_params) + config = INDUSTRY_CONFIGS.fetch(profile[:industry], INDUSTRY_CONFIGS['general']) + + apply_language(ephemeral, profile) + apply_tier_params(ephemeral, profile) + apply_industry_prompts(ephemeral, profile, config) + apply_global_data(ephemeral, profile, config) + apply_debug_and_ab(ephemeral, profile) end puts "Starting comprehensive dynamic agent on port #{agent.port}..." diff --git a/examples/simple_dynamic_enhanced.rb b/examples/simple_dynamic_enhanced.rb index 13c8949a..5cf15535 100644 --- a/examples/simple_dynamic_enhanced.rb +++ b/examples/simple_dynamic_enhanced.rb @@ -19,78 +19,86 @@ record_call: true ) -agent.set_dynamic_config_callback(nil) do |query_params, _body_params, _headers, clone| - is_vip = query_params['vip'].to_s.downcase == 'true' - department = (query_params['department'] || 'general').downcase - customer_id = query_params['customer_id'] || '' - language = (query_params['language'] || 'en').downcase +# The per-request knobs this agent reads off the query string. +def request_profile(query_params) + { + vip: query_params['vip'].to_s.downcase == 'true', + department: (query_params['department'] || 'general').downcase, + customer_id: query_params['customer_id'] || '', + language: (query_params['language'] || 'en').downcase + } +end - # Voice and language - voice = is_vip ? 'elevenlabs.nova' : 'elevenlabs.rachel' - if language == 'es' +def apply_voice_and_params(clone, profile) + voice = profile[:vip] ? 'elevenlabs.nova' : 'elevenlabs.rachel' + if profile[:language] == 'es' clone.add_language('Spanish', 'es-ES', voice) else clone.add_language('English', 'en-US', voice) end - - # AI parameters clone.set_params( - 'end_of_speech_timeout' => is_vip ? 300 : 500, - 'attention_timeout' => is_vip ? 20_000 : 15_000 + 'end_of_speech_timeout' => profile[:vip] ? 300 : 500, + 'attention_timeout' => profile[:vip] ? 20_000 : 15_000 ) +end - # Hints - hints = %w[SignalWire SWML API webhook SIP] - hints += case department - when 'sales' then %w[pricing enterprise upgrade] - when 'billing' then %w[invoice payment charges] - else %w[support troubleshoot help] - end - clone.add_hints(hints) +DEPARTMENT_HINTS = { + 'sales' => %w[pricing enterprise upgrade], + 'billing' => %w[invoice payment charges] +}.freeze +DEFAULT_HINTS = %w[support troubleshoot help].freeze - # Global data - global = { 'department' => department, 'service_level' => is_vip ? 'vip' : 'standard' } - global['customer_id'] = customer_id unless customer_id.empty? +def apply_hints_and_data(clone, profile) + clone.add_hints(%w[SignalWire SWML API webhook SIP] + + DEPARTMENT_HINTS.fetch(profile[:department], DEFAULT_HINTS)) + + global = { 'department' => profile[:department], + 'service_level' => profile[:vip] ? 'vip' : 'standard' } + global['customer_id'] = profile[:customer_id] unless profile[:customer_id].empty? clone.global_data = global +end - # Role prompt - role = if customer_id.empty? +def apply_role_prompt(clone, profile) + role = if profile[:customer_id].empty? 'You are a professional customer service representative.' else - "You are a customer service rep helping customer #{customer_id}." + "You are a customer service rep helping customer #{profile[:customer_id]}." end - role += ' This is a VIP customer who receives priority service.' if is_vip + role += ' This is a VIP customer who receives priority service.' if profile[:vip] clone.prompt_add_section('Role and Purpose', role) +end - # Department expertise - case department - when 'sales' - clone.prompt_add_section('Sales Expertise', 'You specialize in sales:', bullets: [ - 'Present product features and benefits', - 'Handle pricing questions', - 'Process orders and upgrades' - ]) - when 'billing' - clone.prompt_add_section('Billing Expertise', 'You specialize in billing:', bullets: [ - 'Explain statements and charges', - 'Process payment arrangements', - 'Handle dispute resolution' - ]) - else - clone.prompt_add_section('Support Guidelines', 'Follow these principles:', bullets: [ - 'Listen carefully to customer needs', - 'Provide accurate information', - 'Escalate complex issues when appropriate' - ]) - end +# department -> [section title, body, bullets]. 'general' is the fallback. +DEPARTMENT_SECTIONS = { + 'sales' => ['Sales Expertise', 'You specialize in sales:', + ['Present product features and benefits', 'Handle pricing questions', + 'Process orders and upgrades']], + 'billing' => ['Billing Expertise', 'You specialize in billing:', + ['Explain statements and charges', 'Process payment arrangements', + 'Handle dispute resolution']] +}.freeze +DEFAULT_SECTION = ['Support Guidelines', 'Follow these principles:', + ['Listen carefully to customer needs', 'Provide accurate information', + 'Escalate complex issues when appropriate']].freeze +VIP_SECTION = ['VIP Standards', 'Premium service:', + ['Provide immediate attention', 'Offer exclusive options', + 'Ensure complete satisfaction']].freeze - if is_vip - clone.prompt_add_section('VIP Standards', 'Premium service:', bullets: [ - 'Provide immediate attention', - 'Offer exclusive options', - 'Ensure complete satisfaction' - ]) - end +def apply_expertise_sections(clone, profile) + title, body, bullets = DEPARTMENT_SECTIONS.fetch(profile[:department], DEFAULT_SECTION) + clone.prompt_add_section(title, body, bullets: bullets) + return unless profile[:vip] + + vip_title, vip_body, vip_bullets = VIP_SECTION + clone.prompt_add_section(vip_title, vip_body, bullets: vip_bullets) +end + +agent.set_dynamic_config_callback(nil) do |query_params, _body_params, _headers, clone| + profile = request_profile(query_params) + apply_voice_and_params(clone, profile) + apply_hints_and_data(clone, profile) + apply_role_prompt(clone, profile) + apply_expertise_sections(clone, profile) end puts 'Starting Enhanced Dynamic Agent' diff --git a/examples/swml_service_example.rb b/examples/swml_service_example.rb index 9e778195..4f5816aa 100755 --- a/examples/swml_service_example.rb +++ b/examples/swml_service_example.rb @@ -23,86 +23,68 @@ # 1. Direct verb manipulation on SWMLService # --------------------------------------------------------------------- -def example_using_service - puts '=== Example using SWMLService directly ===' - - service = SignalWire::SWML::Service.new( - name: 'simple-swml-service', - route: '/simple', - host: '0.0.0.0', - port: 3001 - ) - - # Build the SWML document by calling auto-vivified verb methods. - # Each method appends a verb to the active section of the document. - service.add_verb('answer', {}) - service.add_verb('play', { 'url' => 'say:Hello, world!' }) - service.add_verb('hangup', {}) - +# Every example below has the same shape: print a banner, build a Service, let +# the block append verbs to it, then render the document to stdout and hand the +# service back so the caller could .serve it. +def example(banner, name:, route:, port:) + puts "=== #{banner} ===" + service = SignalWire::SWML::Service.new(name: name, route: route, + host: '0.0.0.0', port: port) + yield service puts JSON.pretty_generate(service.render_document) puts - service end +def example_using_service + example('Example using SWMLService directly', + name: 'simple-swml-service', route: '/simple', port: 3001) do |service| + # Build the SWML document by calling auto-vivified verb methods. + # Each method appends a verb to the active section of the document. + service.add_verb('answer', {}) + service.add_verb('play', { 'url' => 'say:Hello, world!' }) + service.add_verb('hangup', {}) + end +end + # --------------------------------------------------------------------- # 2. Auto-vivified verb method API (Ruby's fluent surface) # --------------------------------------------------------------------- def example_using_builder - puts '=== Example using auto-vivified verb methods ===' - - service = SignalWire::SWML::Service.new( - name: 'fluent-swml-service', - route: '/fluent', - host: '0.0.0.0', - port: 3002 - ) - - # Each verb method appends to the document. The 38 verbs from the - # SWML schema are available as methods on every Service instance. - service.answer - service.play(url: 'say:Welcome to our service!') - service.record(format: 'mp3', stereo: true, beep: true, max_length: 60) - service.play(url: 'say:Thank you for your message. Goodbye!') - service.hangup - - puts JSON.pretty_generate(service.render_document) - puts - - service + example('Example using auto-vivified verb methods', + name: 'fluent-swml-service', route: '/fluent', port: 3002) do |service| + # Each verb method appends to the document. The 38 verbs from the + # SWML schema are available as methods on every Service instance. + service.answer + service.play(url: 'say:Welcome to our service!') + service.record(format: 'mp3', stereo: true, beep: true, max_length: 60) + service.play(url: 'say:Thank you for your message. Goodbye!') + service.hangup + end end # --------------------------------------------------------------------- # 3. AI verb for conversational experiences # --------------------------------------------------------------------- -def example_using_ai - puts '=== Example using AI verb ===' - - service = SignalWire::SWML::Service.new( - name: 'ai-swml-service', - route: '/ai', - host: '0.0.0.0', - port: 3003 - ) - - service.answer - service.ai( - 'prompt' => { - 'text' => 'You are a friendly receptionist. Greet the caller, ask how ' \ - 'you can help, and answer questions about our company.' - }, - 'params' => { 'temperature' => 0.7 }, - 'languages' => [ - { 'name' => 'English', 'code' => 'en-US', 'voice' => 'rachel' } - ] - ) +RECEPTIONIST_AI = { + 'prompt' => { + 'text' => 'You are a friendly receptionist. Greet the caller, ask how ' \ + 'you can help, and answer questions about our company.' + }, + 'params' => { 'temperature' => 0.7 }, + 'languages' => [ + { 'name' => 'English', 'code' => 'en-US', 'voice' => 'rachel' } + ] +}.freeze - puts JSON.pretty_generate(service.render_document) - puts - - service +def example_using_ai + example('Example using AI verb', + name: 'ai-swml-service', route: '/ai', port: 3003) do |service| + service.answer + service.ai(RECEPTIONIST_AI) + end end if __FILE__ == $PROGRAM_NAME diff --git a/examples/swmlservice_ai_sidecar.rb b/examples/swmlservice_ai_sidecar.rb index 4edaaba1..944dd461 100644 --- a/examples/swmlservice_ai_sidecar.rb +++ b/examples/swmlservice_ai_sidecar.rb @@ -24,6 +24,20 @@ # SWML::Service subclass that emits and hosts the tools its # LLM calls. No AgentBase in the inheritance chain. class SalesSidecar < SignalWire::SWML::Service + SIDECAR_PROMPT = 'You are a real-time sales copilot. Listen to the call ' \ + 'and surface competitor pricing comparisons when relevant.' + + COMPETITOR_PARAMS = { + 'competitor' => { + 'type' => 'string', + 'description' => "The competitor's company name, e.g. 'ACME'." + } + }.freeze + + COMPETITOR_TOOL_DESCRIPTION = 'Look up competitor pricing by company name. ' \ + 'The sidecar should call this whenever the ' \ + 'caller mentions a competitor.' + def initialize(public_url: 'https://your-host.example.com/sales-sidecar', host: '0.0.0.0', port: nil) super( @@ -33,57 +47,57 @@ def initialize(public_url: 'https://your-host.example.com/sales-sidecar', port: port ) - # 1. Emit any SWML -- including ai_sidecar. Service#add_verb_to_section - # validates the config against the SWML schema, so a typo'd key or an - # out-of-enum value fails here instead of shipping an invalid document. - # (Document#add_verb_to_section is the raw path and skips that check -- - # do not reach for it.) + build_document(public_url) + register_lookup_competitor + mount_event_sink + end + + private + + # 1. Emit any SWML -- including ai_sidecar. Service#add_verb_to_section + # validates the config against the SWML schema, so a typo'd key or an + # out-of-enum value fails here instead of shipping an invalid document. + # (Document#add_verb_to_section is the raw path and skips that check -- + # do not reach for it.) + def build_document(public_url) answer - add_verb_to_section( - 'main', - 'ai_sidecar', - { - 'prompt' => 'You are a real-time sales copilot. Listen to the ' \ - 'call and surface competitor pricing comparisons ' \ - 'when relevant.', - 'lang' => 'en-US', - 'direction' => %w[remote-caller local-caller], - # Where the sidecar POSTs lifecycle/transcription events. - # Optional -- skip if you don't need an event sink. - 'url' => "#{public_url}/events", - # Where the sidecar's LLM POSTs SWAIG tool calls. This service's - # /swaig route answers them. SWAIG hash key is UPPERCASE per spec. - 'SWAIG' => { - 'defaults' => { 'web_hook_url' => "#{public_url}/swaig" } - } - } - ) + add_verb_to_section('main', 'ai_sidecar', sidecar_config(public_url)) hangup + end - # 2. Register tools the sidecar's LLM can call. Same `define_tool` - # you'd use on AgentBase -- it lives on SWML::Service. + # `url` is where the sidecar POSTs lifecycle/transcription events (optional -- + # skip if you don't need an event sink). `SWAIG.defaults.web_hook_url` is where + # the sidecar's LLM POSTs tool calls; this service's /swaig route answers them. + # The SWAIG hash key is UPPERCASE per spec. + def sidecar_config(public_url) + { + 'prompt' => SIDECAR_PROMPT, + 'lang' => 'en-US', + 'direction' => %w[remote-caller local-caller], + 'url' => "#{public_url}/events", + 'SWAIG' => { 'defaults' => { 'web_hook_url' => "#{public_url}/swaig" } } + } + end + + # 2. Register tools the sidecar's LLM can call. Same `define_tool` + # you'd use on AgentBase -- it lives on SWML::Service. + def register_lookup_competitor define_tool( name: 'lookup_competitor', - description: 'Look up competitor pricing by company name. The sidecar ' \ - 'should call this whenever the caller mentions a competitor.', - parameters: { - 'competitor' => { - 'type' => 'string', - 'description' => "The competitor's company name, e.g. 'ACME'." - } - }, + description: COMPETITOR_TOOL_DESCRIPTION, + parameters: COMPETITOR_PARAMS, secure: false ) do |args, _raw_data| competitor = args['competitor'] || '' - { - 'response' => "Pricing for #{competitor}: $99/seat. " \ - 'Our equivalent plan is $79/seat with the same SLA.' - } + { 'response' => "Pricing for #{competitor}: $99/seat. " \ + 'Our equivalent plan is $79/seat with the same SLA.' } end + end - # 3. (Optional) Mount an event sink for ai_sidecar lifecycle events - # at POST /sales-sidecar/events. Comment this out if you don't - # need it. The sidecar POSTs each event as JSON. + # 3. (Optional) Mount an event sink for ai_sidecar lifecycle events + # at POST /sales-sidecar/events. Comment this out if you don't + # need it. The sidecar POSTs each event as JSON. + def mount_event_sink register_routing_callback(nil, '/events') do |request_data| event_type = request_data && request_data['type'] warn "[sidecar event] type=#{event_type.inspect} body=#{request_data.inspect}" diff --git a/examples/swmlservice_swaig_standalone.rb b/examples/swmlservice_swaig_standalone.rb index 8eef4d56..fbbcbe26 100644 --- a/examples/swmlservice_swaig_standalone.rb +++ b/examples/swmlservice_swaig_standalone.rb @@ -28,6 +28,16 @@ # SWML::Service subclass that registers SWAIG tools and serves them # on /swaig. No AgentBase in the inheritance chain. class StandaloneSwaig < SignalWire::SWML::Service + COMPETITOR_TOOL_DESCRIPTION = 'Look up competitor pricing by company name. Use this ' \ + "when the user asks how a competitor's price compares to ours." + + COMPETITOR_PARAMS = { + 'competitor' => { + 'type' => 'string', + 'description' => "The competitor's company name, e.g. 'ACME'." + } + }.freeze + def initialize(host: '0.0.0.0', port: nil) super( name: 'standalone-swaig', @@ -40,20 +50,19 @@ def initialize(host: '0.0.0.0', port: nil) # HTTP surface is independent of what the document contains. answer hangup + register_lookup_competitor + end + + private - # 2. Register a SWAIG function. `define_tool` lives on SWML::Service, - # not just AgentBase. The handler block receives parsed arguments - # plus the raw POST body. + # 2. Register a SWAIG function. `define_tool` lives on SWML::Service, + # not just AgentBase. The handler block receives parsed arguments + # plus the raw POST body. + def register_lookup_competitor define_tool( name: 'lookup_competitor', - description: 'Look up competitor pricing by company name. Use this ' \ - "when the user asks how a competitor's price compares to ours.", - parameters: { - 'competitor' => { - 'type' => 'string', - 'description' => "The competitor's company name, e.g. 'ACME'." - } - }, + description: COMPETITOR_TOOL_DESCRIPTION, + parameters: COMPETITOR_PARAMS, secure: false # standalone services don't validate session tokens by default ) do |args, _raw_data| competitor = args['competitor'] || '' diff --git a/relay/examples/relay_ivr_connect.rb b/relay/examples/relay_ivr_connect.rb index 2dedde81..40a32685 100644 --- a/relay/examples/relay_ivr_connect.rb +++ b/relay/examples/relay_ivr_connect.rb @@ -24,67 +24,69 @@ def tts(text) { 'type' => 'tts', 'params' => { 'text' => text } } end +MENU_COLLECT = { + 'digits' => { 'max' => 1, 'digit_timeout' => 5.0 }, + 'initial_timeout' => 10.0 +}.freeze + +# Play the menu and collect one digit; returns the digit string ('' on no input). +def collect_menu_digit(call) + media = [tts('Welcome to SignalWire!'), + tts('Press 1 for sales. Press 2 for support. Press 0 to speak with an agent.')] + # media + collect are POSITIONAL on Call#play_and_collect. Passing them as + # `media:` / `collect:` keywords sends them into **kwargs and leaves both + # required positionals unfilled -> ArgumentError. + result = call.play_and_collect(media, MENU_COLLECT).wait.params.fetch('result', {}) + result_type = result.fetch('type', '') + digits = result.dig('params', 'digits') || '' + puts "Collect result: type=#{result_type} digits=#{digits}" + result_type == 'digit' ? digits : '' +end + +def say_and_wait(call, text) + call.play([tts(text)]).wait +end + +# One serial ring group holding a single phone device. `devices` is a list of +# lists: the outer list rings in sequence, each inner list rings in parallel. +def agent_devices(from_number) + [[{ + 'type' => 'phone', + 'params' => { 'to_number' => AGENT_NUMBER, 'from_number' => from_number, + 'timeout' => 30 } + }]] +end + +# Bridge the caller to a live agent and stay on the call until the bridge ends. +def connect_to_agent(call) + say_and_wait(call, 'Connecting you to an agent now. Please hold.') + from_number = call.device.dig('params', 'to_number') || '' + puts "Connecting to #{AGENT_NUMBER} from #{from_number}" + + call.connect(devices: agent_devices(from_number), + ringback: [tts('Please wait while we connect your call.')]) + + call.wait_for_ended + puts "Connected call ended: #{call.call_id}" +end + client.on_call(nil) do |call| puts "Incoming call: #{call.call_id}" call.answer - # Play greeting and collect a single digit - collect_action = call.play_and_collect( - media: [ - tts('Welcome to SignalWire!'), - tts('Press 1 for sales. Press 2 for support. Press 0 to speak with an agent.') - ], - collect: { - 'digits' => { 'max' => 1, 'digit_timeout' => 5.0 }, - 'initial_timeout' => 10.0 - } - ) - - result_event = collect_action.wait - result = result_event.params.fetch('result', {}) - result_type = result.fetch('type', '') - digits = result.dig('params', 'digits') || '' - - puts "Collect result: type=#{result_type} digits=#{digits}" - - if result_type == 'digit' && digits == '1' - # Sales - action = call.play([tts('Thank you for your interest! A sales representative will be with you shortly.')]) - action.wait - - elsif result_type == 'digit' && digits == '2' - # Support - action = call.play([tts('Please hold while we connect you to our support team.')]) - action.wait - - elsif result_type == 'digit' && digits == '0' - # Connect to live agent - action = call.play([tts('Connecting you to an agent now. Please hold.')]) - action.wait - - from_number = call.device.dig('params', 'to_number') || '' - puts "Connecting to #{AGENT_NUMBER} from #{from_number}" - - call.connect( - devices: [[{ - 'type' => 'phone', - 'params' => { - 'to_number' => AGENT_NUMBER, - 'from_number' => from_number, - 'timeout' => 30 - } - }]], - ringback: [tts('Please wait while we connect your call.')] - ) - - # Stay on the call until the bridge ends - call.wait_for_ended - puts "Connected call ended: #{call.call_id}" + case collect_menu_digit(call) + when '1' + say_and_wait(call, 'Thank you for your interest! A sales representative ' \ + 'will be with you shortly.') + when '2' + say_and_wait(call, 'Please hold while we connect you to our support team.') + when '0' + # connect_to_agent blocks until the bridge ends and hangs up with it, so + # this arm must NOT fall through to the call.hangup below. + connect_to_agent(call) next else - # No input or invalid - action = call.play([tts("We didn't receive a valid selection.")]) - action.wait + say_and_wait(call, "We didn't receive a valid selection.") end call.hangup diff --git a/scripts/doc_wire_runner.rb b/scripts/doc_wire_runner.rb index 0eddc5e1..ae9ede7a 100644 --- a/scripts/doc_wire_runner.rb +++ b/scripts/doc_wire_runner.rb @@ -28,42 +28,62 @@ def build_client(base_url) ) end -def main - port = ENV.fetch('MOCK_SIGNALWIRE_PORT', nil) - if port.nil? || port.empty? - warn 'doc_wire_runner: MOCK_SIGNALWIRE_PORT not set' - return 2 - end - base_url = ENV.fetch('SIGNALWIRE_MOCK_URL', "http://127.0.0.1:#{port}") - client = build_client(base_url) +CALL_ID = 'call-doc-wire' - call_id = 'call-doc-wire' +def tts(text) + [{ 'type' => 'tts', 'params' => { 'text' => text } }] +end - # --- README.md + examples/quickstart_rest.rb (region: rest) ---------------- +# README.md + examples/quickstart_rest.rb (region: rest), then rest/README.md + +# rest/docs/namespaces.md phone-number search. +def replay_quickstart(client) client.fabric.ai_agents.create(name: 'Support Bot', prompt: { 'text' => 'You are helpful.' }) - client.calling.play(call_id, play: [{ 'type' => 'tts', 'params' => { 'text' => 'Hello!' } }]) + client.calling.play(CALL_ID, play: tts('Hello!')) client.phone_numbers.search(areacode: '512') client.datasphere.documents.search(query_string: 'billing policy') - - # --- rest/README.md + rest/docs/namespaces.md phone-number search ---------- client.phone_numbers.search(areacode: '512', number_type: 'local') +end + +# rest/docs/calling.md play (nested params:{text}), then +# rest/examples/rest_calling_play_and_record.rb + ivr_and_ai.rb. +def replay_play(client) + client.calling.play(CALL_ID, play: tts('Hello!'), volume: 5.0) + client.calling.play(CALL_ID, play: tts('Welcome to SignalWire.')) + client.calling.play(CALL_ID, play: tts('Enter your PIN followed by pound.')) +end - # --- rest/docs/calling.md play (nested params:{text}) ---------------------- - client.calling.play(call_id, play: [{ 'type' => 'tts', 'params' => { 'text' => 'Hello!' } }], volume: 5.0) +# rest/README.md end + rest/docs/calling.md end/record, then live transcribe & +# translate (action:{start:{}}). +def replay_record_end_and_live(client) + client.calling.record(CALL_ID, audio: { 'format' => 'mp3', 'beep' => true }) + client.calling.end(CALL_ID, reason: 'hangup') + client.calling.live_transcribe(CALL_ID, action: { 'start' => { 'lang' => 'en-US' } }) + client.calling.live_translate(CALL_ID, + action: { 'start' => { 'from_lang' => 'en-US', + 'to_lang' => 'es-ES' } }) +end - # --- rest/examples/rest_calling_play_and_record.rb + ivr_and_ai.rb --------- - client.calling.play(call_id, play: [{ 'type' => 'tts', 'params' => { 'text' => 'Welcome to SignalWire.' } }]) - client.calling.play(call_id, - play: [{ 'type' => 'tts', 'params' => { 'text' => 'Enter your PIN followed by pound.' } }]) +# The mock's base URL, or nil when the gate did not export a port. +def mock_base_url + port = ENV.fetch('MOCK_SIGNALWIRE_PORT', nil) + return nil if port.nil? || port.empty? - # --- rest/README.md end + rest/docs/calling.md end/record ------------------ - client.calling.record(call_id, audio: { 'format' => 'mp3', 'beep' => true }) - client.calling.end(call_id, reason: 'hangup') + ENV.fetch('SIGNALWIRE_MOCK_URL', "http://127.0.0.1:#{port}") +end - # --- rest/docs/calling.md live transcribe & translate (action:{start:{}}) -- - client.calling.live_transcribe(call_id, action: { 'start' => { 'lang' => 'en-US' } }) - client.calling.live_translate(call_id, action: { 'start' => { 'from_lang' => 'en-US', 'to_lang' => 'es-ES' } }) +def replay_all(client) + replay_quickstart(client) + replay_play(client) + replay_record_end_and_live(client) +end +def main + base_url = mock_base_url + if base_url.nil? + warn 'doc_wire_runner: MOCK_SIGNALWIRE_PORT not set' + return 2 + end + replay_all(build_client(base_url)) puts 'doc_wire_runner: replayed documented REST fixtures against the mock' 0 end From 5414292a56afeaf92b1c56045d03ba77ee003cbf Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 06:00:02 -0400 Subject: [PATCH 67/90] lint(tests): extract the self-signed-cert builder instead of disabling two cops tests/core_security_config_test.rb:152 carried a bare # rubocop:disable Metrics/MethodLength, Metrics/AbcSize with NO rationale -- the only unjustified inline suppression in the repo. Rather than write one, the method genuinely decomposed: build_self_signed(key) does the X509 construction, write_self_signed(dir) does the two File.writes. Both cops are back ON for this file. 13 runs, 34 assertions, 0 failures. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- tests/core_security_config_test.rb | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/tests/core_security_config_test.rb b/tests/core_security_config_test.rb index b7703f3a..cbb5090a 100644 --- a/tests/core_security_config_test.rb +++ b/tests/core_security_config_test.rb @@ -149,9 +149,8 @@ def test_ssl_context_kwargs_with_real_cert private - # rubocop:disable Metrics/MethodLength, Metrics/AbcSize - def write_self_signed(dir) - key = OpenSSL::PKey::RSA.new(2048) + # A throwaway self-signed cert for the TLS-config tests, valid for one hour. + def build_self_signed(key) cert = OpenSSL::X509::Certificate.new cert.version = 2 cert.serial = 1 @@ -160,11 +159,16 @@ def write_self_signed(dir) cert.not_before = Time.now cert.not_after = Time.now + 3600 cert.sign(key, OpenSSL::Digest.new('SHA256')) + cert + end + + # Write that cert + its key into +dir+; returns [cert_path, key_path]. + def write_self_signed(dir) + key = OpenSSL::PKey::RSA.new(2048) cert_path = File.join(dir, 'cert.pem') key_path = File.join(dir, 'key.pem') - File.write(cert_path, cert.to_pem) + File.write(cert_path, build_self_signed(key).to_pem) File.write(key_path, key.to_pem) [cert_path, key_path] end - # rubocop:enable Metrics/MethodLength, Metrics/AbcSize end From 067ca5330d8f55a70a7892cf0f90fdd3ae327233 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 06:18:57 -0400 Subject: [PATCH 68/90] fix(scripts): signature_dump silently shortened its default index on a parse failure Second real defect, same class the dotnet/java/go lanes hit: a tool that feeds a gate FAILING SUCCESSFULLY. scripts/signature_dump.rb feeds scripts/enumerate_signatures.py, which writes port_signatures.json -- what the cross-port DRIFT gate compares against the Python oracle. Part of it is a "default index": every `def` under lib/ is parsed with Ripper so literal parameter defaults can be recovered (349 non-null defaults ride on it today). That parse was: def parse_file(path) Ripper.sexp(File.read(path)) rescue StandardError nil end and the caller did `next if sexp.nil?`. A file that would not parse or would not read was skipped with NO diagnostic and NO exit code. The dump still exited 0 and still looked well-formed -- it was just SHORTER. Those defaults came back null, and DRIFT compared the port against a silently-shrunken surface. The in-code comment argued the degradation was honest ("params then stay null, i.e. honestly unrecovered rather than wrong"). It is not: every file under lib/ is valid Ruby by construction -- FMT, LINT and TEST all parse the whole tree -- so a failure here never means "not Ruby". It means truncated, unreadable, or a broken reader. Silence is the one thing that must not happen. parse_file now raises with the path. Ripper.sexp RETURNS NIL on a syntax error rather than raising, so both the nil-return and the exception paths are turned into a loud failure; the read errors are narrowed to SystemCallError/IOError so a genuine bug in the walker is no longer caught here at all. RED before: "StandardError expected but nothing was raised". GREEN after: 2 runs, 6 assertions, 0 failures. Not currently masking anything: port_signatures.json is byte-identical after the change, so no lib/ file is being skipped today. The guard is prophylactic -- it makes the failure impossible to miss rather than fixing a live shortfall. Swept the sibling gate-input producers for the same shape: scripts/route_registry.rb's `rescue StandardError, NotImplementedError` RETURNS the error string into its `errors` list (loud), and scripts/enumerate_surface.rb's `rescue NameError` is a narrow reflection guard. Neither is a swallow-and-continue. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- scripts/signature_dump.rb | 27 +++++++--- tests/signature_dump_fail_loud_test.rb | 71 ++++++++++++++++++++++++++ 2 files changed, 91 insertions(+), 7 deletions(-) create mode 100644 tests/signature_dump_fail_loud_test.rb diff --git a/scripts/signature_dump.rb b/scripts/signature_dump.rb index e4842f3e..e0be0439 100755 --- a/scripts/signature_dump.rb +++ b/scripts/signature_dump.rb @@ -261,10 +261,6 @@ def build_default_index index = {} Dir[File.join(__dir__, '..', 'lib', '**', '*.rb')].each do |path| sexp = parse_file(path) - # A file Ripper cannot parse contributes no defaults; its params then stay - # null, i.e. honestly unrecovered rather than wrong. - next if sexp.nil? - real = File.realpath(path) walk_sexp(sexp) do |node| line, params_node = def_node_parts(node) @@ -277,10 +273,27 @@ def build_default_index index end +# Parse one lib/ file to a Ripper sexp. FAILS LOUD, naming the file. +# +# This used to `rescue StandardError; nil` and let build_default_index `next` on +# the nil. That silence was the whole problem: every file under lib/ is valid +# Ruby by construction (the FMT, LINT and TEST gates all parse the tree), so a +# parse failure here never means "not Ruby" -- it means the file is truncated, +# unreadable, or the reader is broken. Skipping it still produced a dump that +# exited 0 and looked well-formed; it was just SHORTER. The defaults that file +# would have contributed came back null, and the cross-port DRIFT gate then +# compared the port against a silently-shrunken surface. A tool that feeds a +# gate must never fail successfully. +# +# Ripper.sexp returns nil on a syntax error rather than raising, so BOTH the +# nil-return and the exception paths have to be turned into a loud failure. def parse_file(path) - Ripper.sexp(File.read(path)) -rescue StandardError - nil + sexp = Ripper.sexp(File.read(path)) + raise "signature_dump: Ripper could not parse #{path} (syntax error?)" if sexp.nil? + + sexp +rescue SystemCallError, IOError => e + raise "signature_dump: cannot read #{path}: #{e.class}: #{e.message}" end # [def_line, params_node] for a ``def``/``def self.`` node, or [nil, nil]. diff --git a/tests/signature_dump_fail_loud_test.rb b/tests/signature_dump_fail_loud_test.rb new file mode 100644 index 00000000..30456c7a --- /dev/null +++ b/tests/signature_dump_fail_loud_test.rb @@ -0,0 +1,71 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'tmpdir' +require 'ripper' + +# scripts/signature_dump.rb feeds scripts/enumerate_signatures.py, which writes +# port_signatures.json -- the artifact the cross-port DRIFT gate compares against +# the Python oracle. Part of that dump is a "default index": every `def` under +# lib/ is parsed with Ripper so a literal parameter default can be recovered and +# reported (349 non-null defaults ride on it today). +# +# build_default_index used to skip an unparseable file SILENTLY: +# +# sexp = parse_file(path) # rescue StandardError -> nil +# next if sexp.nil? # <- no diagnostic, no exit code +# +# Every file under lib/ is valid Ruby by construction -- the FMT, LINT and TEST +# gates all parse the whole tree -- so a parse failure here never means "this +# file legitimately isn't Ruby". It means the reader is broken, the file is +# truncated, or it is unreadable. And the failure mode is the dangerous one: the +# dump still exits 0 and still looks well-formed, it is just SHORTER. Defaults +# that should have been recovered come back null, and DRIFT compares the port +# against a silently-shrunken surface. It fails SUCCESSFULLY -- the direction +# nobody checks. +# +# parse_file now raises with the offending path. This test proves it: a file +# Ripper cannot parse must produce a loud error NAMING the file, not a nil that +# the caller quietly skips. +class SignatureDumpFailLoudTest < Minitest::Test + REPO = File.expand_path('..', __dir__) + DUMP_SRC = File.read(File.join(REPO, 'scripts', 'signature_dump.rb')) + + # parse_file is a plain top-level method with no SDK dependencies, so it can be + # lifted out of the script and exercised directly -- loading the whole script + # would `require_relative '../lib/signalwire'` and build the real index. + def parse_file_definition + m = DUMP_SRC.match(/^def parse_file\(path\).*?^end$/m) + + refute_nil m, 'scripts/signature_dump.rb no longer defines parse_file(path)' + m[0] + end + + def sandbox + Module.new.tap do |mod| + mod.module_eval(parse_file_definition) + mod.module_eval { module_function :parse_file } + end + end + + def test_parse_file_raises_naming_the_file_it_could_not_parse + Dir.mktmpdir('sigdump-failloud') do |dir| + path = File.join(dir, 'broken.rb') + File.write(path, "def oops( # deliberately unbalanced\n") + + err = assert_raises(StandardError) { sandbox.parse_file(path) } + assert_match(/broken\.rb/, err.message, + 'the failure must NAME the file that would not parse, so a ' \ + 'silently-shortened default index cannot pass as success') + end + end + + def test_parse_file_still_returns_a_sexp_for_valid_ruby + Dir.mktmpdir('sigdump-failloud') do |dir| + path = File.join(dir, 'fine.rb') + File.write(path, "def fine(a = 1)\n a\nend\n") + + assert_kind_of Array, sandbox.parse_file(path) + end + end +end From b195700b0c767bfdaa4d254a1e213b3514774378 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 06:19:20 -0400 Subject: [PATCH 69/90] lint(python): add a ruff config and burn scripts/*.py to zero (58 -> 0) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The repo is a Ruby SDK, but scripts/ holds SEVEN hand-written Python programs: the five code generators, the cross-port surface enumerator, and _gen_format.py -- which is part of the FORMAT TOOLCHAIN ITSELF. No gate linted or format-checked any of it (FMT/LINT run rubocop, which cannot see a .py file), so this load-bearing tooling was held to no standard at all. Fleet-wide gap; ruby's share is these 7 files. ruff.toml MIRRORS the reference's config (signalwire-python/pyproject.toml [tool.ruff]): same target-version py310, same line-length 88, same select list (E4/E7/E9/F/B/S/C4/PERF/SIM/PTH/RET/RUF/UP), same explicit `preview = false` format pin. Deliberately no per-file-ignores. 58 findings -> 0. Beyond the mechanical UP/RUF/PERF/SIM/RET fixes, three had teeth: * F601 x3 -- RUBY_TO_PYTHON_MODULE_MAP in enumerate_signatures.py declared ChatResource, DatasphereDocuments and DatasphereNamespace TWICE. The values happened to match, so nothing was wrong today (proven: port_signatures.json is byte-identical after removing the dupes), but a dict literal with a repeated key is a live trap -- editing one copy silently loses to the other. * F841 x3 -- three dead locals, one of them meaningful: generate_rest.py's §9 update-verb check still carried `item = spec.doc["paths"][anchor]`, the leftover of the FLEET-WIDE §9 TRAP where that check inspected the COLLECTION path for put/patch and therefore never fired. The item_level=True lookup that fixed it was already there; the assignment was its corpse. Commented so it does not come back. * B007 x2 -- two unused loop variables renamed to _spec/_anchor. Three subprocess sites (S603/S607) carry a per-line `# noqa` with a written rationale: each is a fixed list-form arg vector under the default shell=False -- no shell to interpolate into -- and the only non-literal elements are paths the module itself builds. Same disposition and same reasoning the reference applies to its own subprocess calls. These are the ONLY suppressions added. `ruff format` applied (7 files reformatted). Verified, not assumed -- this is tooling that produces gate inputs, so output identity is the bar: * enumerate_signatures.py: port_signatures.json byte-identical (349 non-null defaults still recovered). * All five generators pass `--check` (GEN-FRESH): generate_rest, generate_rest_tests, generate_relay_protocol, generate_swaig_payloads, generate_swml_verbs. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- ruff.toml | 35 ++ scripts/_gen_format.py | 19 +- scripts/enumerate_signatures.py | 426 +++++++++++++----- scripts/generate_relay_protocol.py | 33 +- scripts/generate_rest.py | 696 ++++++++++++++++++++++------- scripts/generate_rest_tests.py | 71 +-- scripts/generate_swaig_payloads.py | 80 +++- scripts/generate_swml_verbs.py | 59 ++- 8 files changed, 1064 insertions(+), 355 deletions(-) create mode 100644 ruff.toml diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 00000000..eb92b2c2 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,35 @@ +# Ruff config for signalwire-ruby's hand-written PYTHON. +# +# The repo is a Ruby SDK, but scripts/ holds 7 hand-written Python programs -- +# the code generators (generate_rest.py, generate_rest_tests.py, +# generate_relay_protocol.py, generate_swaig_payloads.py, +# generate_swml_verbs.py), the cross-port surface enumerator +# (enumerate_signatures.py), and _gen_format.py, which is part of the FORMAT +# TOOLCHAIN ITSELF. Until 2026-07-30 no gate linted or format-checked any of it +# (the FMT/LINT gates run rubocop, which cannot see a .py file), so this +# load-bearing tooling was held to no standard at all. +# +# The rule selection MIRRORS the reference implementation's +# (signalwire-python/pyproject.toml [tool.ruff]) so the fleet is consistent -- +# same target-version, same line-length, same select list, same explicit +# `preview = false` pin. Do not diverge from it without changing python first. +# +# Wired into scripts/run-ci.sh as the PY-LINT and PY-FMT gates (PY-FMT: local +# applies, CI runs --check), mirroring the FMT/LINT contract for Ruby. + +target-version = "py310" +line-length = 88 + +[format] +# Pin STABLE formatting explicitly. Without this, `ruff format --check` can +# resolve preview-mode formatting in CI while a local stable run leaves the file +# unchanged -- a local != CI split with no visible cause. Same pin, same reason, +# as signalwire-python. +preview = false + +[lint] +# E4/E7/E9 + F are the ruff defaults (E501 line-length intentionally excluded -- +# formatting is owned by `ruff format`, not the linter). B = flake8-bugbear +# (likely-bug patterns), S = flake8-bandit (security smells). Identical to the +# reference's select list. +select = ["E4", "E7", "E9", "F", "B", "S", "C4", "PERF", "SIM", "PTH", "RET", "RUF", "UP"] diff --git a/scripts/_gen_format.py b/scripts/_gen_format.py index 2e592565..5d334971 100644 --- a/scripts/_gen_format.py +++ b/scripts/_gen_format.py @@ -20,6 +20,7 @@ Fails LOUD if rubocop is unavailable or errors (so a broken tool can't silently ship unformatted generated code). """ + from __future__ import annotations import os @@ -126,12 +127,20 @@ def rubocop_format(files: dict[str, str]) -> dict[str, str]: # not itself a failure; a missing/broken rubocop is (caught below via the binary # probe + the read-back). cmd = [ - "bundle", "exec", "rubocop", - "-a", "--force-exclusion", "--no-color", - "--config", str(config), + "bundle", + "exec", + "rubocop", + "-a", + "--force-exclusion", + "--no-color", + "--config", + str(config), str(work), ] - proc = subprocess.run(cmd, cwd=str(repo), capture_output=True, text=True) + # S603: fixed list-form arg vector under the default shell=False, so there + # is no shell to interpolate into; the only non-literal elements are paths + # this function itself built (the tempdir mirror and the repo config). + proc = subprocess.run(cmd, cwd=str(repo), capture_output=True, text=True) # noqa: S603 # rubocop returns 0 (clean) or 1 (offenses remain). Any other code, or a # "command not found"/load error, means the tool itself failed — fail loud. if proc.returncode not in (0, 1): @@ -168,7 +177,7 @@ def _fix_enable_directive(src: str) -> str: dis_cops = "" for ln in lines: if ln.startswith(dis_prefix): - dis_cops = ln[len(dis_prefix):].strip() + dis_cops = ln[len(dis_prefix) :].strip() break kept: list[str] = [] for ln in lines: diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index f135982f..8b444609 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -88,10 +88,19 @@ def _resolve_porting_sdk() -> Path: # the diff tool). GENERATED_TYPES_PREFIX = GENERATED_PREFIX + "Types::" GENERATED_TYPES_NS = { - "RelayRest": "relay_rest", "Fabric": "fabric", "Calling": "calling", - "Video": "video", "Datasphere": "datasphere", "Logs": "logs", - "Message": "message", "Voice": "voice", "Fax": "fax", "Project": "project", - "Chat": "chat", "PubSub": "pubsub", "SwmlWebhooks": "swml_webhooks", + "RelayRest": "relay_rest", + "Fabric": "fabric", + "Calling": "calling", + "Video": "video", + "Datasphere": "datasphere", + "Logs": "logs", + "Message": "message", + "Voice": "voice", + "Fax": "fax", + "Project": "project", + "Chat": "chat", + "PubSub": "pubsub", + "SwmlWebhooks": "swml_webhooks", } GENERATED_PAYLOAD_PREFIXES = { "SignalWire::Core::SwmlVerbsGenerated::": "signalwire.core.swml_verbs_generated", @@ -227,37 +236,91 @@ def _build_ref_method_index() -> dict: # would blind the slot). Keyed (py_module, py_class_or_None, method) -> # {ruby_param_name: reference_param_name}. Applied BEFORE the type projection. HAND_PARAM_RENAMES: dict[tuple, dict[str, str]] = { - ("signalwire.core.agent_base", "AgentBase", "register_sip_username"): {"username": "sip_username"}, + ("signalwire.core.agent_base", "AgentBase", "register_sip_username"): { + "username": "sip_username" + }, ("signalwire.core.auth_handler", "AuthHandler", "flask_decorator"): {"app": "f"}, - ("signalwire.core.contexts", "Context", "add_enter_filler"): {"lang_code": "language_code"}, - ("signalwire.core.contexts", "Context", "add_exit_filler"): {"lang_code": "language_code"}, + ("signalwire.core.contexts", "Context", "add_enter_filler"): { + "lang_code": "language_code" + }, + ("signalwire.core.contexts", "Context", "add_exit_filler"): { + "lang_code": "language_code" + }, ("signalwire.core.contexts", "Context", "set_consolidate"): {"val": "consolidate"}, - ("signalwire.core.contexts", "Context", "set_enter_fillers"): {"fillers": "enter_fillers"}, - ("signalwire.core.contexts", "Context", "set_exit_fillers"): {"fillers": "exit_fillers"}, + ("signalwire.core.contexts", "Context", "set_enter_fillers"): { + "fillers": "enter_fillers" + }, + ("signalwire.core.contexts", "Context", "set_exit_fillers"): { + "fillers": "exit_fillers" + }, ("signalwire.core.contexts", "Context", "set_full_reset"): {"val": "full_reset"}, ("signalwire.core.contexts", "Context", "set_isolated"): {"val": "isolated"}, - ("signalwire.core.contexts", "Context", "set_post_prompt"): {"prompt": "post_prompt"}, - ("signalwire.core.contexts", "Context", "set_system_prompt"): {"prompt": "system_prompt"}, - ("signalwire.core.contexts", "Context", "set_user_prompt"): {"prompt": "user_prompt"}, + ("signalwire.core.contexts", "Context", "set_post_prompt"): { + "prompt": "post_prompt" + }, + ("signalwire.core.contexts", "Context", "set_system_prompt"): { + "prompt": "system_prompt" + }, + ("signalwire.core.contexts", "Context", "set_user_prompt"): { + "prompt": "user_prompt" + }, ("signalwire.core.contexts", "Step", "set_end"): {"is_end": "end"}, - ("signalwire.core.contexts", "Step", "set_reset_consolidate"): {"val": "consolidate"}, + ("signalwire.core.contexts", "Step", "set_reset_consolidate"): { + "val": "consolidate" + }, ("signalwire.core.contexts", "Step", "set_reset_full_reset"): {"val": "full_reset"}, - ("signalwire.core.contexts", "Step", "set_reset_system_prompt"): {"prompt": "system_prompt"}, - ("signalwire.core.contexts", "Step", "set_reset_user_prompt"): {"prompt": "user_prompt"}, + ("signalwire.core.contexts", "Step", "set_reset_system_prompt"): { + "prompt": "system_prompt" + }, + ("signalwire.core.contexts", "Step", "set_reset_user_prompt"): { + "prompt": "user_prompt" + }, ("signalwire.core.data_map", "DataMap", "description"): {"desc": "description"}, ("signalwire.core.data_map", "DataMap", "purpose"): {"desc": "description"}, - ("signalwire.core.function_result", "FunctionResult", "set_post_process"): {"val": "post_process"}, - ("signalwire.core.function_result", "FunctionResult", "set_response"): {"text": "response"}, - ("signalwire.core.function_result", "FunctionResult", "toggle_functions"): {"toggles": "function_toggles"}, - ("signalwire.core.mixins.ai_config_mixin", "AIConfigMixin", "add_internal_filler"): {"func_name": "function_name", "lang_code": "language_code"}, - ("signalwire.core.mixins.ai_config_mixin", "AIConfigMixin", "set_internal_fillers"): {"fillers": "internal_fillers"}, - ("signalwire.core.mixins.ai_config_mixin", "AIConfigMixin", "set_native_functions"): {"names": "function_names"}, - ("signalwire.core.mixins.web_mixin", "WebMixin", "manual_set_proxy_url"): {"url": "proxy_url"}, - ("signalwire.core.mixins.web_mixin", "WebMixin", "set_dynamic_config_callback"): {"callable": "callback"}, - ("signalwire.core.security.session_manager", "SessionManager", "activate_session"): {"_call_id": "call_id"}, - ("signalwire.pom.pom", "PromptObjectModel", "add_section"): {"numbered_bullets": "numberedBullets"}, - ("signalwire.pom.pom", "Section", "__init__"): {"numbered_bullets": "numberedBullets"}, - ("signalwire.pom.pom", "Section", "add_subsection"): {"numbered_bullets": "numberedBullets"}, + ("signalwire.core.function_result", "FunctionResult", "set_post_process"): { + "val": "post_process" + }, + ("signalwire.core.function_result", "FunctionResult", "set_response"): { + "text": "response" + }, + ("signalwire.core.function_result", "FunctionResult", "toggle_functions"): { + "toggles": "function_toggles" + }, + ( + "signalwire.core.mixins.ai_config_mixin", + "AIConfigMixin", + "add_internal_filler", + ): {"func_name": "function_name", "lang_code": "language_code"}, + ( + "signalwire.core.mixins.ai_config_mixin", + "AIConfigMixin", + "set_internal_fillers", + ): {"fillers": "internal_fillers"}, + ( + "signalwire.core.mixins.ai_config_mixin", + "AIConfigMixin", + "set_native_functions", + ): {"names": "function_names"}, + ("signalwire.core.mixins.web_mixin", "WebMixin", "manual_set_proxy_url"): { + "url": "proxy_url" + }, + ("signalwire.core.mixins.web_mixin", "WebMixin", "set_dynamic_config_callback"): { + "callable": "callback" + }, + ( + "signalwire.core.security.session_manager", + "SessionManager", + "activate_session", + ): {"_call_id": "call_id"}, + ("signalwire.pom.pom", "PromptObjectModel", "add_section"): { + "numbered_bullets": "numberedBullets" + }, + ("signalwire.pom.pom", "Section", "__init__"): { + "numbered_bullets": "numberedBullets" + }, + ("signalwire.pom.pom", "Section", "add_subsection"): { + "numbered_bullets": "numberedBullets" + }, ("signalwire.relay.call", "Call", "play"): {"loop_count": "loop"}, # DialEvent's ctor kwarg: the reference dataclass field is ``call``, Ruby # spells the same slot ``call_data`` (``call`` collides with nothing but @@ -265,20 +328,39 @@ def _build_ref_method_index() -> dict: # ``params['call']`` (relay_event.rb:508, event.py:308) — so this is a # RENAME, not a missing configurable. ("signalwire.relay.event", "DialEvent", "__init__"): {"call_data": "call"}, - ("signalwire.rest._base", "HttpClient", "__init__"): {"project_id": "project", "space": "host"}, - ("signalwire.rest._base", "SignalWireRestError", "__init__"): {"method_name": "method"}, - ("signalwire.rest._base", "SignalWireRestTransportError", "__init__"): {"method_name": "method"}, - ("signalwire.skills.registry", "SkillRegistry", "register_skill"): {"skill_class_or_name": "skill_class"}, + ("signalwire.rest._base", "HttpClient", "__init__"): { + "project_id": "project", + "space": "host", + }, + ("signalwire.rest._base", "SignalWireRestError", "__init__"): { + "method_name": "method" + }, + ("signalwire.rest._base", "SignalWireRestTransportError", "__init__"): { + "method_name": "method" + }, + ("signalwire.skills.registry", "SkillRegistry", "register_skill"): { + "skill_class_or_name": "skill_class" + }, # SkillManager get/unload take a Ruby ``key`` positional == the reference's # ``skill_identifier`` (method names reconciled via SIG_METHOD_ALIASES above). - ("signalwire.core.skill_manager", "SkillManager", "get_skill"): {"key": "skill_identifier"}, - ("signalwire.core.skill_manager", "SkillManager", "unload_skill"): {"key": "skill_identifier"}, - ("signalwire.core.skill_manager", "SkillManager", "has_skill"): {"key": "skill_identifier"}, + ("signalwire.core.skill_manager", "SkillManager", "get_skill"): { + "key": "skill_identifier" + }, + ("signalwire.core.skill_manager", "SkillManager", "unload_skill"): { + "key": "skill_identifier" + }, + ("signalwire.core.skill_manager", "SkillManager", "has_skill"): { + "key": "skill_identifier" + }, # SWMLService add_* are donated from SWML::Document (SIG_METHOD_DONORS); the # Document param names (``name``/``section``) reconcile to the reference's # ``section_name``. - ("signalwire.core.swml_service", "SWMLService", "add_section"): {"name": "section_name"}, - ("signalwire.core.swml_service", "SWMLService", "add_verb_to_section"): {"section": "section_name"}, + ("signalwire.core.swml_service", "SWMLService", "add_section"): { + "name": "section_name" + }, + ("signalwire.core.swml_service", "SWMLService", "add_verb_to_section"): { + "section": "section_name" + }, } @@ -304,13 +386,17 @@ def _build_ref_method_index() -> dict: # wire key (pom.py:345,361,371 round-trip it unchanged); Ruby spells the # reader snake_case per its own idiom. ("signalwire.pom.pom", "Section"): { - "to_h": "to_dict", "numbered_bullets": "numberedBullets"}, + "to_h": "to_dict", + "numbered_bullets": "numberedBullets", + }, ("signalwire.core.function_result", "FunctionResult"): {"to_h": "to_dict"}, ("signalwire.relay.event", "DialEvent"): {"call_data": "call"}, ("signalwire.relay.call", "Call"): {"pass_call": "pass_", "tap_audio": "tap"}, ("signalwire.relay.message", "Message"): {"on_event": "on"}, ("signalwire.relay.client", "RelayClient"): { - "stop": "disconnect", "project_id": "project"}, + "stop": "disconnect", + "project_id": "project", + }, # Ruby cannot name these readers ``message``: ``Exception#message`` is # stdlib-defined and overriding it changes what raise/rescue and every logger # print. Likewise ``method`` is ``Object#method``, core reflection on every @@ -320,11 +406,17 @@ def _build_ref_method_index() -> dict: ("signalwire.rest._base", "SignalWireRestError"): {"method_name": "method"}, ("signalwire.prefabs.faq_bot", "FAQBotAgent"): {"handle_search": "search_faqs"}, ("signalwire.prefabs.info_gatherer", "InfoGathererAgent"): { - "handle_start": "start_questions", "handle_submit": "submit_answer"}, + "handle_start": "start_questions", + "handle_submit": "submit_answer", + }, ("signalwire.core.skill_base", "SkillBase"): {"instance_key": "get_instance_key"}, ("signalwire.core.skill_manager", "SkillManager"): { - "load": "load_skill", "unload": "unload_skill", "get": "get_skill", - "loaded": "has_skill", "loaded_keys": "list_loaded_skills"}, + "load": "load_skill", + "unload": "unload_skill", + "get": "get_skill", + "loaded": "has_skill", + "loaded_keys": "list_loaded_skills", + }, # Same lookup capability, Ruby spelling: given a skill name, return the # instantiable handle for that skill or nil. Python hands back the CLASS # (`type[SkillBase] | None`, instantiated `skill_class(agent, params)`); @@ -333,8 +425,7 @@ def _build_ref_method_index() -> dict: # same role at the single call site (skill_manager.py:48 / # agent_base.rb:1303). MIRRORS enumerate_surface.rb's # SURFACE_METHOD_ALIASES, which already renames this surface-side. - ("signalwire.skills.registry", "SkillRegistry"): { - "get_factory": "get_skill_class"}, + ("signalwire.skills.registry", "SkillRegistry"): {"get_factory": "get_skill_class"}, } @@ -361,8 +452,11 @@ def apply_sig_method_aliases(out_modules: dict) -> None: # sees the method where the reference declares it. SIG_METHOD_DONORS: dict[tuple, list] = { ("signalwire.core.swml_service", "SWMLService"): [ - ("signalwire.swml.document", "Document", - ["add_section", "add_verb", "add_verb_to_section", "reset"]), + ( + "signalwire.swml.document", + "Document", + ["add_section", "add_verb", "add_verb_to_section", "reset"], + ), ], } @@ -374,9 +468,13 @@ def apply_sig_method_aliases(out_modules: dict) -> None: # module's functions[]. SIG_FREE_FUNCTION_PROJECTIONS: dict[tuple, tuple] = { ("signalwire.core.data_map", "DataMap"): ( - "signalwire.core.data_map", ["create_expression_tool", "create_simple_api_tool"]), + "signalwire.core.data_map", + ["create_expression_tool", "create_simple_api_tool"], + ), ("signalwire.contexts", "Contexts"): ( - "signalwire.core.contexts", ["create_simple_context"]), + "signalwire.core.contexts", + ["create_simple_context"], + ), # The decomposed framework-free webhook-validation core. Ruby ships it as a # ``def self.validate`` singleton method on the WebhookMiddleware class (the # natural home — the Rack #call wrapper delegates to it); the reference @@ -386,13 +484,17 @@ def apply_sig_method_aliases(out_modules: dict) -> None: # (method/url/headers/body/signing_key) are re-attached from the oracle by # project_reference_param_types (runs after this). ("signalwire.core.security.webhook_middleware", "WebhookMiddleware"): ( - "signalwire.core.security.webhook_middleware", ["validate"]), + "signalwire.core.security.webhook_middleware", + ["validate"], + ), # RequestOptions envelope: the reference exposes resolve + status_is_retryable # as MODULE-level functions; Ruby ships them as `def self.` methods on # RequestOptions. Project both to the module functions[] (mirrors # FREE_FUNCTION_PROJECTIONS in enumerate_surface.rb). ("signalwire.rest._request_options", "RequestOptions"): ( - "signalwire.rest._request_options", ["resolve", "status_is_retryable"]), + "signalwire.rest._request_options", + ["resolve", "status_is_retryable"], + ), } @@ -430,7 +532,11 @@ def apply_sig_free_function_projections(out_modules: dict) -> None: sig = smethods.pop(m) # A module free function has no receiver — drop the self param. sig = dict(sig) - sig["params"] = [p for p in sig.get("params", []) if p.get("kind") not in ("self", "cls")] + sig["params"] = [ + p + for p in sig.get("params", []) + if p.get("kind") not in ("self", "cls") + ] target.setdefault(m, sig) @@ -447,8 +553,16 @@ def apply_sig_free_function_projections(out_modules: dict) -> None: # concrete field types by name. Keyed by (module, class) -> ordered field names # (Struct field order = the reference __init__ positional order). AI_CHAT_STRUCT_FIELDS: dict[tuple, list[str]] = { - ("signalwire.ai_chat.client", "ConversationInfo"): ["id", "status", "initial_message"], - ("signalwire.ai_chat.client", "ChatResponse"): ["text", "conversation_id", "user_event"], + ("signalwire.ai_chat.client", "ConversationInfo"): [ + "id", + "status", + "initial_message", + ], + ("signalwire.ai_chat.client", "ChatResponse"): [ + "text", + "conversation_id", + "user_event", + ], ("signalwire.ai_chat.client", "ChatLog"): ["messages", "call_timeline"], } @@ -519,8 +633,7 @@ def synth_positional_struct_inits(out_modules: dict) -> None: # Verify each declared field is present as a reflected zero-arg reader — # a real Struct field drop/rename then re-surfaces as drift here. readers = [ - f for f in fields - if f in methods and not _has_value_params(methods[f]) + f for f in fields if f in methods and not _has_value_params(methods[f]) ] params = [{"name": "self", "kind": "self"}] + [ {"name": f, "type": "any", "required": True} for f in readers @@ -545,8 +658,7 @@ def synth_ai_chat_struct_inits(out_modules: dict) -> None: # Verify each declared field is present as a reflected zero-arg reader — # a real Struct field drop/rename then re-surfaces as drift here. readers = [ - f for f in fields - if f in methods and not _has_value_params(methods[f]) + f for f in fields if f in methods and not _has_value_params(methods[f]) ] # DEFAULT VALUES ARE GENUINELY UNRECOVERABLE HERE, and not for the usual # reflection reason. These models are ``Struct.new(..., keyword_init: @@ -564,7 +676,13 @@ def synth_ai_chat_struct_inits(out_modules: dict) -> None: # divergence is pre-existing and governed as before — it is NOT changed # here, since this pass is additive to ``default`` only. params = [{"name": "self", "kind": "self"}] + [ - {"name": f, "type": "any", "kind": "keyword", "required": False, "default": None} + { + "name": f, + "type": "any", + "kind": "keyword", + "required": False, + "default": None, + } for f in readers ] # The oracle records each dataclass field BOTH as an ``__init__`` param @@ -600,6 +718,7 @@ def _has_value_params(sig: dict) -> bool: def apply_hand_param_renames(out_modules: dict) -> None: """Rewrite Ruby-idiom hand-written param identifiers to the reference name so the projection + diff compare EQUAL (see HAND_PARAM_RENAMES). In place.""" + def apply(key: tuple, sig: dict) -> None: rn = HAND_PARAM_RENAMES.get(key) if not rn: @@ -638,7 +757,11 @@ def apply(key: tuple, sig: dict) -> None: ("signalwire.rest._base", "HttpClient", "delete"): {"request_options"}, ("signalwire.rest.client", "RestClient", "__init__"): {"request_options"}, ("signalwire.rest._request_options", "RequestOptions", "__init__"): { - "timeout", "retries", "retry_on_status", "retry_backoff", "abort_signal", + "timeout", + "retries", + "retry_on_status", + "retry_backoff", + "abort_signal", }, # 6.6 error-observability: the reference's trailing optional ``headers=None`` # ctor param (positional-or-keyword => canonical positional). Ruby spells a @@ -653,7 +776,13 @@ def normalize_request_options_param_kind(out_modules: dict) -> None: Ruby keyword idiom compares EQUAL to the reference's positional-or-keyword params (see REQUEST_OPTIONS_KEYWORD_AS_POSITIONAL). In place.""" for (mod, cls, meth), names in REQUEST_OPTIONS_KEYWORD_AS_POSITIONAL.items(): - sig = out_modules.get(mod, {}).get("classes", {}).get(cls, {}).get("methods", {}).get(meth) + sig = ( + out_modules.get(mod, {}) + .get("classes", {}) + .get(cls, {}) + .get("methods", {}) + .get(meth) + ) if not sig: continue for prm in sig.get("params", []): @@ -667,6 +796,7 @@ def project_reference_param_types(out_modules: dict) -> None: """Re-attach the reference-documented concrete type onto each hand-written port param that reflection recorded as bare ``any`` (see the block comment above). Mutates ``out_modules`` in place.""" + def apply(key: tuple, sig: dict) -> None: ref_types = REF_PARAM_TYPES.get(key) if not ref_types: @@ -687,6 +817,7 @@ def apply(key: tuple, sig: dict) -> None: for fn, sig in me.get("functions", {}).items(): apply((mod, None, fn), sig) + # ADAPTER PARAM-RENAMES (renames, NOT omissions — the wire field is unchanged; # only the Ruby-side kwarg identifier differs from the reference-recorded name). # * The generator lower-cases an uppercase-initial wire field so it is a valid @@ -755,12 +886,10 @@ def apply(key: tuple, sig: dict) -> None: "SignalWire::Agents::BedrockAgent": "signalwire.agents.bedrock", "SignalWire::Core::Agent::Prompt::PromptManager": "signalwire.core.agent.prompt.manager", "SignalWire::Core::Agent::Tools::ToolRegistry": "signalwire.core.agent.tools.registry", - # Prompt Object Model: Ruby's SignalWire::POM::* classes mirror Python's # signalwire.pom.pom.* module exactly (PromptObjectModel + Section). "SignalWire::POM::PromptObjectModel": "signalwire.pom.pom", "SignalWire::POM::Section": "signalwire.pom.pom", - "SignalWire::AgentServer": "signalwire.agent_server", "SignalWire::Security::SessionManager": "signalwire.core.security.session_manager", "SignalWire::Security::WebhookMiddleware": "signalwire.core.security.webhook_middleware", @@ -914,11 +1043,6 @@ def apply(key: tuple, sig: dict) -> None: "SignalWire::REST::Namespaces::VideoConferences": "signalwire.rest.namespaces.video", "SignalWire::REST::Namespaces::VideoConferenceTokens": "signalwire.rest.namespaces.video", "SignalWire::REST::Namespaces::VideoStreams": "signalwire.rest.namespaces.video", - # Chat namespace - "SignalWire::REST::Namespaces::ChatResource": "signalwire.rest.namespaces.chat", - # Datasphere namespace - "SignalWire::REST::Namespaces::DatasphereDocuments": "signalwire.rest.namespaces.datasphere", - "SignalWire::REST::Namespaces::DatasphereNamespace": "signalwire.rest.namespaces.datasphere", } RUBY_TO_PYTHON_CLASS_ALIASES = { @@ -936,22 +1060,41 @@ def apply(key: tuple, sig: dict) -> None: MIXIN_PROJECTIONS = { ("signalwire.core.mixins.ai_config_mixin", "AIConfigMixin"): [ - "add_function_include", "add_hint", "add_hints", "add_internal_filler", - "add_language", "add_mcp_server", "add_pattern_hint", "add_pronunciation", - "enable_debug_events", "enable_mcp_server", + "add_function_include", + "add_hint", + "add_hints", + "add_internal_filler", + "add_language", + "add_mcp_server", + "add_pattern_hint", + "add_pronunciation", + "enable_debug_events", + "enable_mcp_server", "get_language_params", - "set_function_includes", "set_global_data", "set_internal_fillers", + "set_function_includes", + "set_global_data", + "set_internal_fillers", "set_language_params", - "set_languages", "set_multilingual", "set_native_functions", - "set_param", "set_params", - "set_post_prompt_llm_params", "set_prompt_llm_params", - "set_pronunciations", "update_global_data", + "set_languages", + "set_multilingual", + "set_native_functions", + "set_param", + "set_params", + "set_post_prompt_llm_params", + "set_prompt_llm_params", + "set_pronunciations", + "update_global_data", ], ("signalwire.core.mixins.prompt_mixin", "PromptMixin"): [ - "define_contexts", "get_post_prompt", "get_prompt", + "define_contexts", + "get_post_prompt", + "get_prompt", "prompt_add_section", - "prompt_add_subsection", "prompt_add_to_section", - "prompt_has_section", "reset_contexts", "set_post_prompt", + "prompt_add_subsection", + "prompt_add_to_section", + "prompt_has_section", + "reset_contexts", + "set_post_prompt", "set_prompt_text", ], # Python additionally extracted a ``PromptManager`` class that @@ -960,30 +1103,54 @@ def apply(key: tuple, sig: dict) -> None: # AgentBase methods to PromptManager so the cross-language audit # treats both paths as covered. ("signalwire.core.agent.prompt.manager", "PromptManager"): [ - "define_contexts", "get_contexts", "get_post_prompt", "get_prompt", + "define_contexts", + "get_contexts", + "get_post_prompt", + "get_prompt", "get_raw_prompt", - "prompt_add_section", "prompt_add_subsection", "prompt_add_to_section", - "prompt_has_section", "set_post_prompt", "set_prompt_pom", + "prompt_add_section", + "prompt_add_subsection", + "prompt_add_to_section", + "prompt_has_section", + "set_post_prompt", + "set_prompt_pom", "set_prompt_text", ], ("signalwire.core.mixins.skill_mixin", "SkillMixin"): [ - "add_skill", "has_skill", "list_skills", "remove_skill", + "add_skill", + "has_skill", + "list_skills", + "remove_skill", ], ("signalwire.core.mixins.tool_mixin", "ToolMixin"): [ - "define_tool", "on_function_call", "register_swaig_function", + "define_tool", + "on_function_call", + "register_swaig_function", ], ("signalwire.core.agent.tools.registry", "ToolRegistry"): [ - "define_tool", "register_swaig_function", - "has_function", "get_function", "get_all_functions", + "define_tool", + "register_swaig_function", + "has_function", + "get_function", + "get_all_functions", "remove_function", ], ("signalwire.core.mixins.auth_mixin", "AuthMixin"): [ - "validate_basic_auth", "get_basic_auth_credentials", + "validate_basic_auth", + "get_basic_auth_credentials", ], ("signalwire.core.mixins.web_mixin", "WebMixin"): [ - "as_router", "enable_debug_routes", "get_app", "manual_set_proxy_url", - "on_request", "on_swml_request", "register_routing_callback", "run", - "serve", "set_dynamic_config_callback", "setup_graceful_shutdown", + "as_router", + "enable_debug_routes", + "get_app", + "manual_set_proxy_url", + "on_request", + "on_swml_request", + "register_routing_callback", + "run", + "serve", + "set_dynamic_config_callback", + "setup_graceful_shutdown", ], ("signalwire.core.mixins.mcp_server_mixin", "MCPServerMixin"): [ "add_mcp_server", @@ -1103,8 +1270,7 @@ def apply(key: tuple, sig: dict) -> None: def snake_case(name: str) -> str: s = _CAMEL_RE_1.sub(r"\1_\2", name) - s = _CAMEL_RE_2.sub(r"\1_\2", s).lower() - return s + return _CAMEL_RE_2.sub(r"\1_\2", s).lower() def ruby_module_to_py(ns_parts: list[str]) -> str: @@ -1123,7 +1289,7 @@ def resolve_class(full_name: str) -> tuple[str, str] | None: # over name-keyed lookup). Method-less, so they normally don't reach here; the # routing is kept for parity with the surface enumerator. if full_name.startswith(GENERATED_TYPES_PREFIX): - ns_mod = full_name[len(GENERATED_TYPES_PREFIX):].split("::", 1)[0] + ns_mod = full_name[len(GENERATED_TYPES_PREFIX) :].split("::", 1)[0] ns_key = GENERATED_TYPES_NS.get(ns_mod) if ns_key is None: raise SystemExit( @@ -1151,7 +1317,7 @@ def resolve_class(full_name: str) -> tuple[str, str] | None: if full_name in RUBY_TO_PYTHON_MODULE_OVERRIDES: return RUBY_TO_PYTHON_MODULE_OVERRIDES[full_name], canonical_class # Default: derive Python module from Ruby namespace - return ruby_module_to_py(parts[:-1] + [short]), canonical_class + return ruby_module_to_py([*parts[:-1], short]), canonical_class # --------------------------------------------------------------------------- @@ -1206,8 +1372,9 @@ def collect(raw: dict) -> dict: if as_class: mod_path, class_name = as_class else: - mod_path = RUBY_MODULE_LEVEL_OVERRIDES.get(full) or \ - ruby_module_to_py(full.split("::")) + mod_path = RUBY_MODULE_LEVEL_OVERRIDES.get(full) or ruby_module_to_py( + full.split("::") + ) functions: dict = {} class_methods: dict = {} for m in type_entry.get("methods", []): @@ -1216,7 +1383,9 @@ def collect(raw: dict) -> dict: native = m.get("name", "") if native.startswith("__") or native == "": continue - if native.endswith("=") or not re.match(r"^[A-Za-z_][A-Za-z0-9_]*[?!]?$", native): + if native.endswith("=") or not re.match( + r"^[A-Za-z_][A-Za-z0-9_]*[?!]?$", native + ): continue # skip Ruby setters / operator methods # Underscore-prefixed Ruby methods are private convention; # skip them from the public surface. @@ -1244,10 +1413,10 @@ def collect(raw: dict) -> dict: if class_methods: out_modules.setdefault(mod_path, {}) out_modules[mod_path].setdefault("classes", {}) - out_modules[mod_path]["classes"].setdefault( - class_name, {"methods": {}} + out_modules[mod_path]["classes"].setdefault(class_name, {"methods": {}}) + out_modules[mod_path]["classes"][class_name]["methods"].update( + class_methods ) - out_modules[mod_path]["classes"][class_name]["methods"].update(class_methods) continue resolved = resolve_class(full) @@ -1274,7 +1443,9 @@ def collect(raw: dict) -> dict: # @property machinery and Python lists the property name # only once. Operator methods (``[]``, ``==``, ``+``, # etc.) likewise aren't part of the canonical surface. - if native.endswith("=") or not re.match(r"^[A-Za-z_][A-Za-z0-9_]*[?!]?$", native): + if native.endswith("=") or not re.match( + r"^[A-Za-z_][A-Za-z0-9_]*[?!]?$", native + ): continue # Strip Ruby ?/! suffixes for the canonical name; Python # signature inventory doesn't mark predicates / bangs. @@ -1284,7 +1455,8 @@ def collect(raw: dict) -> dict: if method_canonical in methods_out: continue sig = build_signature( - m, instance_method=not m.get("is_static") and native != "", + m, + instance_method=not m.get("is_static") and native != "", ) # Filter out parameters with empty names (anonymous block / rest) sig["params"] = [p for p in sig["params"] if p.get("name")] @@ -1301,7 +1473,8 @@ def collect(raw: dict) -> dict: # same param SET the source method exposes — not an omission. sidecar = ( REST_SIGNATURES.get(f"{canonical_class}::{clean}") - if native != "" else None + if native != "" + else None ) if sidecar is not None: self_p = [p for p in sig["params"] if p.get("kind") == "self"] @@ -1330,8 +1503,16 @@ def collect(raw: dict) -> dict: # so every method shows on AgentBase. Project canonical-Python mixin # methods onto their owning mixin module. Methods may also live on # SWMLService (parent class) — combine both for projection lookup. - ab_entry = out_modules.get("signalwire.core.agent_base", {}).get("classes", {}).get("AgentBase") - svc_entry = out_modules.get("signalwire.core.swml_service", {}).get("classes", {}).get("SWMLService") + ab_entry = ( + out_modules.get("signalwire.core.agent_base", {}) + .get("classes", {}) + .get("AgentBase") + ) + svc_entry = ( + out_modules.get("signalwire.core.swml_service", {}) + .get("classes", {}) + .get("SWMLService") + ) if ab_entry or svc_entry: ab_methods = ab_entry["methods"] if ab_entry else {} svc_methods = svc_entry["methods"] if svc_entry else {} @@ -1557,8 +1738,12 @@ def resolved(key: str, seen: frozenset = frozenset()) -> dict: AND the reference flattens the same inheritance (see the docstring).""" params = dict(own.get(key, {})) parent = superclasses.get(key) - if (key in splats and parent and parent not in seen - and _oracle_flattens(key, parent)): + if ( + key in splats + and parent + and parent not in seen + and _oracle_flattens(key, parent) + ): inherited = resolved(parent, seen | {key}) for name, spec in inherited.items(): params.setdefault(name, spec) @@ -1611,10 +1796,7 @@ def build_signature(method: dict, instance_method: bool) -> dict: param["required"] = True params_out.append(param) name = method.get("name") - if name == "": - returns = "void" - else: - returns = RETURN_TYPE_OVERRIDES.get(name, "any") + returns = "void" if name == "" else RETURN_TYPE_OVERRIDES.get(name, "any") return { "params": params_out, "returns": returns, @@ -1622,9 +1804,16 @@ def build_signature(method: dict, instance_method: bool) -> dict: def run_dump() -> dict: - cp = subprocess.run( - ["bundle", "exec", "ruby", str(HERE / "signature_dump.rb")], - cwd=PORT_ROOT, capture_output=True, text=True, timeout=300, + # S603/S607: fixed list-form arg vector under the default shell=False (no + # shell to interpolate into); the only non-literal element is this script's + # own sibling signature_dump.rb. S607's partial `bundle` path is the normal + # idiom for invoking the project's bundler off PATH. + cp = subprocess.run( # noqa: S603 + ["bundle", "exec", "ruby", str(HERE / "signature_dump.rb")], # noqa: S607 + cwd=PORT_ROOT, + capture_output=True, + text=True, + timeout=300, ) if cp.returncode != 0: raise RuntimeError(f"signature_dump.rb failed:\n{cp.stderr}\n{cp.stdout}") @@ -1644,11 +1833,18 @@ def main() -> int: canonical = collect(raw) - args.out.write_text(json.dumps(canonical, indent=2, sort_keys=False) + "\n", encoding="utf-8") + args.out.write_text( + json.dumps(canonical, indent=2, sort_keys=False) + "\n", encoding="utf-8" + ) n_mods = len(canonical["modules"]) - n_methods = sum(sum(len(c["methods"]) for c in m.get("classes", {}).values()) for m in canonical["modules"].values()) + n_methods = sum( + sum(len(c["methods"]) for c in m.get("classes", {}).values()) + for m in canonical["modules"].values() + ) n_funcs = sum(len(m.get("functions", {})) for m in canonical["modules"].values()) - print(f"enumerate_signatures: wrote {args.out} ({n_mods} modules, {n_methods} methods, {n_funcs} functions)") + print( + f"enumerate_signatures: wrote {args.out} ({n_mods} modules, {n_methods} methods, {n_funcs} functions)" + ) return 0 diff --git a/scripts/generate_relay_protocol.py b/scripts/generate_relay_protocol.py index 3549b6f2..115428ea 100644 --- a/scripts/generate_relay_protocol.py +++ b/scripts/generate_relay_protocol.py @@ -38,6 +38,7 @@ python3 scripts/generate_relay_protocol.py --check # GEN-FRESH: fail if stale python3 scripts/generate_relay_protocol.py --out DIR # scratch: emit into DIR """ + from __future__ import annotations import argparse @@ -48,12 +49,14 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _gen_format import rubocop_format, wrap_spec_derived_disables # noqa: E402 +from _gen_format import rubocop_format, wrap_spec_derived_disables def _load_rest_generator(): here = Path(__file__).resolve().parent - spec = importlib.util.spec_from_file_location("generate_rest", here / "generate_rest.py") + spec = importlib.util.spec_from_file_location( + "generate_rest", here / "generate_rest.py" + ) if spec is None or spec.loader is None: # pragma: no cover raise SystemExit("generate_relay_protocol.py: cannot load generate_rest.py") mod = importlib.util.module_from_spec(spec) @@ -103,8 +106,11 @@ def build_outputs(psdk: Path) -> dict: emitted_names.add(rb_name) fn = "/".join(RELAY_SUBDIR) + f"/{GR.snake(rb_name)}.rb" outs[fn] = GR.emit_methodless_class( - RELAY_MODULE, rb_name, node.get("properties") or {}, - f"RELAY method {method!r}, {phase}", emit_readers=False, + RELAY_MODULE, + rb_name, + node.get("properties") or {}, + f"RELAY method {method!r}, {phase}", + emit_readers=False, ) return outs @@ -112,7 +118,9 @@ def build_outputs(psdk: Path) -> dict: def main(argv: list) -> int: ap = argparse.ArgumentParser(description=__doc__) - ap.add_argument("--check", action="store_true", help="GEN-FRESH: exit non-zero if stale") + ap.add_argument( + "--check", action="store_true", help="GEN-FRESH: exit non-zero if stale" + ) ap.add_argument("--out", default="", help="scratch: emit into this dir") args = ap.parse_args(argv) @@ -125,7 +133,10 @@ def main(argv: list) -> int: # Format-on-emit (see _gen_format): wrap the spec-derived disable pair, then run the # repo rubocop safe-autocorrect so the committed tree is GEN-FRESH + FMT/LINT clean. rel_base = out_dir.relative_to(repo_root()).as_posix() - wrapped = {f"{rel_base}/{fn}": wrap_spec_derived_disables(src) for fn, src in outs.items()} + wrapped = { + f"{rel_base}/{fn}": wrap_spec_derived_disables(src) + for fn, src in outs.items() + } formatted = rubocop_format(wrapped) outs = {fn: formatted[f"{rel_base}/{fn}"] for fn in outs} @@ -143,11 +154,15 @@ def main(argv: list) -> int: if rel not in expected: stale.append(f"{p} (leftover — not in generator output)") if stale: - sys.stderr.write("GEN-FRESH FAIL: %d generated RELAY-protocol file(s) stale:\n" % len(stale)) + sys.stderr.write( + f"GEN-FRESH FAIL: {len(stale)} generated RELAY-protocol file(s) stale:\n" + ) for s in stale: - sys.stderr.write(" - %s\n" % s) + sys.stderr.write(f" - {s}\n") return 1 - print("GEN-FRESH: generated RELAY-protocol files match porting-sdk/relay-protocol/.") + print( + "GEN-FRESH: generated RELAY-protocol files match porting-sdk/relay-protocol/." + ) return 0 for fn, src in outs.items(): diff --git a/scripts/generate_rest.py b/scripts/generate_rest.py index d0a261b0..9bdeafbb 100644 --- a/scripts/generate_rest.py +++ b/scripts/generate_rest.py @@ -50,6 +50,7 @@ python3 scripts/generate_rest.py --check # GEN-FRESH: fail if stale python3 scripts/generate_rest.py --out DIR # scratch: emit flat into DIR """ + from __future__ import annotations import argparse @@ -60,7 +61,7 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _gen_format import rubocop_format, wrap_spec_derived_disables # noqa: E402 +from _gen_format import rubocop_format, wrap_spec_derived_disables try: import yaml @@ -81,28 +82,33 @@ # - hidden: DROP the field from the SDK surface entirely (still on the wire). # - deprecated: EMIT the field but flag it deprecated (a `# deprecated:` comment). # _overlay_cache holds {"hidden": set, "deprecated": set} of (field, scope-or-None). -_overlay_cache: "dict[str, set[tuple[str, str | None]]] | None" = None +_overlay_cache: dict[str, set[tuple[str, str | None]]] | None = None -def _load_overlay(psdk: Path) -> "dict[str, set[tuple[str, str | None]]]": +def _load_overlay(psdk: Path) -> dict[str, set[tuple[str, str | None]]]: global _overlay_cache if _overlay_cache is None: - def rules(key: str, data: dict) -> "set[tuple[str, str | None]]": + + def rules(key: str, data: dict) -> set[tuple[str, str | None]]: out: set[tuple[str, str | None]] = set() for entry in data.get(key) or []: if isinstance(entry, dict) and entry.get("field"): out.add((entry["field"], entry.get("scope"))) return out + path = psdk / "rest-apis" / "x-sdk-overlay.yaml" data = yaml.safe_load(path.read_text()) if path.is_file() else {} data = data or {} - _overlay_cache = {"hidden": rules("hidden", data), - "deprecated": rules("deprecated", data)} + _overlay_cache = { + "hidden": rules("hidden", data), + "deprecated": rules("deprecated", data), + } return _overlay_cache -def _overlay_match(rules: "set[tuple[str, str | None]]", field: str, - schema_name: "str | None") -> bool: +def _overlay_match( + rules: set[tuple[str, str | None]], field: str, schema_name: str | None +) -> bool: # A rule matches when its field equals `field` AND (it is unscoped OR its scope # equals the containing SPEC schema name — the $defs / components.schemas key, # NOT the emitted Ruby class name). @@ -112,11 +118,11 @@ def _overlay_match(rules: "set[tuple[str, str | None]]", field: str, return False -def overlay_hidden(field: str, schema_name: "str | None", psdk: Path) -> bool: +def overlay_hidden(field: str, schema_name: str | None, psdk: Path) -> bool: return _overlay_match(_load_overlay(psdk)["hidden"], field, schema_name) -def overlay_deprecated(field: str, schema_name: "str | None", psdk: Path) -> bool: +def overlay_deprecated(field: str, schema_name: str | None, psdk: Path) -> bool: return _overlay_match(_load_overlay(psdk)["deprecated"], field, schema_name) @@ -147,9 +153,21 @@ def overlay_deprecated(field: str, schema_name: "str | None", psdk: Path) -> boo # never silently dropped. registry has no own dir (its resources live inside # relay-rest via namespace: registry). _NS_ORDER = [ - "relay-rest", "fabric", "calling", "video", "datasphere", - "logs", "message", "messages", "voice", "fax", "project", "projects", - "chat", "pubsub", "swml-webhooks", + "relay-rest", + "fabric", + "calling", + "video", + "datasphere", + "logs", + "message", + "messages", + "voice", + "fax", + "project", + "projects", + "chat", + "pubsub", + "swml-webhooks", ] # Module-segment casing overrides — where mechanical PascalCase of the dir name @@ -200,7 +218,7 @@ def _scan_namespaces(psdk: Path) -> tuple[list[str], list[tuple[str, str, str]]] isinstance(item, dict) and item.get("x-sdk-resource") for item in (doc.get("paths") or {}).values() ) - has_schemas = bool(((doc.get("components") or {}).get("schemas"))) + has_schemas = bool((doc.get("components") or {}).get("schemas")) has_servers = bool(doc.get("servers")) if has_resource: resource_dirs.append(name) @@ -217,11 +235,47 @@ def _scan_namespaces(psdk: Path) -> tuple[list[str], list[tuple[str, str, str]]] # names collide only via the calling command-dispatch (handled by the command # name derivation, e.g. `calling.end` -> `end`, which IS a keyword — see below). RUBY_KEYWORDS = { - "BEGIN", "END", "alias", "and", "begin", "break", "case", "class", "def", - "defined?", "do", "else", "elsif", "end", "ensure", "false", "for", "if", - "in", "module", "next", "nil", "not", "or", "redo", "rescue", "retry", - "return", "self", "super", "then", "true", "undef", "unless", "until", - "when", "while", "yield", "__FILE__", "__LINE__", "__ENCODING__", + "BEGIN", + "END", + "alias", + "and", + "begin", + "break", + "case", + "class", + "def", + "defined?", + "do", + "else", + "elsif", + "end", + "ensure", + "false", + "for", + "if", + "in", + "module", + "next", + "nil", + "not", + "or", + "redo", + "rescue", + "retry", + "return", + "self", + "super", + "then", + "true", + "undef", + "unless", + "until", + "when", + "while", + "yield", + "__FILE__", + "__LINE__", + "__ENCODING__", } @@ -229,6 +283,7 @@ def _scan_namespaces(psdk: Path) -> tuple[list[str], list[tuple[str, str, str]]] # Resolution. # --------------------------------------------------------------------------- + def resolve_porting_sdk() -> Path: env = os.environ.get("PORTING_SDK") if env and (Path(env) / "rest-apis").is_dir(): @@ -238,7 +293,9 @@ def resolve_porting_sdk() -> Path: cand = parent.parent / "porting-sdk" if (cand / "rest-apis").is_dir(): return cand.resolve() - raise SystemExit("generate_rest.py: porting-sdk not found (set $PORTING_SDK or clone adjacent)") + raise SystemExit( + "generate_rest.py: porting-sdk not found (set $PORTING_SDK or clone adjacent)" + ) def repo_root() -> Path: @@ -249,12 +306,13 @@ def repo_root() -> Path: # Base loading (x-sdk-bases; §2) — validate cyclic/undefined extends (fail loud). # --------------------------------------------------------------------------- + def load_bases(psdk: Path) -> dict[str, list[str]]: raw = yaml.safe_load((psdk / "rest-apis" / "x-sdk-bases.yaml").read_text()) bases = dict(raw.get("x-sdk-bases") or {}) fab = psdk / "rest-apis" / "fabric" / "x-sdk-bases.yaml" if fab.is_file(): - bases.update((yaml.safe_load(fab.read_text()).get("x-sdk-bases") or {})) + bases.update(yaml.safe_load(fab.read_text()).get("x-sdk-bases") or {}) def resolve(name: str, seen: set[str]) -> list[str]: if name in seen: @@ -276,24 +334,35 @@ def resolve(name: str, seen: set[str]) -> list[str]: # Spec model. # --------------------------------------------------------------------------- + class Spec: def __init__(self, name: str, doc: dict): self.name = name self.doc = doc self.server_path = _url_path(doc["servers"][0]["url"]) if self.server_path != "/" and self.server_path.endswith("/"): - raise SystemExit(f"{name}: servers[0].url path {self.server_path!r} has a trailing slash") + raise SystemExit( + f"{name}: servers[0].url path {self.server_path!r} has a trailing slash" + ) self.namespace_attr = (doc.get("x-sdk-namespace") or {}).get("attr") or "" self.ops: dict[str, tuple[str, str, bool]] = {} - self.op_body: dict[str, dict] = {} # operationId -> requestBody JSON schema (or {}) + self.op_body: dict[ + str, dict + ] = {} # operationId -> requestBody JSON schema (or {}) for path, item in (doc.get("paths") or {}).items(): for verb in ("get", "post", "put", "patch", "delete"): o = item.get(verb) if o and o.get("operationId"): - self.ops[o["operationId"]] = (verb, path, bool(o.get("requestBody"))) + self.ops[o["operationId"]] = ( + verb, + path, + bool(o.get("requestBody")), + ) body = o.get("requestBody") or {} content = body.get("content") or {} - media = content.get("application/json") or (next(iter(content.values())) if content else {}) + media = content.get("application/json") or ( + next(iter(content.values())) if content else {} + ) self.op_body[o["operationId"]] = (media or {}).get("schema") or {} self.schemas = ((doc.get("components") or {}).get("schemas")) or {} @@ -314,13 +383,16 @@ def _url_path(url: str) -> str: def load_spec(psdk: Path, ns: str) -> Spec: - return Spec(ns, yaml.safe_load((psdk / "rest-apis" / ns / "openapi.yaml").read_text())) + return Spec( + ns, yaml.safe_load((psdk / "rest-apis" / ns / "openapi.yaml").read_text()) + ) # --------------------------------------------------------------------------- # Path composition (§4). # --------------------------------------------------------------------------- + def join_path(a: str, b: str) -> str: if not b: return a @@ -346,7 +418,7 @@ def relative_tail(spec: Spec, anchor: str, markup: dict, op_path: str): full = join_path(spec.server_path, coll) absp = join_path(spec.server_path, op_path) if coll and absp.startswith(full + "/"): - return ([s for s in absp[len(full) + 1:].split("/") if s], False) + return ([s for s in absp[len(full) + 1 :].split("/") if s], False) if coll and absp == full: return ([], False) return ([s for s in absp.lstrip("/").split("/") if s], True) @@ -356,6 +428,7 @@ def relative_tail(spec: Spec, anchor: str, markup: dict, op_path: str): # Naming. # --------------------------------------------------------------------------- + def escape_param(field: str) -> str: """A wire field name → a safe Ruby keyword-arg identifier. Ruby keyword-arg names are snake_case (already the wire convention); the aliased identifier is @@ -377,12 +450,20 @@ def escape_param(field: str) -> str: PARAM_ARG_NAME = { - "id": "id", "queue_id": "queue_id", "NumberGroupId": "group_id", - "documentId": "document_id", "chunkId": "chunk_id", - "mfa_request_id": "request_id", "e164_number": "e164", - "fabric_subscriber_id": "subscriber_id", "ai_agent_id": "id", - "cxml_webhook_id": "id", "swml_webhook_id": "id", "token_id": "token_id", - "room_id": "room_id", "resource_id": "resource_id", + "id": "id", + "queue_id": "queue_id", + "NumberGroupId": "group_id", + "documentId": "document_id", + "chunkId": "chunk_id", + "mfa_request_id": "request_id", + "e164_number": "e164", + "fabric_subscriber_id": "subscriber_id", + "ai_agent_id": "id", + "cxml_webhook_id": "id", + "swml_webhook_id": "id", + "token_id": "token_id", + "room_id": "room_id", + "resource_id": "resource_id", "sip_endpoint_id": "sip_endpoint_id", } @@ -442,22 +523,27 @@ def rb_str(s: str) -> str: # Command-dispatch (§6). # --------------------------------------------------------------------------- + def command_method_name(cmd: str) -> str: """Command string -> ruby snake_case method name (strip a leading `calling.` domain prefix, dots -> underscores). `calling.play.pause` -> `play_pause`, `dial` -> `dial`, `calling.end` -> `end` (a keyword, but a valid METHOD name in ruby — only PARAM/local-var identifiers need escaping).""" - s = cmd[len("calling."):] if cmd.startswith("calling.") else cmd + s = cmd[len("calling.") :] if cmd.startswith("calling.") else cmd return s.replace(".", "_") def discriminator_mapping(spec: Spec, schema_name: str) -> dict: sch = spec.schemas.get(schema_name) if sch is None: - raise SystemExit(f"command-dispatch request {schema_name!r} not in components.schemas") + raise SystemExit( + f"command-dispatch request {schema_name!r} not in components.schemas" + ) mapping = (sch.get("discriminator") or {}).get("mapping") if not mapping: - raise SystemExit(f"command-dispatch request {schema_name!r} has no discriminator.mapping") + raise SystemExit( + f"command-dispatch request {schema_name!r} has no discriminator.mapping" + ) return mapping @@ -465,6 +551,7 @@ def discriminator_mapping(spec: Spec, schema_name: str) -> dict: # Typed inputs (§5). # --------------------------------------------------------------------------- + def resolve_schema(spec: Spec, schema: dict | None, seen=None) -> dict: if not schema: return {} @@ -480,7 +567,12 @@ def resolve_schema(spec: Spec, schema: dict | None, seen=None) -> dict: seen.add(leaf) return resolve_schema(spec, spec.schemas.get(leaf), seen) allof = schema.get("allOf") - if allof and len(allof) == 1 and not schema.get("properties") and not schema.get("type"): + if ( + allof + and len(allof) == 1 + and not schema.get("properties") + and not schema.get("type") + ): return resolve_schema(spec, allof[0], seen) return schema @@ -501,7 +593,9 @@ def object_body_fields(spec: Spec, body_schema: dict) -> list[tuple[str, dict, b return [(name, psc, name in required) for name, psc in props.items()] -def command_param_fields(spec: Spec, command_schema: dict) -> tuple[list[tuple[str, dict, bool]], bool]: +def command_param_fields( + spec: Spec, command_schema: dict +) -> tuple[list[tuple[str, dict, bool]], bool]: """§6 union-flatten: ([(wire_name, schema, required)], has_id). The command schema's `params` sub-schema may itself be anyOf/oneOf of variant param schemas; expose the UNION of variants' fields, a field required only if @@ -542,7 +636,7 @@ def is_object_body(spec: Spec, body_schema: dict) -> bool: return False if resolved.get("properties") or resolved.get("allOf"): return True - return (resolved.get("type") == "object") + return resolved.get("type") == "object" def ordered_fields(fields): @@ -575,7 +669,12 @@ def ordered_fields(fields): # gate correctly fails for a param the oracle types concretely; L14). # --------------------------------------------------------------------------- -_SCALAR_CANON = {"string": "string", "integer": "int", "number": "float", "boolean": "bool"} +_SCALAR_CANON = { + "string": "string", + "integer": "int", + "number": "float", + "boolean": "bool", +} def _is_named_ref(schema: dict) -> bool: @@ -587,7 +686,12 @@ def _is_named_ref(schema: dict) -> bool: if schema.get("$ref"): return True allof = schema.get("allOf") - if allof and len(allof) == 1 and not schema.get("properties") and not schema.get("type"): + if ( + allof + and len(allof) == 1 + and not schema.get("properties") + and not schema.get("type") + ): return _is_named_ref(allof[0]) return False @@ -640,8 +744,13 @@ def _register_sidecar(cls: str, ruby_method: str, records: list[dict]) -> None: def _request_options_record() -> dict: - return {"name": "request_options", "kind": "keyword", - "type": REQUEST_OPTIONS_TYPE, "required": False, "default": None} + return { + "name": "request_options", + "kind": "keyword", + "type": REQUEST_OPTIONS_TYPE, + "required": False, + "default": None, + } def schema_fields(spec: Spec, schema: dict, seen=None) -> set[str]: @@ -669,6 +778,7 @@ def schema_fields(spec: Spec, schema: dict, seen=None) -> set[str]: # Body-param emission (Ruby kwargs + extras + **kwargs — §B). # --------------------------------------------------------------------------- + def kwarg_params_and_body(spec, fields, indent=" ", body_var="body"): """Build (kwarg_param_list, body_build_lines, sidecar_records, body_var) for a set of object-body / command-params fields, in the Ruby kwargs idiom + the two doors @@ -703,23 +813,35 @@ def kwarg_params_and_body(spec, fields, indent=" ", body_var="body"): for wire_name, schema, required in ordered_fields(fields): ident = escape_param(wire_name) ct = canonical_type(spec, schema, required) - rec: dict = {"name": wire_name, "kind": "keyword", "type": ct, "required": required} + rec: dict = { + "name": wire_name, + "kind": "keyword", + "type": ct, + "required": required, + } if required: params.append(f"{ident}:") build.append(f"{indent}{body_var}[{rb_str(wire_name)}] = {ident}") else: params.append(f"{ident}: nil") rec["default"] = None - build.append(f"{indent}{body_var}[{rb_str(wire_name)}] = {ident} unless {ident}.nil?") + build.append( + f"{indent}{body_var}[{rb_str(wire_name)}] = {ident} unless {ident}.nil?" + ) records.append(rec) params.append("extras: {}") params.append(REQUEST_OPTIONS_SIG) params.append("**kwargs") build.append(f"{indent}{body_var} = {body_var}.merge(extras).merge(kwargs)") - records.append({ - "name": "extras", "kind": "keyword", - "type": "optional>", "required": False, "default": None, - }) + records.append( + { + "name": "extras", + "kind": "keyword", + "type": "optional>", + "required": False, + "default": None, + } + ) # §PY-7: the trailing sidecar slot is the keyword-only ``request_options`` (the # reference records it at the var_keyword position; the ``**kwargs`` forward- # compat splat stays in the physical signature but is not surfaced in the @@ -786,8 +908,15 @@ def abs_ruby_path(full: str, id_args: list[str]) -> str: """ -def emit_method(spec: Spec, anchor: str, markup: dict, base: str, - method_snake: str, op_id: str, indent: str) -> list[str]: +def emit_method( + spec: Spec, + anchor: str, + markup: dict, + base: str, + method_snake: str, + op_id: str, + indent: str, +) -> list[str]: if op_id not in spec.ops: raise SystemExit(f"{markup['name']}.{method_snake}: op {op_id!r} not in spec") verb, op_path, has_body = spec.ops[op_id] @@ -800,7 +929,10 @@ def emit_method(spec: Spec, anchor: str, markup: dict, base: str, cls = markup["name"] # Leading path-id params: the reference types every path/collection id # positional as ``string`` (a URL path segment). Record them so. - id_records = [{"name": a, "kind": "positional", "type": "string", "required": True} for a in id_args] + id_records = [ + {"name": a, "kind": "positional", "type": "string", "required": True} + for a in id_args + ] ro_rec = _request_options_record() if write_verb and has_body: @@ -809,11 +941,15 @@ def emit_method(spec: Spec, anchor: str, markup: dict, base: str, fields = object_body_fields(spec, body_schema) # kwarg_params_and_body already emits ``request_options: nil`` into the # signature (kw) and the request_options record into ``records``. - kw, build, records, bvar = kwarg_params_and_body(spec, fields, indent=indent + " ") + kw, build, records, bvar = kwarg_params_and_body( + spec, fields, indent=indent + " " + ) sig = ", ".join(id_args + kw) lines.append(f"{indent}def {name}({sig})") lines.extend(build) - lines.append(f"{indent} @http.{verb_fn}({path_expr}, {bvar}, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.{verb_fn}({path_expr}, {bvar}, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") _register_sidecar(cls, name, id_records + records) else: @@ -825,41 +961,59 @@ def emit_method(spec: Spec, anchor: str, markup: dict, base: str, # ``gen:`` — ``canonical_type`` returns the folding # ``dict`` for it; a bare inline union stays ``any``. body_type = canonical_type(spec, body_schema, True) - sig = ", ".join(id_args + ["body", REQUEST_OPTIONS_SIG]) + sig = ", ".join([*id_args, "body", REQUEST_OPTIONS_SIG]) lines.append(f"{indent}def {name}({sig})") - lines.append(f"{indent} @http.{verb_fn}({path_expr}, body, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.{verb_fn}({path_expr}, body, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") - _register_sidecar(cls, name, id_records + [ - {"name": "body", "kind": "positional", "type": body_type, "required": True}, - ro_rec, - ]) + _register_sidecar( + cls, + name, + [ + *id_records, + { + "name": "body", + "kind": "positional", + "type": body_type, + "required": True, + }, + ro_rec, + ], + ) elif write_verb: - sig = ", ".join(id_args + [REQUEST_OPTIONS_SIG]) + sig = ", ".join([*id_args, REQUEST_OPTIONS_SIG]) lines.append(f"{indent}def {name}({sig})") - lines.append(f"{indent} @http.{verb_fn}({path_expr}, {{}}, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.{verb_fn}({path_expr}, {{}}, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") - _register_sidecar(cls, name, id_records + [ro_rec]) + _register_sidecar(cls, name, [*id_records, ro_rec]) elif verb == "get": # §5.3 GET query door — a trailing keyword-splat `**params` map, plus the # keyword-only ``request_options:`` (extracted before the splat). The # reference enumerator records ONLY the path-ids + ``request_options`` for # a GET (the ``**params`` var_keyword is not surfaced), so the sidecar # mirrors that shape (drop ``params``, record ``request_options``). - sig = ", ".join(id_args + [REQUEST_OPTIONS_SIG, "**params"]) + sig = ", ".join([*id_args, REQUEST_OPTIONS_SIG, "**params"]) lines.append(f"{indent}def {name}({sig})") - lines.append(f"{indent} @http.get({path_expr}, params.empty? ? nil : params, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.get({path_expr}, params.empty? ? nil : params, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") - _register_sidecar(cls, name, id_records + [ro_rec]) + _register_sidecar(cls, name, [*id_records, ro_rec]) else: # delete - sig = ", ".join(id_args + [REQUEST_OPTIONS_SIG]) + sig = ", ".join([*id_args, REQUEST_OPTIONS_SIG]) lines.append(f"{indent}def {name}({sig})") lines.append(f"{indent} @http.delete({path_expr}, {REQUEST_OPTIONS_FWD})") lines.append(f"{indent}end") - _register_sidecar(cls, name, id_records + [ro_rec]) + _register_sidecar(cls, name, [*id_records, ro_rec]) return lines -def emit_crud_create_update(spec: Spec, anchor: str, markup: dict, base: str, indent: str) -> list[str]: +def emit_crud_create_update( + spec: Spec, anchor: str, markup: dict, base: str, indent: str +) -> list[str]: """Emit the OWN methods the oracle records for a full-CRUD resource, matching the Python enumerator's rule (`_emit_generic_inherited`): it walks the DIRECT generic base the resource subscripts and records that base's OWN members onto @@ -877,11 +1031,12 @@ def emit_crud_create_update(spec: Spec, anchor: str, markup: dict, base: str, in own-set into the subclass body (delete for CrudResource, not for FabricResource) to reproduce the oracle.""" lines: list[str] = [] - coll = collection_segment(anchor, markup) # create: the collection-level POST (create_* operation). create_op = _find_op(spec, anchor, markup, verbs=("post",), item_level=False) update_verb = "put" if markup.get("update_method") == "PUT" else "patch" - update_op = _find_op(spec, anchor, markup, verbs=(update_verb, "put", "patch"), item_level=True) + update_op = _find_op( + spec, anchor, markup, verbs=(update_verb, "put", "patch"), item_level=True + ) # NOTE: the plain-CRUD create/update/delete are NOT sidecar-registered. The # reference publishes them structurally (a CrudResource base), so the drift @@ -892,33 +1047,51 @@ def emit_crud_create_update(spec: Spec, anchor: str, markup: dict, base: str, in # typed-input unfold. if create_op: _, _, cbody = create_op - fields = object_body_fields(spec, cbody) if is_object_body(spec, cbody) else None + fields = ( + object_body_fields(spec, cbody) if is_object_body(spec, cbody) else None + ) if fields is not None: - kw, build, _records, bvar = kwarg_params_and_body(spec, fields, indent=indent + " ") + kw, build, _records, bvar = kwarg_params_and_body( + spec, fields, indent=indent + " " + ) lines.append(f"{indent}def create({', '.join(kw)})") lines.extend(build) - lines.append(f"{indent} @http.post(@base_path, {bvar}, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.post(@base_path, {bvar}, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") else: lines.append(f"{indent}def create(body, {REQUEST_OPTIONS_SIG})") - lines.append(f"{indent} @http.post(@base_path, body, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.post(@base_path, body, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") if update_op: uverb, _, ubody = update_op - fields = object_body_fields(spec, ubody) if is_object_body(spec, ubody) else None + fields = ( + object_body_fields(spec, ubody) if is_object_body(spec, ubody) else None + ) verb_fn = uverb if fields is not None: - kw, build, _records, bvar = kwarg_params_and_body(spec, fields, indent=indent + " ") + kw, build, _records, bvar = kwarg_params_and_body( + spec, fields, indent=indent + " " + ) lines.append("") lines.append(f"{indent}def update(resource_id, {', '.join(kw)})") lines.extend(build) - lines.append(f"{indent} @http.{verb_fn}(_path(resource_id), {bvar}, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.{verb_fn}(_path(resource_id), {bvar}, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") else: lines.append("") - lines.append(f"{indent}def update(resource_id, body, {REQUEST_OPTIONS_SIG})") - lines.append(f"{indent} @http.{verb_fn}(_path(resource_id), body, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent}def update(resource_id, body, {REQUEST_OPTIONS_SIG})" + ) + lines.append( + f"{indent} @http.{verb_fn}(_path(resource_id), body, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") # delete: a CrudResource OWN member → recorded on a plain CrudResource @@ -927,7 +1100,9 @@ def emit_crud_create_update(spec: Spec, anchor: str, markup: dict, base: str, in if base == "CrudResource": lines.append("") lines.append(f"{indent}def delete(resource_id, {REQUEST_OPTIONS_SIG})") - lines.append(f"{indent} @http.delete(_path(resource_id), {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.delete(_path(resource_id), {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") return lines @@ -941,7 +1116,11 @@ def _find_op(spec: Spec, anchor: str, markup: dict, verbs, item_level: bool): full = join_path(spec.server_path, coll) this = join_path(spec.server_path, path) if item_level: - if not (path.startswith(coll + "/{") and path.count("/{") == 1 and path.endswith("}")): + if not ( + path.startswith(coll + "/{") + and path.count("/{") == 1 + and path.endswith("}") + ): continue else: # collection-level: the anchor collection path exactly @@ -952,7 +1131,9 @@ def _find_op(spec: Spec, anchor: str, markup: dict, verbs, item_level: bool): if o and o.get("operationId"): body = o.get("requestBody") or {} content = body.get("content") or {} - media = content.get("application/json") or (next(iter(content.values())) if content else {}) + media = content.get("application/json") or ( + next(iter(content.values())) if content else {} + ) return (verb, path, (media or {}).get("schema") or {}) return None @@ -965,7 +1146,9 @@ def emit_read_list_get(spec: Spec, anchor: str, markup: dict, indent: str) -> li L4: only DECLARED GET methods carry a query tail, not the base list/get).""" lines: list[str] = [] lines.append(f"{indent}def list({REQUEST_OPTIONS_SIG}, **params)") - lines.append(f"{indent} @http.get(@base_path, params.empty? ? nil : params, {REQUEST_OPTIONS_FWD})") + lines.append( + f"{indent} @http.get(@base_path, params.empty? ? nil : params, {REQUEST_OPTIONS_FWD})" + ) lines.append(f"{indent}end") lines.append("") # paginate: the ReadResource base's page-walking iterator (oracle records @@ -985,9 +1168,15 @@ def emit_read_list_get(spec: Spec, anchor: str, markup: dict, indent: str) -> li return lines -def emit_set_method(spec: Spec, markup: dict, sm_name: str, sm: dict, - update_schema_fields: set[str], - update_field_schemas: dict[str, dict], indent: str) -> list[str]: +def emit_set_method( + spec: Spec, + markup: dict, + sm_name: str, + sm: dict, + update_schema_fields: set[str], + update_field_schemas: dict[str, dict], + indent: str, +) -> list[str]: handler = sm.get("handler") if not handler: raise SystemExit(f"{markup['name']}.{sm_name}: set_method missing handler") @@ -1002,12 +1191,19 @@ def emit_set_method(spec: Spec, markup: dict, sm_name: str, sm: dict, # takes keyword args + an ``extra: {}`` / ``**kwargs`` pair; the sidecar unfold # projects the reference's positional/var_keyword kinds — wire-identical. records: list[dict] = [ - {"name": "resource_id", "kind": "positional", "type": "string", "required": True}, + { + "name": "resource_id", + "kind": "positional", + "type": "string", + "required": True, + }, ] for arg_name, arg in args.items(): field = arg.get("field") if not field: - raise SystemExit(f"{markup['name']}.{sm_name}: arg {arg_name!r} missing field") + raise SystemExit( + f"{markup['name']}.{sm_name}: arg {arg_name!r} missing field" + ) if field not in update_schema_fields: raise SystemExit( f"{markup['name']}.{sm_name}: arg field {field!r} not in update request schema" @@ -1015,7 +1211,12 @@ def emit_set_method(spec: Spec, markup: dict, sm_name: str, sm: dict, ident = escape_param(arg_name) required = bool(arg.get("required")) ct = canonical_type(spec, update_field_schemas.get(field, {}), required) - rec: dict = {"name": arg_name, "kind": "positional", "type": ct, "required": required} + rec: dict = { + "name": arg_name, + "kind": "positional", + "type": ct, + "required": required, + } if required: params.append(f"{ident}:") required_lines.append(f"{indent} body[{rb_str(field)}] = {ident}") @@ -1039,26 +1240,46 @@ def emit_set_method(spec: Spec, markup: dict, sm_name: str, sm: dict, lines.extend(required_lines) for ident, field in optional_lines: lines.append(f"{indent} body[{rb_str(field)}] = {ident} unless {ident}.nil?") - lines.append(f"{indent} update(resource_id, {REQUEST_OPTIONS_FWD}, **body.transform_keys(&:to_sym), **extra, **kwargs)") + lines.append( + f"{indent} update(resource_id, {REQUEST_OPTIONS_FWD}, **body.transform_keys(&:to_sym), **extra, **kwargs)" + ) lines.append(f"{indent}end") return lines def update_request_fields(spec: Spec, anchor: str, markup: dict) -> set[str]: - op = _find_op(spec, anchor, markup, - verbs=("put" if markup.get("update_method") == "PUT" else "patch", "put", "patch"), - item_level=True) + op = _find_op( + spec, + anchor, + markup, + verbs=( + "put" if markup.get("update_method") == "PUT" else "patch", + "put", + "patch", + ), + item_level=True, + ) if not op: return set() return schema_fields(spec, op[2]) -def update_request_field_schemas(spec: Spec, anchor: str, markup: dict) -> dict[str, dict]: +def update_request_field_schemas( + spec: Spec, anchor: str, markup: dict +) -> dict[str, dict]: """{ wire_field -> field_schema } for the update request body — used to type a set_method's args from their bound update field (§7 sidecar typing).""" - op = _find_op(spec, anchor, markup, - verbs=("put" if markup.get("update_method") == "PUT" else "patch", "put", "patch"), - item_level=True) + op = _find_op( + spec, + anchor, + markup, + verbs=( + "put" if markup.get("update_method") == "PUT" else "patch", + "put", + "patch", + ), + item_level=True, + ) if not op: return {} return {name: sch for name, sch, _req in object_body_fields(spec, op[2])} @@ -1083,7 +1304,7 @@ def emit_command_dispatch(spec: Spec, anchor: str, markup: dict) -> str: lines.append(" module Namespaces") lines.append(" module Generated") lines.append(f" # {name} — command-dispatch resource ({spec.name} spec).") - lines.append(f" #") + lines.append(" #") lines.append(f" # Each method POSTs {{command, params, id?}} to {base}.") lines.append(f" class {name} < SignalWire::REST::BaseResource") lines.append(" def initialize(http)") @@ -1095,16 +1316,30 @@ def emit_command_dispatch(spec: Spec, anchor: str, markup: dict) -> str: cmd_leaf = cmd_ref.rsplit("/", 1)[-1] if cmd_ref else "" cmd_schema = spec.schemas.get(cmd_leaf, {}) fields, with_id = command_param_fields(spec, cmd_schema) - kw, build, records, bvar = kwarg_params_and_body(spec, fields, indent=" ", body_var="params") + kw, build, records, bvar = kwarg_params_and_body( + spec, fields, indent=" ", body_var="params" + ) id_params = ["call_id"] if with_id else [] sig = ", ".join(id_params + kw) - id_records = ([{"name": "call_id", "kind": "positional", "type": "string", - "required": True}] if with_id else []) + id_records = ( + [ + { + "name": "call_id", + "kind": "positional", + "type": "string", + "required": True, + } + ] + if with_id + else [] + ) _register_sidecar(name, mname, id_records + records) lines.append("") lines.append(f" def {mname}({sig})") lines.extend(build) - lines.append(f" body = {{ 'command' => {rb_str(cmd)}, 'params' => {bvar} }}") + lines.append( + f" body = {{ 'command' => {rb_str(cmd)}, 'params' => {bvar} }}" + ) if with_id: lines.append(" body['id'] = call_id if call_id") lines.append(f" @http.post(@base_path, body, {REQUEST_OPTIONS_FWD})") @@ -1114,7 +1349,14 @@ def emit_command_dispatch(spec: Spec, anchor: str, markup: dict) -> str: lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc=f"Generated command-dispatch resource for the {spec.name!r} namespace.") + "\n" + "\n".join(lines) + "\n" + return ( + GEN_HEADER.format( + desc=f"Generated command-dispatch resource for the {spec.name!r} namespace." + ) + + "\n" + + "\n".join(lines) + + "\n" + ) # The generated Fabric base classes (they only select the update verb). Emitted @@ -1161,18 +1403,27 @@ def emit_resource(spec: Spec, anchor: str, markup: dict) -> str: upd = markup.get("update_method") if not upd: raise SystemExit(f"{name}: {base} requires update_method") - item = spec.doc["paths"][anchor] # anchor is the collection path; the update op is item-level. Validate # the declared verb against the actual item-level update op. + # (A dead `item = spec.doc["paths"][anchor]` sat here: the leftover of + # the fleet-wide §9 trap where this check inspected the COLLECTION path + # for put/patch and therefore never fired. The item_level=True lookup + # below is the fix; the assignment was unused.) up = _find_op(spec, anchor, markup, verbs=("put", "patch"), item_level=True) if up: spec_verb = up[0].upper() if upd != spec_verb: - raise SystemExit(f"{name}: update_method {upd} != spec update verb {spec_verb}") + raise SystemExit( + f"{name}: update_method {upd} != spec update verb {spec_verb}" + ) # Resolve the Ruby parent class. if base == "FabricResource": - parent = "FabricResourcePUT" if markup.get("update_method") == "PUT" else "FabricResource" + parent = ( + "FabricResourcePUT" + if markup.get("update_method") == "PUT" + else "FabricResource" + ) else: parent = RUBY_PARENT[base] @@ -1184,7 +1435,9 @@ def emit_resource(spec: Spec, anchor: str, markup: dict) -> str: lines.append(" module REST") lines.append(" module Namespaces") lines.append(" module Generated") - lines.append(f" # {name} — REST resource for the {spec.name} API (base {base}).") + lines.append( + f" # {name} — REST resource for the {spec.name} API (base {base})." + ) lines.append(f" class {name} < {parent}") # Constructor bakes the base path (§4). lines.append(" def initialize(http)") @@ -1226,7 +1479,9 @@ def emit_resource(spec: Spec, anchor: str, markup: dict) -> str: else: continue lines.append("") - lines.extend(emit_method(spec, anchor, markup, base, method_snake, op_id, indent)) + lines.extend( + emit_method(spec, anchor, markup, base, method_snake, op_id, indent) + ) # set_methods (§7): require a CRUD base. set_methods = markup.get("set_methods") or {} @@ -1237,14 +1492,25 @@ def emit_resource(spec: Spec, anchor: str, markup: dict) -> str: upd_schemas = update_request_field_schemas(spec, anchor, markup) for sm_name, sm in set_methods.items(): lines.append("") - lines.extend(emit_set_method(spec, markup, sm_name, sm, upd_fields, upd_schemas, indent)) + lines.extend( + emit_set_method( + spec, markup, sm_name, sm, upd_fields, upd_schemas, indent + ) + ) lines.append(" end") lines.append(" end") lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc=f"Generated REST resource for the {spec.name!r} namespace.") + "\n" + "\n".join(lines) + "\n" + return ( + GEN_HEADER.format( + desc=f"Generated REST resource for the {spec.name!r} namespace." + ) + + "\n" + + "\n".join(lines) + + "\n" + ) # --------------------------------------------------------------------------- @@ -1267,10 +1533,15 @@ def emit_resource(spec: Spec, anchor: str, markup: dict) -> str: # doesn't match the canonical accessor the reference client tree exposes, the # override pins it. Reference FACTS (the accessor callers use). ATTR_OVERRIDE = { - "GenericResources": "resources", "FabricAddresses": "addresses", - "FabricTokens": "tokens", "DatasphereDocuments": "documents", - "ProjectTokens": "tokens", "PubSub": "pubsub", - "MessageLogs": "messages", "VoiceLogs": "voice", "FaxLogs": "fax", + "GenericResources": "resources", + "FabricAddresses": "addresses", + "FabricTokens": "tokens", + "DatasphereDocuments": "documents", + "ProjectTokens": "tokens", + "PubSub": "pubsub", + "MessageLogs": "messages", + "VoiceLogs": "voice", + "FaxLogs": "fax", "ConferenceLogs": "conferences", } @@ -1281,7 +1552,7 @@ def container_accessor(markup: dict, name: str, container: str) -> str: if name in ATTR_OVERRIDE: return snake(ATTR_OVERRIDE[name]) lead = container[:1].upper() + container[1:] - stem = name[len(lead):] if name.startswith(lead) else name + stem = name[len(lead) :] if name.startswith(lead) else name return snake(stem) if stem else snake(name) @@ -1308,7 +1579,9 @@ def emit_container(container: str, members: list[tuple[str, str]]) -> str: lines.append(" module REST") lines.append(" module Namespaces") lines.append(" module Generated") - lines.append(f" # {cls} — groups the {container} namespace resources; each is exposed") + lines.append( + f" # {cls} — groups the {container} namespace resources; each is exposed" + ) lines.append(" # as a memoized reader on this container.") lines.append(f" class {cls}") accs = [a for a, _ in members] @@ -1323,7 +1596,14 @@ def emit_container(container: str, members: list[tuple[str, str]]) -> str: lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc=f"Generated REST client container for the {container} namespace.") + "\n" + "\n".join(lines) + "\n" + return ( + GEN_HEADER.format( + desc=f"Generated REST client container for the {container} namespace." + ) + + "\n" + + "\n".join(lines) + + "\n" + ) def emit_resource_tree(placed) -> str: @@ -1332,7 +1612,7 @@ def emit_resource_tree(placed) -> str: flats: list[tuple[str, str]] = [] containers_seen: list[str] = [] seen_c: set[str] = set() - for spec, anchor, markup, container in placed: + for _spec, _anchor, markup, container in placed: name = markup["name"] if not container: flats.append((flat_accessor(name), name)) @@ -1346,9 +1626,15 @@ def emit_resource_tree(placed) -> str: lines.append(" module REST") lines.append(" module Namespaces") lines.append(" module Generated") - lines.append(" # ResourceTree — lazy accessors for every flat REST resource plus the") - lines.append(" # namespace containers. The RestClient includes this module and provides") - lines.append(" # `generated_http_client`; each accessor memoizes its resource on the") + lines.append( + " # ResourceTree — lazy accessors for every flat REST resource plus the" + ) + lines.append( + " # namespace containers. The RestClient includes this module and provides" + ) + lines.append( + " # `generated_http_client`; each accessor memoizes its resource on the" + ) lines.append(" # shared HTTP client.") lines.append(" module ResourceTree") for accessor, cls in flats: @@ -1367,7 +1653,14 @@ def emit_resource_tree(placed) -> str: lines.append(" end") lines.append(" end") lines.append("end") - return GEN_HEADER.format(desc="Generated REST resource tree module that RestClient includes.") + "\n" + "\n".join(lines) + "\n" + return ( + GEN_HEADER.format( + desc="Generated REST resource tree module that RestClient includes." + ) + + "\n" + + "\n".join(lines) + + "\n" + ) # --------------------------------------------------------------------------- @@ -1458,7 +1751,11 @@ def is_object_schema(node: dict) -> bool: return False props = node.get("properties") t = _type_schema_type(node) - return (t == "object" or (t is None and props)) and isinstance(props, dict) and len(props) > 0 + return ( + (t == "object" or (t is None and props)) + and isinstance(props, dict) + and len(props) > 0 + ) def _wire_field_type_symbol(psc: dict) -> str: @@ -1477,8 +1774,9 @@ def _wire_field_type_symbol(psc: dict) -> str: return ":any" -def emit_type_class(ns_mod: str, raw_name: str, node: dict, ns_key: str, - psdk: "Path | None" = None) -> str: +def emit_type_class( + ns_mod: str, raw_name: str, node: dict, ns_key: str, psdk: Path | None = None +) -> str: """Emit one method-less Ruby data class for an object schema. ``raw_name`` is the SPEC schema name (the components/schemas key) — that, not the @@ -1491,19 +1789,30 @@ def emit_type_class(ns_mod: str, raw_name: str, node: dict, ns_key: str, lines.append(" module Generated") lines.append(" module Types") lines.append(f" module {ns_mod}") - lines.append(f" # {rb_name} — generated wire type from the {ns_key!r} spec" - f" (components/schemas {raw_name!r}).") + lines.append( + f" # {rb_name} — generated wire type from the {ns_key!r} spec" + f" (components/schemas {raw_name!r})." + ) lines.append(" #") - lines.append(" # Method-less data DTO: the frozen FIELDS constant maps each snake wire") - lines.append(" # key to its JSON type symbol. No reader/writer methods and no") - lines.append(" # initialize — the class is a bare namespace for its FIELDS map,") - lines.append(" # describing the wire shape rather than wrapping a payload.") + lines.append( + " # Method-less data DTO: the frozen FIELDS constant maps each snake wire" + ) + lines.append( + " # key to its JSON type symbol. No reader/writer methods and no" + ) + lines.append( + " # initialize — the class is a bare namespace for its FIELDS map," + ) + lines.append( + " # describing the wire shape rather than wrapping a payload." + ) lines.append(f" class {rb_name}") # SDK-surface policy from the single overlay (rest-apis/x-sdk-overlay.yaml), keyed by # the SPEC schema name (raw_name, the components/schemas key — NOT the emitted Ruby # class name): hidden fields dropped entirely, deprecated fields flagged. props = { - k: v for k, v in (node.get("properties") or {}).items() + k: v + for k, v in (node.get("properties") or {}).items() if not (psdk and overlay_hidden(k, raw_name, psdk)) } if props: @@ -1537,7 +1846,9 @@ def _enum_const_name(value: str) -> str: return s -def emit_type_enum(ns_mod: str, enum_name: str, values: list, ns_key: str, raw_name: str) -> str: +def emit_type_enum( + ns_mod: str, enum_name: str, values: list, ns_key: str, raw_name: str +) -> str: """Emit a method-less Ruby class carrying frozen string constants (value == wire string) grouped into a frozen ALL list — the port's closed-set idiom for an x-sdk-enum public enum (PORT_PHILOSOPHY_RUBY). Surfaced as a method-less @@ -1550,9 +1861,15 @@ class by the reference.""" lines.append(" module Types") lines.append(f" module {ns_mod}") lines.append(f" # {enum_name} — public closed-set for {raw_name!r}") - lines.append(f" # ({ns_key!r} API). Frozen string constants whose value IS the wire") - lines.append(" # string (the idiomatic Ruby closed set — not a static enum type),") - lines.append(" # grouped into a frozen ALL. Method-less: constants only, no instance methods.") + lines.append( + f" # ({ns_key!r} API). Frozen string constants whose value IS the wire" + ) + lines.append( + " # string (the idiomatic Ruby closed set — not a static enum type)," + ) + lines.append( + " # grouped into a frozen ALL. Method-less: constants only, no instance methods." + ) lines.append(f" class {enum_name}") used: set[str] = set() consts: list[str] = [] @@ -1604,10 +1921,15 @@ def _reader_name(wire_key: str) -> str: return s -def emit_methodless_class(module_segments: list, rb_name: str, properties: dict, - source_desc: str, emit_readers: bool = False, - spec_schema_name: "str | None" = None, - psdk: "Path | None" = None) -> str: +def emit_methodless_class( + module_segments: list, + rb_name: str, + properties: dict, + source_desc: str, + emit_readers: bool = False, + spec_schema_name: str | None = None, + psdk: Path | None = None, +) -> str: """Emit one generated Ruby data class under an ARBITRARY nested module path, carrying a frozen FIELDS constant that maps each snake wire key to its JSON type symbol. Shared by the REST wire-type emitter and the SWML-verbs / @@ -1636,32 +1958,47 @@ def emit_methodless_class(module_segments: list, rb_name: str, properties: dict, # Every module segment carries a doc comment: this file's namespace nesting is # public surface and the DOC-SURFACE gate reads the nearest preceding comment. if depth: - lines.append(f"{indent}# {'::'.join(module_segments[:depth + 1])} — " - f"namespace for this generated data-class tree.") + lines.append( + f"{indent}# {'::'.join(module_segments[: depth + 1])} — " + f"namespace for this generated data-class tree." + ) lines.append(f"{indent}module {seg}") indent += " " kind = "data type" if not emit_readers else "read-side payload" lines.append(f"{indent}# {rb_name} — generated {kind} ({source_desc}).") lines.append(f"{indent}#") - lines.append(f"{indent}# Frozen FIELDS maps each snake wire key to its JSON type symbol.") + lines.append( + f"{indent}# Frozen FIELDS maps each snake wire key to its JSON type symbol." + ) if emit_readers: - lines.append(f"{indent}# Each field also has a zero-arg reader, so a decoded payload can be") + lines.append( + f"{indent}# Each field also has a zero-arg reader, so a decoded payload can be" + ) lines.append(f"{indent}# accessed by name rather than by wire key.") else: - lines.append(f"{indent}# No reader/writer methods and no initialize — the class is a bare") - lines.append(f"{indent}# namespace for its FIELDS map, describing the wire shape only.") + lines.append( + f"{indent}# No reader/writer methods and no initialize — the class is a bare" + ) + lines.append( + f"{indent}# namespace for its FIELDS map, describing the wire shape only." + ) lines.append(f"{indent}class {rb_name}") inner = indent + " " + # SDK-surface policy from the single overlay (rest-apis/x-sdk-overlay.yaml), keyed # by the SPEC schema name (spec_schema_name) — hidden fields are dropped entirely # (FIELDS + reader), deprecated fields are emitted with a `# deprecated:` marker. # Only applied when the caller passes the spec name + psdk (swml-verbs does; the # relay-protocol / swaig-payload callers don't and are unaffected). def _hidden(k: str) -> bool: - return bool(spec_schema_name and psdk and overlay_hidden(k, spec_schema_name, psdk)) + return bool( + spec_schema_name and psdk and overlay_hidden(k, spec_schema_name, psdk) + ) def _deprecated(k: str) -> bool: - return bool(spec_schema_name and psdk and overlay_deprecated(k, spec_schema_name, psdk)) + return bool( + spec_schema_name and psdk and overlay_deprecated(k, spec_schema_name, psdk) + ) props_kept = {k: v for k, v in (properties or {}).items() if not _hidden(k)} if props_kept: @@ -1682,15 +2019,16 @@ def _deprecated(k: str) -> bool: used.add(r) readers.append(r) lines.append("") - for r in readers: - lines.append(f"{inner}attr_reader :{r}") + lines.extend(f"{inner}attr_reader :{r}" for r in readers) else: lines.append(f"{inner}FIELDS = {{}}.freeze") lines.append(f"{indent}end") for _ in module_segments: indent = indent[:-2] lines.append(f"{indent}end") - return GENERIC_TYPES_HEADER.format(desc=source_desc) + "\n" + "\n".join(lines) + "\n" + return ( + GENERIC_TYPES_HEADER.format(desc=source_desc) + "\n" + "\n".join(lines) + "\n" + ) def _load_types_schemas(psdk: Path, spec_dir: str) -> dict: @@ -1716,7 +2054,12 @@ def emit_types(psdk: Path, outs: dict, type_ns: list[tuple[str, str, str]]) -> N fn = f"types/{ns_key}/{snake(enum_name)}.rb" if fn not in outs: outs[fn] = emit_type_enum( - ns_mod, enum_name, list(node.get("enum") or []), ns_key, raw_name) + ns_mod, + enum_name, + list(node.get("enum") or []), + ns_key, + raw_name, + ) continue # Object schema → a method-less data class. (Non-object, non-x-sdk-enum # schemas — scalar/array/union aliases and plain inline enums — are NOT @@ -1734,6 +2077,7 @@ def emit_types(psdk: Path, outs: dict, type_ns: list[tuple[str, str, str]]) -> N # Driver. # --------------------------------------------------------------------------- + def generated_module(spec_name: str) -> str: """The oracle module a namespace's resource classes land in — the Python reference emits every generated resource of spec ```` into @@ -1743,7 +2087,11 @@ def generated_module(spec_name: str) -> str: generated ``SignalWire::REST::Namespaces::Generated::`` class onto the module this returns so the idiom-blind surface/signature diffs line up 1:1 with the reference.""" - return "signalwire.rest.namespaces." + spec_name.replace("-", "_") + "_resources_generated" + return ( + "signalwire.rest.namespaces." + + spec_name.replace("-", "_") + + "_resources_generated" + ) CLIENT_TREE_MODULE = "signalwire.rest.namespaces._client_tree_generated" @@ -1777,8 +2125,7 @@ def build_rest_signatures_sidecar() -> dict: keyword params and this sidecar are BOTH derived from the same computed param lists in the generator, so they never diverge (GEN-FRESH covers the sidecar).""" methods = { - f"{cls}::{meth}": records - for (cls, meth), records in sorted(_SIDECAR.items()) + f"{cls}::{meth}": records for (cls, meth), records in sorted(_SIDECAR.items()) } return { "_comment": ( @@ -1807,7 +2154,7 @@ def build_outputs(psdk: Path) -> dict[str, str]: placed = resolve_placement(specs) by_container: dict[str, list[tuple[str, str]]] = {} order: list[str] = [] - for spec, anchor, markup, container in placed: + for _spec, _anchor, markup, container in placed: if not container: continue if container not in by_container: @@ -1817,7 +2164,9 @@ def build_outputs(psdk: Path) -> dict[str, str]: by_container[container].append((acc, markup["name"])) for container in order: if container not in CONTAINERS: - raise SystemExit(f"container attr {container!r} has no Ruby container class (add to CONTAINERS)") + raise SystemExit( + f"container attr {container!r} has no Ruby container class (add to CONTAINERS)" + ) cls, _ = CONTAINERS[container] outs[snake(cls) + ".rb"] = emit_container(container, by_container[container]) outs["resource_tree.rb"] = emit_resource_tree(placed) @@ -1830,7 +2179,9 @@ def build_outputs(psdk: Path) -> dict[str, str]: def main(argv: list[str]) -> int: ap = argparse.ArgumentParser(description=__doc__) - ap.add_argument("--check", action="store_true", help="GEN-FRESH: exit non-zero if stale") + ap.add_argument( + "--check", action="store_true", help="GEN-FRESH: exit non-zero if stale" + ) ap.add_argument("--out", default="", help="scratch: emit flat into this dir") args = ap.parse_args(argv) @@ -1841,14 +2192,19 @@ def main(argv: list[str]) -> int: if scratch: out_dir = Path(args.out) else: - out_dir = repo_root() / "lib" / "signalwire" / "rest" / "namespaces" / "generated" + out_dir = ( + repo_root() / "lib" / "signalwire" / "rest" / "namespaces" / "generated" + ) # Format-on-emit: run the raw emit through the repo's rubocop safe-autocorrect so the # committed tree is both GEN-FRESH clean (regen reproduces it) and FMT/LINT clean # (needs no generated-tree Exclude in .rubocop.yml). Skipped for a --out scratch dump. if not scratch: rel_base = out_dir.relative_to(repo_root()).as_posix() - wrapped = {f"{rel_base}/{fn}": wrap_spec_derived_disables(src) for fn, src in outs.items()} + wrapped = { + f"{rel_base}/{fn}": wrap_spec_derived_disables(src) + for fn, src in outs.items() + } formatted = rubocop_format(wrapped) outs = {fn: formatted[f"{rel_base}/{fn}"] for fn in outs} @@ -1863,7 +2219,9 @@ def main(argv: list[str]) -> int: # (§B / L10). Populated during build_outputs(psdk) above. Committed at the # repo root next to port_signatures.json. rest_sig_path = repo_root() / "rest_signatures.json" - rest_sig_src = json.dumps(build_rest_signatures_sidecar(), indent=2, sort_keys=True) + "\n" + rest_sig_src = ( + json.dumps(build_rest_signatures_sidecar(), indent=2, sort_keys=True) + "\n" + ) if args.check: stale = [] @@ -1876,14 +2234,20 @@ def main(argv: list[str]) -> int: rel = p.relative_to(out_dir).as_posix() if rel not in expected: stale.append(f"{p} (leftover — not in generator output)") - if not scratch and (not sidecar_path.is_file() or sidecar_path.read_text() != sidecar_src): + if not scratch and ( + not sidecar_path.is_file() or sidecar_path.read_text() != sidecar_src + ): stale.append(f"{sidecar_path} (surface-map sidecar stale)") - if not scratch and (not rest_sig_path.is_file() or rest_sig_path.read_text() != rest_sig_src): + if not scratch and ( + not rest_sig_path.is_file() or rest_sig_path.read_text() != rest_sig_src + ): stale.append(f"{rest_sig_path} (typed-input sidecar stale)") if stale: - sys.stderr.write("GEN-FRESH FAIL: %d generated REST file(s) stale:\n" % len(stale)) + sys.stderr.write( + f"GEN-FRESH FAIL: {len(stale)} generated REST file(s) stale:\n" + ) for s in stale: - sys.stderr.write(" - %s\n" % s) + sys.stderr.write(f" - {s}\n") return 1 print("GEN-FRESH: generated REST files match the canonical specs.") return 0 diff --git a/scripts/generate_rest_tests.py b/scripts/generate_rest_tests.py index 9248eb7a..4dda7cc2 100644 --- a/scripts/generate_rest_tests.py +++ b/scripts/generate_rest_tests.py @@ -26,7 +26,7 @@ generator self-snapshot. Inputs joined by (METHOD, normalized-path) (RULES §2): the registry's deduped -routes (path params already {id}) × the spec operationIds (spec path normalized +routes (path params already {id}) CROSSED WITH the spec operationIds (spec path normalized the SAME way before the join). Routing collisions are resolved longest-template-wins (RULES §7) so the asserted route is the one the mock ACTUALLY journals (e.g. GET /rooms/{id} vs GET /rooms/{name}). @@ -46,6 +46,7 @@ python3 scripts/generate_rest_tests.py # (re)write the test files python3 scripts/generate_rest_tests.py --check # GEN-FRESH: fail if stale """ + from __future__ import annotations import argparse @@ -57,7 +58,7 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _gen_format import rubocop_format, wrap_spec_derived_disables # noqa: E402 +from _gen_format import rubocop_format, wrap_spec_derived_disables try: import yaml @@ -70,6 +71,7 @@ # Resolution. # --------------------------------------------------------------------------- + def resolve_porting_sdk() -> Path: env = os.environ.get("PORTING_SDK") if env and (Path(env) / "rest-apis").is_dir(): @@ -94,9 +96,13 @@ def repo_root() -> Path: # rest_test_plan.rb: per-via call plan (chain, member, sentinel args). # --------------------------------------------------------------------------- + def _run_ruby(script: Path) -> dict: - proc = subprocess.run( - ["ruby", "-Ilib", str(script)], + # S603/S607: fixed list-form arg vector under the default shell=False (no + # shell to interpolate into); `script` is a path this module builds from + # repo_root(). S607's partial `ruby` path is the normal PATH-resolved idiom. + proc = subprocess.run( # noqa: S603 + ["ruby", "-Ilib", str(script)], # noqa: S607 cwd=str(repo_root()), capture_output=True, text=True, @@ -132,7 +138,7 @@ def load_plan() -> dict[str, dict]: # --------------------------------------------------------------------------- -# 2. The join — registry routes × spec operationIds by (method, normalized-path). +# 2. The join — registry routes CROSSED WITH spec operationIds by (method, normalized-path). # --------------------------------------------------------------------------- _BRACE = re.compile(r"\{[^}]+\}") @@ -152,15 +158,13 @@ def wire_key(p: str) -> str: def spec_prefix(doc: dict) -> str: url = ((doc.get("servers") or [{}])[0]).get("url", "") i = url.find("signalwire.com") - return url[i + len("signalwire.com"):] if i >= 0 else "" + return url[i + len("signalwire.com") :] if i >= 0 else "" def spec_dirs_with_openapi(psdk: Path) -> list[str]: root = psdk / "rest-apis" out = [ - d.name - for d in root.iterdir() - if d.is_dir() and (d / "openapi.yaml").is_file() + d.name for d in root.iterdir() if d.is_dir() and (d / "openapi.yaml").is_file() ] return sorted(out) @@ -211,13 +215,15 @@ def build_join(routes: list[dict], psdk: Path, spec_dirs: list[str]) -> list[dic continue op_id = winner[1] spec = op_id[: op_id.index(".")] - rows.append({ - "method": method, - "path": np, - "op_id": op_id, - "via": via_list[0], - "spec": spec, - }) + rows.append( + { + "method": method, + "path": np, + "op_id": op_id, + "via": via_list[0], + "spec": spec, + } + ) return rows @@ -225,9 +231,12 @@ def build_join(routes: list[dict], psdk: Path, spec_dirs: list[str]) -> list[dic # 3. Emit — one tests/rest/generated/_generated_test.rb per spec namespace. # --------------------------------------------------------------------------- + def camel_spec(spec: str) -> str: """spec dir name → CamelCase class-name fragment (relay-rest → RelayRest).""" - return "".join(part[:1].upper() + part[1:] for part in re.split(r"[-_]", spec) if part) + return "".join( + part[:1].upper() + part[1:] for part in re.split(r"[-_]", spec) if part + ) def slug(via: str) -> str: @@ -237,7 +246,7 @@ def slug(via: str) -> str: calling_dial. Non-alnum → '_', trailing '_' trimmed. Used to build the test-method name, which minitest discovers by the `test_` prefix. """ - tail = via[via.index(".") + 1:] if "." in via else via + tail = via[via.index(".") + 1 :] if "." in via else via return re.sub(r"_+$", "", re.sub(r"[^A-Za-z0-9]+", "_", tail)) @@ -315,6 +324,7 @@ def test_{name}_error # Driver. # --------------------------------------------------------------------------- + def build_outputs(psdk: Path) -> tuple[dict[str, str], list[str], int]: """Return ({filename: source}, uncovered_vias, n_routes_covered).""" routes = load_routes() @@ -362,20 +372,27 @@ def build_outputs(psdk: Path) -> tuple[dict[str, str], list[str], int]: def main(argv: list[str]) -> int: ap = argparse.ArgumentParser(description=__doc__) - ap.add_argument("--check", action="store_true", help="GEN-FRESH: exit non-zero if stale") + ap.add_argument( + "--check", action="store_true", help="GEN-FRESH: exit non-zero if stale" + ) ap.add_argument("--out", default="", help="scratch: emit into this dir") args = ap.parse_args(argv) psdk = resolve_porting_sdk() outs, uncovered, n_covered = build_outputs(psdk) - out_dir = Path(args.out) if args.out else (repo_root() / "tests" / "rest" / "generated") + out_dir = ( + Path(args.out) if args.out else (repo_root() / "tests" / "rest" / "generated") + ) if not args.out: # Format-on-emit (see _gen_format): wrap the spec-derived disable pair, then run the # repo rubocop safe-autocorrect so the committed tree is GEN-FRESH + FMT/LINT clean. rel_base = out_dir.relative_to(repo_root()).as_posix() - wrapped = {f"{rel_base}/{fn}": wrap_spec_derived_disables(src) for fn, src in outs.items()} + wrapped = { + f"{rel_base}/{fn}": wrap_spec_derived_disables(src) + for fn, src in outs.items() + } formatted = rubocop_format(wrapped) outs = {fn: formatted[f"{rel_base}/{fn}"] for fn in outs} @@ -394,11 +411,15 @@ def main(argv: list[str]) -> int: stale.append(str(p)) expected = set(outs.keys()) if out_dir.is_dir(): - for p in sorted(out_dir.glob("*_generated_test.rb")): - if p.name not in expected: - stale.append(f"{p} (leftover — not in generator output)") + stale.extend( + f"{p} (leftover — not in generator output)" + for p in sorted(out_dir.glob("*_generated_test.rb")) + if p.name not in expected + ) if stale: - sys.stderr.write("GEN-FRESH FAIL: %d generated REST test file(s) stale:\n" % len(stale)) + sys.stderr.write( + f"GEN-FRESH FAIL: {len(stale)} generated REST test file(s) stale:\n" + ) for s in stale: sys.stderr.write(f" - {s}\n") return 1 diff --git a/scripts/generate_swaig_payloads.py b/scripts/generate_swaig_payloads.py index 87fa2a23..a9bb254e 100644 --- a/scripts/generate_swaig_payloads.py +++ b/scripts/generate_swaig_payloads.py @@ -38,6 +38,7 @@ python3 scripts/generate_swaig_payloads.py --check # GEN-FRESH: fail if stale python3 scripts/generate_swaig_payloads.py --out DIR # scratch: emit into DIR """ + from __future__ import annotations import argparse @@ -47,12 +48,14 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _gen_format import rubocop_format, wrap_spec_derived_disables # noqa: E402 +from _gen_format import rubocop_format, wrap_spec_derived_disables def _load_rest_generator(): here = Path(__file__).resolve().parent - spec = importlib.util.spec_from_file_location("generate_rest", here / "generate_rest.py") + spec = importlib.util.spec_from_file_location( + "generate_rest", here / "generate_rest.py" + ) if spec is None or spec.loader is None: # pragma: no cover raise SystemExit("generate_swaig_payloads.py: cannot load generate_rest.py") mod = importlib.util.module_from_spec(spec) @@ -87,7 +90,9 @@ def _load_yaml(path: Path) -> dict: def _emit(module_segs, subdir, rb_name, props, desc, emit_readers): fn = "/".join(subdir) + f"/{GR.snake(rb_name)}.rb" - src = GR.emit_methodless_class(module_segs, rb_name, props, desc, emit_readers=emit_readers) + src = GR.emit_methodless_class( + module_segs, rb_name, props, desc, emit_readers=emit_readers + ) return fn, src @@ -103,11 +108,23 @@ def _build_swaig_request(psdk: Path) -> dict: outs: dict = {} arg = props.get("argument") if isinstance(arg, dict) and arg.get("properties"): - fn, src = _emit(SR_MODULE, SR_SUBDIR, "SwaigArgument", arg["properties"], - "inline swaig-request `argument` object", emit_readers=True) + fn, src = _emit( + SR_MODULE, + SR_SUBDIR, + "SwaigArgument", + arg["properties"], + "inline swaig-request `argument` object", + emit_readers=True, + ) outs[fn] = src - fn, src = _emit(SR_MODULE, SR_SUBDIR, "SwaigRequest", props, - "swaig-request `SwaigRequest` schema", emit_readers=True) + fn, src = _emit( + SR_MODULE, + SR_SUBDIR, + "SwaigRequest", + props, + "swaig-request `SwaigRequest` schema", + emit_readers=True, + ) outs[fn] = src return outs @@ -124,8 +141,14 @@ def _build_post_prompt(psdk: Path) -> dict: if rb_name in emitted: continue emitted.add(rb_name) - fn, src = _emit(PP_MODULE, PP_SUBDIR, rb_name, node.get("properties") or {}, - f"post-prompt components/schemas {raw_name!r}", emit_readers=True) + fn, src = _emit( + PP_MODULE, + PP_SUBDIR, + rb_name, + node.get("properties") or {}, + f"post-prompt components/schemas {raw_name!r}", + emit_readers=True, + ) outs[fn] = src return outs @@ -135,7 +158,11 @@ def _build_swaig_actions(psdk: Path) -> dict: actions = spec["components"]["schemas"]["SwaigAction"]["properties"] def _is_obj(s) -> bool: - return isinstance(s, dict) and s.get("type") == "object" and bool(s.get("properties")) + return ( + isinstance(s, dict) + and s.get("type") == "object" + and bool(s.get("properties")) + ) outs: dict = {} emitted: set = set() @@ -149,13 +176,21 @@ def _is_obj(s) -> bool: if not _is_obj(b): continue obj_i += 1 - rb_name = GR.type_name(_pascal_verb(verb) + "Action" + ("" if obj_i == 1 else str(obj_i))) + rb_name = GR.type_name( + _pascal_verb(verb) + "Action" + ("" if obj_i == 1 else str(obj_i)) + ) if rb_name in emitted: continue emitted.add(rb_name) # swaig-actions are NOT in the sig oracle -> method-less both sides. - fn, src = _emit(SA_MODULE, SA_SUBDIR, rb_name, b.get("properties") or {}, - f"swaig-response action {verb!r} value object", emit_readers=False) + fn, src = _emit( + SA_MODULE, + SA_SUBDIR, + rb_name, + b.get("properties") or {}, + f"swaig-response action {verb!r} value object", + emit_readers=False, + ) outs[fn] = src return outs @@ -175,7 +210,9 @@ def build_outputs(psdk: Path) -> dict: def main(argv: list) -> int: ap = argparse.ArgumentParser(description=__doc__) - ap.add_argument("--check", action="store_true", help="GEN-FRESH: exit non-zero if stale") + ap.add_argument( + "--check", action="store_true", help="GEN-FRESH: exit non-zero if stale" + ) ap.add_argument("--out", default="", help="scratch: emit into this dir") args = ap.parse_args(argv) @@ -188,7 +225,10 @@ def main(argv: list) -> int: # Format-on-emit (see _gen_format): wrap the spec-derived disable pair, then run the # repo rubocop safe-autocorrect so the committed tree is GEN-FRESH + FMT/LINT clean. rel_base = out_dir.relative_to(repo_root()).as_posix() - wrapped = {f"{rel_base}/{fn}": wrap_spec_derived_disables(src) for fn, src in outs.items()} + wrapped = { + f"{rel_base}/{fn}": wrap_spec_derived_disables(src) + for fn, src in outs.items() + } formatted = rubocop_format(wrapped) outs = {fn: formatted[f"{rel_base}/{fn}"] for fn in outs} @@ -208,11 +248,15 @@ def main(argv: list) -> int: if rel not in expected: stale.append(f"{p} (leftover — not in generator output)") if stale: - sys.stderr.write("GEN-FRESH FAIL: %d generated SWAIG-payload file(s) stale:\n" % len(stale)) + sys.stderr.write( + f"GEN-FRESH FAIL: {len(stale)} generated SWAIG-payload file(s) stale:\n" + ) for s in stale: - sys.stderr.write(" - %s\n" % s) + sys.stderr.write(f" - {s}\n") return 1 - print("GEN-FRESH: generated SWAIG-payload files match porting-sdk/swaig-specs/.") + print( + "GEN-FRESH: generated SWAIG-payload files match porting-sdk/swaig-specs/." + ) return 0 for fn, src in outs.items(): diff --git a/scripts/generate_swml_verbs.py b/scripts/generate_swml_verbs.py index e1a4f53b..c4de25d0 100644 --- a/scripts/generate_swml_verbs.py +++ b/scripts/generate_swml_verbs.py @@ -38,6 +38,7 @@ python3 scripts/generate_swml_verbs.py --check # GEN-FRESH: fail if stale python3 scripts/generate_swml_verbs.py --out DIR # scratch: emit into DIR """ + from __future__ import annotations import argparse @@ -48,12 +49,14 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _gen_format import rubocop_format, wrap_spec_derived_disables # noqa: E402 +from _gen_format import rubocop_format, wrap_spec_derived_disables def _load_rest_generator(): here = Path(__file__).resolve().parent - spec = importlib.util.spec_from_file_location("generate_rest", here / "generate_rest.py") + spec = importlib.util.spec_from_file_location( + "generate_rest", here / "generate_rest.py" + ) if spec is None or spec.loader is None: # pragma: no cover raise SystemExit("generate_swml_verbs.py: cannot load generate_rest.py") mod = importlib.util.module_from_spec(spec) @@ -132,7 +135,9 @@ def build_outputs(psdk: Path) -> dict: outs: dict = {} emitted_names: set = set() - def emit(rb_name: str, props: dict, desc: str, spec_schema_name: "str | None" = None) -> None: + def emit( + rb_name: str, props: dict, desc: str, spec_schema_name: str | None = None + ) -> None: if rb_name in emitted_names: return emitted_names.add(rb_name) @@ -141,16 +146,26 @@ def emit(rb_name: str, props: dict, desc: str, spec_schema_name: "str | None" = # emit_methodless_class can consult x-sdk-overlay.yaml (hidden/deprecated). Scoped # by the spec name, NOT the emitted Ruby class name. Synthetic Config classes # have no spec name (None) — the overlay's AIParams-scoped rules never match them. - outs[fn] = GR.emit_methodless_class(SWML_VERBS_MODULE, rb_name, props, desc, - emit_readers=True, - spec_schema_name=spec_schema_name, psdk=psdk) + outs[fn] = GR.emit_methodless_class( + SWML_VERBS_MODULE, + rb_name, + props, + desc, + emit_readers=True, + spec_schema_name=spec_schema_name, + psdk=psdk, + ) # 1. One data class per OBJECT $defs schema. for raw_name, node in defs.items(): if not isinstance(node, dict) or not GR.is_object_schema(node): continue - emit(GR.type_name(raw_name), node.get("properties") or {}, - f"schema.json $defs schema {raw_name!r}", spec_schema_name=raw_name) + emit( + GR.type_name(raw_name), + node.get("properties") or {}, + f"schema.json $defs schema {raw_name!r}", + spec_schema_name=raw_name, + ) # 2. One Config class per flattenable SWMLMethod.anyOf verb. sm = defs.get("SWMLMethod") @@ -172,15 +187,20 @@ def emit(rb_name: str, props: dict, desc: str, spec_schema_name: "str | None" = props = _flatten_union(defs, inner) if not props: continue - emit(GR.type_name(_pascal(verb) + "Config"), props, - f"flattened SWMLMethod verb {verb!r} config") + emit( + GR.type_name(_pascal(verb) + "Config"), + props, + f"flattened SWMLMethod verb {verb!r} config", + ) return outs def main(argv: list) -> int: ap = argparse.ArgumentParser(description=__doc__) - ap.add_argument("--check", action="store_true", help="GEN-FRESH: exit non-zero if stale") + ap.add_argument( + "--check", action="store_true", help="GEN-FRESH: exit non-zero if stale" + ) ap.add_argument("--out", default="", help="scratch: emit into this dir") args = ap.parse_args(argv) @@ -189,15 +209,16 @@ def main(argv: list) -> int: if args.out: out_dir = Path(args.out) - prefix = "" else: out_dir = repo_root() / "lib" / "signalwire" - prefix = "" # Format-on-emit (see _gen_format): wrap each file's body in the spec-derived # disable pair, then run the repo rubocop safe-autocorrect, so the committed tree # is both GEN-FRESH clean and FMT/LINT clean (no generated-tree Exclude needed). rel_base = out_dir.relative_to(repo_root()).as_posix() - wrapped = {f"{rel_base}/{fn}": wrap_spec_derived_disables(src) for fn, src in outs.items()} + wrapped = { + f"{rel_base}/{fn}": wrap_spec_derived_disables(src) + for fn, src in outs.items() + } formatted = rubocop_format(wrapped) outs = {fn: formatted[f"{rel_base}/{fn}"] for fn in outs} @@ -215,11 +236,15 @@ def main(argv: list) -> int: if rel not in expected: stale.append(f"{p} (leftover — not in generator output)") if stale: - sys.stderr.write("GEN-FRESH FAIL: %d generated SWML-verb file(s) stale:\n" % len(stale)) + sys.stderr.write( + f"GEN-FRESH FAIL: {len(stale)} generated SWML-verb file(s) stale:\n" + ) for s in stale: - sys.stderr.write(" - %s\n" % s) + sys.stderr.write(f" - {s}\n") return 1 - print("GEN-FRESH: generated SWML-verb files match porting-sdk/schema.json ($defs).") + print( + "GEN-FRESH: generated SWML-verb files match porting-sdk/schema.json ($defs)." + ) return 0 for fn, src in outs.items(): From cfbe097c9c94f7cd15ab990c304286da40928c18 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 06:22:33 -0400 Subject: [PATCH 70/90] ci: wire PY-LINT + PY-FMT; document the widened FMT/LINT scope Wired only now that BOTH burns are at zero (rubocop 743 -> 0, ruff 58 -> 0), so neither gate lands red. Ruby side: NO new gate. FMT and LINT already invoke bare `rubocop` from the repo root, so cutting .rubocop.yml's AllCops/Exclude down to vendor/ widened them automatically over examples/, relay/examples/, rest/examples/, the 12 bin/*-dump programs and scripts/doc_wire_runner.rb. Adding a REPO-LINT/REPO-FMT pair would have double-linted the same files; the gate descriptions and a run-ci comment now say so explicitly so nobody adds one later. Also corrected the stale scope comment in _env.sh, which still claimed examples/ were excluded. Python side: new PY-LINT + PY-FMT gates over scripts/*.py, with scripts/run-py-lint.sh and scripts/run-py-format.sh as the canonical entry points -- same shape as run-lint.sh / run-format.sh, same contract for the format gate (LOCAL APPLIES, CI RUNS --check), CWD-independent via _env.sh. ruff is declared in BOTH layers, per the dev-dependency rule: * scripts/_env.sh: sw_ruff resolves `python3 -m ruff`, else the `ruff` binary on PATH, else FAILS LOUD with an install hint. Never a silent skip -- a skipping gate is a gate that passes vacuously. * the three ruby workflows that run run-ci.sh (test.yml, nightly.yml x2 jobs, publish.yml) each `pip install ruff`. Negative-controlled rather than assumed: with a deliberately bad scripts/*.py (unused imports + unformatted), run-py-lint.sh exits 1 and run-py-format.sh --check exits 1 -- both invoked from a DIFFERENT working directory, which also proves the repo-root resolution. CROSS-REPO FOLLOW-UP (not editable from this lane): porting-sdk's .github/workflows/cross-port.yml runs each port's run-ci.sh and does not install ruff. The ruby matrix leg will hit _env.sh's fail-loud until `pip install ruff` is added to its setup, alongside the existing mock_relay/mock_signalwire installs. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- .github/workflows/nightly.yml | 14 ++++++++++++ .github/workflows/publish.yml | 7 ++++++ .github/workflows/test.yml | 8 +++++++ scripts/_env.sh | 40 ++++++++++++++++++++++++++++++++--- scripts/run-ci.sh | 23 ++++++++++++++++++-- scripts/run-py-format.sh | 38 +++++++++++++++++++++++++++++++++ scripts/run-py-lint.sh | 35 ++++++++++++++++++++++++++++++ 7 files changed, 160 insertions(+), 5 deletions(-) create mode 100755 scripts/run-py-format.sh create mode 100755 scripts/run-py-lint.sh diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 3c923362..2c17c154 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -119,6 +119,13 @@ jobs: pip install -e porting-sdk/test_harness/mock_relay pip install -e porting-sdk/test_harness/mock_signalwire + # ruff backs the PY-LINT / PY-FMT gates over the hand-written Python in + # scripts/ (the 5 code generators, the surface enumerator, _gen_format.py). + # scripts/_env.sh fails LOUD when ruff is absent rather than skipping, so + # the gate cannot pass vacuously on a runner that lacks it. + - name: Install ruff (PY-LINT / PY-FMT gates) + run: pip install ruff + # EMISSION needs `import signalwire` (the oracle). Install from the # adjacent checkout only if not already importable. - name: Install signalwire-python (EMISSION oracle) if not importable @@ -197,6 +204,13 @@ jobs: pip install -e porting-sdk/test_harness/mock_relay pip install -e porting-sdk/test_harness/mock_signalwire + # ruff backs the PY-LINT / PY-FMT gates over the hand-written Python in + # scripts/ (the 5 code generators, the surface enumerator, _gen_format.py). + # scripts/_env.sh fails LOUD when ruff is absent rather than skipping, so + # the gate cannot pass vacuously on a runner that lacks it. + - name: Install ruff (PY-LINT / PY-FMT gates) + run: pip install ruff + # A clean-bundle require + the full suite on the forward Ruby: -w surfaces any # deprecation warning from a stdlib gem that was extracted from the defaults. - name: Require smoke + gemspec-dependency honesty (extracted-stdlib deps) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 92c7bbbc..b56d7aa3 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -48,6 +48,13 @@ jobs: pip install -e porting-sdk/test_harness/mock_relay pip install -e porting-sdk/test_harness/mock_signalwire + # ruff backs the PY-LINT / PY-FMT gates over the hand-written Python in + # scripts/ (the 5 code generators, the surface enumerator, _gen_format.py). + # scripts/_env.sh fails LOUD when ruff is absent rather than skipping, so + # the gate cannot pass vacuously on a runner that lacks it. + - name: Install ruff (PY-LINT / PY-FMT gates) + run: pip install ruff + - name: Run CI gate script (full run-ci.sh — the same gate set as PR CI) working-directory: signalwire-ruby env: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index c01f0af8..fe54fe3f 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -61,6 +61,14 @@ jobs: pip install -e porting-sdk/test_harness/mock_relay pip install -e porting-sdk/test_harness/mock_signalwire + # ruff backs the PY-LINT / PY-FMT gates over the hand-written Python in + # scripts/ (the 5 code generators, the surface enumerator, _gen_format.py). + # scripts/_env.sh fails LOUD when ruff is absent rather than skipping, so + # the gate cannot pass vacuously on a runner that lacks it — hence this + # explicit install rather than relying on it being preinstalled. + - name: Install ruff (PY-LINT / PY-FMT gates) + run: pip install ruff + # EMISSION needs `import signalwire` (the oracle). Install from the # adjacent checkout only if not already importable. - name: Install signalwire-python (EMISSION oracle) if not importable diff --git a/scripts/_env.sh b/scripts/_env.sh index 28246d4f..d3bfa0b3 100755 --- a/scripts/_env.sh +++ b/scripts/_env.sh @@ -51,10 +51,44 @@ _sw_bootstrap_rubocop() { } # sw_rubocop — run rubocop via bundler from the repo root. -# Bootstraps on first call. Path scope (which dirs are linted, and the generated / -# examples excludes) lives in .rubocop.yml, so callers pass MODE flags only -# (nothing, or -a) and let the config decide the tree. +# Bootstraps on first call. Path scope lives in .rubocop.yml — which as of +# 2026-07-30 excludes ONLY vendor/, so this covers lib/, tests/, examples/, +# relay/examples/, rest/examples/, bin/, scripts/ and the generated trees at one +# bar. Callers pass MODE flags only (nothing, or -a) and let the config decide. sw_rubocop() { _sw_bootstrap_rubocop || return 1 (cd "$REPO_ROOT" && bundle exec rubocop "$@") } + +# The hand-written PYTHON in scripts/ (the 5 code generators, the surface +# enumerator, _gen_format.py) is linted + format-checked by ruff, configured in +# ruff.toml. rubocop cannot see a .py file, so this is a SEPARATE tool with its +# own gates (PY-LINT / PY-FMT in run-ci.sh); it is not a second, looser bar -- +# ruff.toml mirrors the reference implementation's rule selection exactly. +SW_PY_DIRS=("scripts") + +# ruff is a NATIVE binary (not a gem), so it is declared here rather than in the +# Gemfile: `python3 -m ruff` when the module is importable, else the `ruff` +# binary on PATH, else fail loud with an install hint. Same shape as the rubocop +# bootstrap above -- never a silent skip, which would let the gate pass vacuously. +_sw_ruff_cmd() { + if python3 -c 'import ruff' >/dev/null 2>&1; then + echo "python3 -m ruff" + return 0 + fi + if command -v ruff >/dev/null 2>&1; then + echo "ruff" + return 0 + fi + echo "FATAL: ruff not found (needed to lint/format the Python under scripts/)." >&2 + echo " Install it with: python3 -m pip install ruff (or: brew install ruff)" >&2 + return 1 +} + +# sw_ruff — run ruff from the repo root, however it resolves. +sw_ruff() { + local cmd + cmd="$(_sw_ruff_cmd)" || return 1 + # shellcheck disable=SC2086 # $cmd is our own 1-or-3 word command, intentionally split + (cd "$REPO_ROOT" && $cmd "$@") +} diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh index 7a44efad..23a67be3 100755 --- a/scripts/run-ci.sh +++ b/scripts/run-ci.sh @@ -205,12 +205,31 @@ sched_gate ENV-VAR-CONSISTENCY desc="REST base-url override present + custom-CA # for every port. This port's workflows are verified valid (live-smoke.yml gates on a # JOB-level env, not a step-level secrets.* in if:); actionlint is clean here. -sched_gate FMT defer=1 desc="run-format.sh (local: apply; CI: --check)" \ +# FMT + LINT cover the WHOLE Ruby tree at ONE bar. .rubocop.yml's AllCops/Exclude +# was cut to vendor/ alone on 2026-07-30 (owner: "examples and tests are shipping +# code too, all at the levels the shipping code gets"), so these two gates now +# reach examples/, relay/examples/, rest/examples/, the bin/*-dump programs and +# scripts/doc_wire_runner.rb as well as lib/ + tests/ + the generated trees. +# Both invoke bare rubocop from the repo root, so that widening needed no new +# gate here -- do NOT add a second one, it would double-lint the same files. +sched_gate FMT defer=1 desc="run-format.sh (whole repo minus vendor/; local: apply; CI: --check)" \ -- bash scripts/run-format.sh ${CI:+--check} -sched_gate LINT defer=1 desc="run-lint.sh (rubocop zero offenses)" \ +sched_gate LINT defer=1 desc="run-lint.sh (rubocop zero offenses, whole repo minus vendor/)" \ -- bash scripts/run-lint.sh +# PY-LINT / PY-FMT — the hand-written PYTHON under scripts/ (the 5 code +# generators, the surface enumerator, and _gen_format.py, which is part of the +# format toolchain itself). rubocop cannot see a .py file, so this tooling was +# linted and format-checked by NOTHING until 2026-07-30; ruff.toml mirrors the +# reference's rule selection so it is the same bar, not a looser one. +# Wired once the burn reached ZERO (58 -> 0), so the gate never lands red. +sched_gate PY-LINT defer=1 desc="run-py-lint.sh (ruff check, zero findings over scripts/*.py)" \ + -- bash scripts/run-py-lint.sh + +sched_gate PY-FMT defer=1 desc="run-py-format.sh (ruff format over scripts/*.py; local: apply; CI: --check)" \ + -- bash scripts/run-py-format.sh ${CI:+--check} + # ROUTE-COLLISION is intentionally NOT wired (kept out of the SURFACE suite for ruby): # with ruby's route_registry.rb it fails on a SPEC-FAITHFUL route-split — the fabric # spec declares SINGULAR sibling paths /resources/call_flow/{id}/addresses + diff --git a/scripts/run-py-format.sh b/scripts/run-py-format.sh new file mode 100755 index 00000000..7d73735d --- /dev/null +++ b/scripts/run-py-format.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# run-py-format.sh — the PY-FMT entry point for signalwire-ruby (tool: ruff). +# +# Same contract as scripts/run-format.sh, for the hand-written Python under +# scripts/ that rubocop cannot see: LOCAL APPLIES, CI RUNS --check. +# +# Modes: +# bash scripts/run-py-format.sh # DEFAULT: APPLY — reformat in place. +# bash scripts/run-py-format.sh --check # VERIFY-ONLY (CI) — exit non-zero if +# # anything is unformatted. +# +# Formatting is pinned to ruff's STABLE style by `preview = false` in ruff.toml, +# so a CI --check can never resolve preview formatting a local apply did not. +# +# Idempotent: a second run right after the first produces no diff. + +set -euo pipefail + +# shellcheck source=scripts/_env.sh +source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/_env.sh" + +MODE="apply" +if [ "${1:-}" = "--check" ]; then + MODE="check" +elif [ -n "${1:-}" ]; then + echo "usage: $0 [--check]" >&2 + exit 2 +fi + +if [ "$MODE" = "check" ]; then + echo "==> PY-FMT check (ruff format --check, read-only) — repo: $REPO_ROOT" + sw_ruff format --check "${SW_PY_DIRS[@]}" +else + echo "==> PY-FMT apply (ruff format) — repo: $REPO_ROOT" + sw_ruff format "${SW_PY_DIRS[@]}" >/dev/null + # Re-check so an apply that somehow left the tree unformatted still fails. + sw_ruff format --check "${SW_PY_DIRS[@]}" +fi diff --git a/scripts/run-py-lint.sh b/scripts/run-py-lint.sh new file mode 100755 index 00000000..b46b3d26 --- /dev/null +++ b/scripts/run-py-lint.sh @@ -0,0 +1,35 @@ +#!/usr/bin/env bash +# run-py-lint.sh — the PY-LINT entry point for signalwire-ruby (tool: ruff). +# +# The repo is a Ruby SDK, but scripts/ holds seven hand-written PYTHON programs: +# the five code generators, the cross-port surface enumerator, and +# _gen_format.py, which is part of the format toolchain itself. rubocop cannot +# see a .py file, so until 2026-07-30 none of that load-bearing tooling was +# linted by anything. +# +# This is NOT a second, looser tier: ruff.toml mirrors the reference +# implementation's rule selection (signalwire-python/pyproject.toml [tool.ruff]) +# exactly, so the Python here is held to the same bar the reference holds its own. +# +# Callable from ANY directory; the tool environment is self-bootstrapped via +# scripts/_env.sh (see porting-sdk/RUN_LINT_FORMAT_SPEC.md). +# +# Modes: +# bash scripts/run-py-lint.sh # report; exit non-zero on any finding. +# bash scripts/run-py-lint.sh --fix # apply SAFE fixes first, then report. + +set -euo pipefail + +# shellcheck source=scripts/_env.sh +source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/_env.sh" + +if [ "${1:-}" = "--fix" ]; then + echo "==> PY-LINT autofix (ruff check --fix, safe only) — repo: $REPO_ROOT" + sw_ruff check --fix "${SW_PY_DIRS[@]}" >/dev/null || true +elif [ -n "${1:-}" ]; then + echo "usage: $0 [--fix]" >&2 + exit 2 +fi + +echo "==> PY-LINT (ruff check, zero findings) — repo: $REPO_ROOT" +sw_ruff check "${SW_PY_DIRS[@]}" From e99b9632fcd33fb97713fad1b2c23674a2fc63c2 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 06:26:11 -0400 Subject: [PATCH 71/90] fix: move ruff.toml to eng/ (ROOT-HYGIENE) and resync the README includes Two gate failures the previous commits caused, both fixed at the source rather than allowlisted. ROOT-HYGIENE: a public port root must be free of tool config; the gate named the remedy ("move to eng/"). ruff.toml -> eng/ruff.toml. Adding a ROOT_HYGIENE_ALLOW.md entry instead would have needed human approval for a file that has no reason to sit at the root. That move exposed a REAL vacuous-pass risk, so sw_ruff now PINS --config eng/ruff.toml: ruff only auto-discovers a config from the TARGET's directory upward, so with the file at eng/ a bare `ruff check scripts/` silently falls back to ruff's BUILT-IN defaults. Measured on a probe using shell=True plus an unnecessary .keys() iteration -- built-in defaults find 0, this config finds 4. The gate would have gone on passing while checking almost nothing. Negative- controlled after the fix: a bad scripts/*.py still exits 1 through the runner. README-INCLUDE: all three README code blocks are gate-enforced to be BYTE-IDENTICAL to their `# region:` fixture in examples/. The rubocop autocorrect reformatted those examples (Layout/ExtraSpacing collapsed `token: ` to `token: `, etc.), so the README drifted. Resynced all three blocks FROM the fixtures, which is the correct direction -- the runnable example is the source of truth and the doc mirrors it. DOC-TRUTH now reports all 8 rules PASS (readme-include: clean, 3 sites verified). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- README.md | 16 ++++++++-------- ruff.toml => eng/ruff.toml | 0 scripts/_env.sh | 23 +++++++++++++++++------ 3 files changed, 25 insertions(+), 14 deletions(-) rename ruff.toml => eng/ruff.toml (100%) diff --git a/README.md b/README.md index 318c3d7d..daaf6f7a 100644 --- a/README.md +++ b/README.md @@ -55,10 +55,10 @@ AGENT.add_language('English', 'en-US', 'elevenlabs.rachel') AGENT.prompt_add_section('Role', 'You are a helpful assistant.') AGENT.define_tool( - name: 'get_time', + name: 'get_time', description: 'Get the current time', - parameters: {}, - handler: nil # the block below is the handler + parameters: {}, + handler: nil # the block below is the handler ) do |_args, _raw_data| SignalWire::Swaig::FunctionResult.new("The time is #{Time.now.strftime('%H:%M:%S')}") end @@ -134,9 +134,9 @@ require 'signalwire' require 'signalwire/relay/client' client = SignalWire::Relay::Client.new( - project: 'your-project-id', - token: 'your-api-token', - space: 'example.signalwire.com', + project: 'your-project-id', + token: 'your-api-token', + space: 'example.signalwire.com', contexts: ['default'] ) @@ -170,8 +170,8 @@ require 'signalwire/rest/rest_client' client = SignalWire::REST::RestClient.new( project: 'your-project-id', - token: 'your-api-token', - host: 'example.signalwire.com' + token: 'your-api-token', + host: 'example.signalwire.com' ) client.fabric.ai_agents.create(name: 'Support Bot', prompt: { 'text' => 'You are helpful.' }) diff --git a/ruff.toml b/eng/ruff.toml similarity index 100% rename from ruff.toml rename to eng/ruff.toml diff --git a/scripts/_env.sh b/scripts/_env.sh index d3bfa0b3..f7c3a5fc 100755 --- a/scripts/_env.sh +++ b/scripts/_env.sh @@ -62,9 +62,9 @@ sw_rubocop() { # The hand-written PYTHON in scripts/ (the 5 code generators, the surface # enumerator, _gen_format.py) is linted + format-checked by ruff, configured in -# ruff.toml. rubocop cannot see a .py file, so this is a SEPARATE tool with its -# own gates (PY-LINT / PY-FMT in run-ci.sh); it is not a second, looser bar -- -# ruff.toml mirrors the reference implementation's rule selection exactly. +# eng/ruff.toml. rubocop cannot see a .py file, so this is a SEPARATE tool with +# its own gates (PY-LINT / PY-FMT in run-ci.sh); it is not a second, looser bar +# -- eng/ruff.toml mirrors the reference implementation's rule selection exactly. SW_PY_DIRS=("scripts") # ruff is a NATIVE binary (not a gem), so it is declared here rather than in the @@ -85,10 +85,21 @@ _sw_ruff_cmd() { return 1 } -# sw_ruff — run ruff from the repo root, however it resolves. +# sw_ruff — run ruff from the repo root with the repo +# config PINNED. +# +# --config is load-bearing, not decoration: ruff.toml lives at eng/ruff.toml (the +# ROOT-HYGIENE gate keeps tool config out of a public port's root), and ruff only +# auto-discovers a config from the TARGET's directory upward. Without the flag it +# would silently fall back to its BUILT-IN defaults. Measured on a probe file +# using shell=True plus an unnecessary .keys() iteration: the built-in defaults +# find 0, this config finds 4. A gate running the wrong ruleset passes vacuously, +# which is worse than no gate. sw_ruff() { - local cmd + local cmd sub cmd="$(_sw_ruff_cmd)" || return 1 + sub="$1" + shift # shellcheck disable=SC2086 # $cmd is our own 1-or-3 word command, intentionally split - (cd "$REPO_ROOT" && $cmd "$@") + (cd "$REPO_ROOT" && $cmd "$sub" --config "$REPO_ROOT/eng/ruff.toml" "$@") } From 895087fb0358df325842c324fc267bb12f114bb1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 12:23:47 -0400 Subject: [PATCH 72/90] test(relay): stop mutating process-global ENV from parallel suites Two process-global ENV writes lived inside `parallelize_me!` classes, so every concurrently-running test observed an environment mutated by a test it does not own. Both are fixed by SCOPING, not by serialising: no suite mutex was added, no `parallelize_me!` was removed, and no ordering was forced. 1. `connect_mock_test.rb` -- `test_connect_rejects_empty_creds_at_constructor` `ENV.delete`d SIGNALWIRE_PROJECT_ID / _API_TOKEN / _JWT_TOKEN and restored them in an `ensure`. Under `parallelize_me!` that is a window in which the credential vars are absent for every other running thread, AND -- because the `ensure` restores them -- concurrent instances clobber each other's window. Demonstrated, not asserted: a minimal two-suite reproduction of this exact shape (one suite doing the delete/restore, one constructing a client that reads the ambient JWT) fails 12 of 40 runs. Fixed by INJECTION. No var actually needed clearing: `value_or_env` is `explicit || ENV[key]` and `''` is TRUTHY in Ruby, so the explicit `project:`/`token:`/`space:` already won outright. Only `jwt_token:` was unset and could fall back to an ambient SIGNALWIRE_JWT_TOKEN -- which short-circuits `validate_credentials` (client.rb:151) and would suppress the ArgumentError. Passing `jwt_token: ''` closes that channel by injection. Negative-controlled: with all three vars set ambient, the injected form still raises and the un-injected form does not -- so `jwt_token: ''` is load-bearing rather than decoration. 2. `mock_test.rb` -- `build_sdk_client` set SIGNALWIRE_RELAY_SCHEME and SIGNALWIRE_RELAY_HOST on EVERY client build, i.e. once per parallel test. Those two are the SDK's only ws:// redirect channel (client.rb:615/:625, no kwarg exists), so the VALUE must be process-global; the WRITE must not be. Moved into `Lifecycle.start_harness`, the `@mu`-guarded one-time startup that already computes the host -- written once, before any parallel suite starts, read-only thereafter. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- tests/relay/connect_mock_test.rb | 26 +++++++++++++++++--------- tests/relay/mock_test.rb | 17 ++++++++++++++--- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/tests/relay/connect_mock_test.rb b/tests/relay/connect_mock_test.rb index 06effc3f..6a042a0c 100644 --- a/tests/relay/connect_mock_test.rb +++ b/tests/relay/connect_mock_test.rb @@ -182,18 +182,26 @@ def test_connect_journal_event_acks_true # ---- Auth failure paths ------------------------------------------------ + # Every credential is INJECTED, so the assertion depends on nothing outside + # this example. It used to `ENV.delete` the three credential vars and restore + # them in an `ensure` -- a process-global mutation inside a `parallelize_me!` + # class, i.e. a window in which every concurrently-running test saw the + # environment of a test it does not own. (`ensure` restores the var, so the + # racing threads clobber EACH OTHER's window too: the mutation is the defect, + # not just the read.) + # + # No env var actually needed clearing. `value_or_env` is `explicit || ENV[key]` + # and `''` is TRUTHY in Ruby, so the explicit `project:`/`token:`/`space:` + # already win outright; only `jwt_token:` was unset and could fall back to an + # ambient `SIGNALWIRE_JWT_TOKEN` (which short-circuits validation and would + # suppress the ArgumentError). Passing `jwt_token: ''` closes that last channel + # by injection rather than by mutating the world. def test_connect_rejects_empty_creds_at_constructor - old_proj = ENV.delete('SIGNALWIRE_PROJECT_ID') - old_token = ENV.delete('SIGNALWIRE_API_TOKEN') - old_jwt = ENV.delete('SIGNALWIRE_JWT_TOKEN') - assert_raises(ArgumentError) do - SignalWire::Relay::Client.new(project: '', token: '', space: '127.0.0.1:1') + SignalWire::Relay::Client.new( + project: '', token: '', jwt_token: '', space: '127.0.0.1:1' + ) end - ensure - ENV['SIGNALWIRE_PROJECT_ID'] = old_proj if old_proj - ENV['SIGNALWIRE_API_TOKEN'] = old_token if old_token - ENV['SIGNALWIRE_JWT_TOKEN'] = old_jwt if old_jwt end def test_unauthenticated_raw_connect_rejected_by_mock diff --git a/tests/relay/mock_test.rb b/tests/relay/mock_test.rb index 8843b5ba..3efe7a18 100644 --- a/tests/relay/mock_test.rb +++ b/tests/relay/mock_test.rb @@ -337,11 +337,22 @@ def harness end # Resolve ports, build the Harness, and probe-or-spawn the server. + # + # SIGNALWIRE_RELAY_SCHEME / SIGNALWIRE_RELAY_HOST are set HERE, exactly + # once, inside the `@mu`-guarded one-time startup -- not per-client in + # build_sdk_client. Those two are the SDK's only redirect channel (no + # kwarg exists, client.rb:615/:625), so they must be process-global; what + # must not be global is the WRITE. Setting them per-client meant every + # `parallelize_me!` relay test re-wrote a process-global from its own + # thread on every client build. Writing them once, before any parallel + # suite starts, makes them read-only for the rest of the run. def start_harness @ws_port = resolve_port('MOCK_RELAY_PORT') @http_port = resolve_port('MOCK_RELAY_HTTP_PORT') @host = '127.0.0.1' @harness = Harness.new(host: @host, ws_port: @ws_port, http_port: @http_port) + ENV['SIGNALWIRE_RELAY_SCHEME'] = 'ws' + ENV['SIGNALWIRE_RELAY_HOST'] = @harness.relay_host return @harness if probe_health(@harness) @@ -507,10 +518,10 @@ def client(project: 'test_proj', token: 'test_tok', jwt_token: nil, { client: sdk_client, run_thread: run_thread, mock: mock } end - # Force the SDK to dial ws://host:ws_port (not wss://{space}) and build it. + # Build the SDK client. The ws:// redirect env is already in place from the + # one-time Lifecycle.start_harness (see the note there) -- this method makes + # no process-global writes, so it is safe to call from parallel threads. def build_sdk_client(harness, project, token, jwt_token, contexts) - ENV['SIGNALWIRE_RELAY_SCHEME'] = 'ws' - ENV['SIGNALWIRE_RELAY_HOST'] = harness.relay_host SignalWire::Relay::Client.new( project: project, token: token, jwt_token: jwt_token, space: harness.relay_host, contexts: contexts From 2dbcb14b2979917a93f159899abd054040193afb Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 12:29:05 -0400 Subject: [PATCH 73/90] fold(surface): PromptMixin.contexts is a rename, not an omission The `define_contexts` projection-table review (task #118) turned up a paired omission+addition that is really one accessor-spelling rename. FINDING 1 -- a retired omission. `PORT_SIGNATURE_OMISSIONS.md` excused `PromptMixin.contexts` as "Ruby exposes contexts via define_contexts/internal state, not a bare `contexts` accessor". Ruby DOES expose the read; it spells it `get_contexts`. Same value, same source, different accessor name -- textbook idiom, which Rule 2 folds at the enumerator. Added the rename to BOTH `SURFACE_METHOD_ALIASES` (enumerate_surface.rb) and `SIG_METHOD_ALIASES` (enumerate_signatures.py), keyed on PromptMixin only: the reference ALSO declares a real `get_contexts` on PromptManager, which Ruby matches by that name outright and must not be renamed. Verified both survive: PromptMixin.contexts and PromptManager.get_contexts are each present and distinct after the fold. The alias alone was inert -- `get_contexts` was not in the PromptMixin entry of `MIXIN_PROJECTIONS`, and the alias pass runs AFTER projection, so a name that never arrives can never be renamed. Added it to the projection list too. Excused signature divergences 1176 -> 1175. FINDING 2 -- a false rationale, corrected in place. `PORT_ADDITIONS.md`'s `agentbase-family.get_contexts` was justified "port-only". It is not port-only: the reference declares this read TWICE (PromptManager#get_contexts and the PromptMixin.contexts property). Tested by removal -- the entry is still load-bearing, because Ruby's mixin collapse puts a `get_contexts` on AgentBase that the reference's AgentBase does not carry -- so it stays, but re-stated with the accurate mixin-collapse reason its sibling entries already use, and scoped to the AgentBase-hosted twin. The `define_contexts` projection itself needed no change: the fill-not-clobber rule is correct and the two reference `define_contexts` genuinely differ (PromptManager required/void vs PromptMixin optional/union-return); ruby's port_signatures records both with the matching required/optional split. Both artifacts verified fresh by sha256 against a fresh regen, not by an empty git diff. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- PORT_ADDITIONS.md | 2 +- PORT_SIGNATURE_OMISSIONS.md | 1 - port_signatures.json | 9 +++++++++ port_surface.json | 2 +- scripts/enumerate_signatures.py | 15 +++++++++++++++ scripts/enumerate_surface.rb | 8 ++++++++ 6 files changed, 34 insertions(+), 3 deletions(-) diff --git a/PORT_ADDITIONS.md b/PORT_ADDITIONS.md index ee5fa2a5..0267a0c7 100644 --- a/PORT_ADDITIONS.md +++ b/PORT_ADDITIONS.md @@ -661,7 +661,7 @@ agentbase-family.default_webhook_url: port-only: Ruby attr_reader for the constr agentbase-family.extract_sip_username: port-only: mixin method collapsed onto SignalWire::AgentBase (Ruby single-inheritance + modules model replaces Python multiple inheritance) agentbase-family.extract_sip_username_from_request: port-only: mixin method collapsed onto SignalWire::AgentBase (Ruby single-inheritance + modules model replaces Python multiple inheritance) agentbase-family.full_url: ruby-idiom bare-noun reader (D9) over get_full_url; native `agent.full_url`, get_ name retained for parity -agentbase-family.get_contexts: port-only: Ruby getter for the contexts dictionary (Python parity: PromptManager#get_contexts via PromptMixin projection) +agentbase-family.get_contexts: port-only: mixin method collapsed onto SignalWire::AgentBase (Ruby single-inheritance + modules model replaces Python multiple inheritance). NOT a new capability: the reference declares the same read twice — `PromptManager#get_contexts` (Ruby matches by name) and the `PromptMixin.contexts` property (Ruby's `get_contexts` folds to it via SURFACE_METHOD_ALIASES/SIG_METHOD_ALIASES). Only the AgentBase-hosted twin, which the reference's AgentBase does not carry, is excused here. agentbase-family.get_raw_prompt: port-only: Ruby getter for the raw prompt text (Python parity: PromptManager#get_raw_prompt via PromptMixin projection) agentbase-family.handle_additional_route: port-only: Ruby's SWML::Service hosts the tool/web mixin surface + attr_readers + Rack helpers directly on the base service (Python splits these across ToolMixin/WebMixin/AgentBase; folded onto the base is the Ruby idiom) agentbase-family.list_tool_names: port-only: Ruby's SWML::Service hosts the tool/web mixin surface + attr_readers + Rack helpers directly on the base service (Python splits these across ToolMixin/WebMixin/AgentBase; folded onto the base is the Ruby idiom) diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 820c9258..06f2d395 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -165,7 +165,6 @@ signalwire.core.mixins.web_mixin.WebMixin.register_routing_callback: Ruby block # --- Reference accessors/properties hosted under a different Ruby idiom --- signalwire.agent_server.AgentServer.agents: Ruby AgentServer holds registered agents in an internal ivar (no public `agents` reader); Python exposes an `agents` property — surface-reconciled -signalwire.core.mixins.prompt_mixin.PromptMixin.contexts: Ruby exposes contexts via `define_contexts`/internal state, not a bare `contexts` accessor; Python property — surface-reconciled (PORT_ADDITIONS) signalwire.core.mixins.prompt_mixin.PromptMixin.set_prompt_pom: Ruby PromptMixin sets the POM via `prompt_add_section`/POM builder, not a `set_prompt_pom(pom)` setter — surface-reconciled (PORT_ADDITIONS) signalwire.core.mixins.tool_mixin.ToolMixin.define_tools: Ruby ToolMixin defines tools one at a time via `define_tool`; Python's plural `define_tools` batch helper folds into the singular — surface-reconciled signalwire.core.skill_manager.SkillManager.loaded_skills: Ruby exposes a single `list_loaded_skills` accessor (aliased from `loaded_keys`); Python has both `loaded_skills` (property) and `list_loaded_skills` — same list, one Ruby accessor diff --git a/port_signatures.json b/port_signatures.json index 0b881093..ac13e954 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -6315,6 +6315,15 @@ } ], "returns": "any" + }, + "contexts": { + "params": [ + { + "name": "self", + "kind": "self" + } + ], + "returns": "any" } } } diff --git a/port_surface.json b/port_surface.json index 45c74986..603ce2c8 100644 --- a/port_surface.json +++ b/port_surface.json @@ -1,5 +1,5 @@ { - "generated_from": "signalwire-ruby @ 8cf87e23f90643aceb889e984d9bc15572ddb8ee", + "generated_from": "signalwire-ruby @ 895087fb0358df325842c324fc267bb12f114bb1", "modules": { "signalwire": { "classes": {}, diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 8b444609..20783308 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -409,6 +409,16 @@ def _build_ref_method_index() -> dict: "handle_start": "start_questions", "handle_submit": "submit_answer", }, + # The reference exposes the context tree on PromptMixin as a bare + # ``contexts`` PROPERTY; Ruby spells the same read ``get_contexts``. Same + # value, same source, different accessor spelling -- idiom, so it folds here + # (Rule 2) rather than being carried as an omission. Keyed on PromptMixin + # only: the reference ALSO declares a real ``get_contexts`` on PromptManager, + # which Ruby matches by that name outright and must not be renamed. MIRRORS + # enumerate_surface.rb's SURFACE_METHOD_ALIASES entry. + ("signalwire.core.mixins.prompt_mixin", "PromptMixin"): { + "get_contexts": "contexts" + }, ("signalwire.core.skill_base", "SkillBase"): {"instance_key": "get_instance_key"}, ("signalwire.core.skill_manager", "SkillManager"): { "load": "load_skill", @@ -1087,6 +1097,11 @@ def apply(key: tuple, sig: dict) -> None: ], ("signalwire.core.mixins.prompt_mixin", "PromptMixin"): [ "define_contexts", + # Ruby's ``get_contexts`` is the reference's ``contexts`` PROPERTY under + # a different accessor spelling. Projected here so SIG_METHOD_ALIASES + # can rename it (the alias runs after projection; a name that never + # arrives can never be renamed). + "get_contexts", "get_post_prompt", "get_prompt", "prompt_add_section", diff --git a/scripts/enumerate_surface.rb b/scripts/enumerate_surface.rb index 7b27593c..ee4c2742 100755 --- a/scripts/enumerate_surface.rb +++ b/scripts/enumerate_surface.rb @@ -554,6 +554,14 @@ def load_oracle_all_members(python_surface_path) ['signalwire.core.swml_service', 'SWMLService'] => { 'method_missing' => '__getattr__' }, ['signalwire.core.swaig_function', 'SWAIGFunction'] => { 'call' => '__call__' }, ['signalwire.agents.bedrock', 'BedrockAgent'] => { 'inspect' => '__repr__' }, + # The reference exposes the context tree on PromptMixin as a bare `contexts` + # PROPERTY; Ruby spells the same read `get_contexts`. Same value, same source, + # different accessor spelling -- idiom, so it folds here (Rule 2) rather than + # being carried as a paired omission (`PromptMixin.contexts`) + addition + # (`agentbase-family.get_contexts`). Keyed on PromptMixin only: the reference + # ALSO declares a real `get_contexts` on PromptManager, which Ruby matches by + # that name outright and must not be renamed. + ['signalwire.core.mixins.prompt_mixin', 'PromptMixin'] => { 'get_contexts' => 'contexts' }, ['signalwire.core.skill_base', 'SkillBase'] => { 'instance_key' => 'get_instance_key' }, ['signalwire.core.skill_manager', 'SkillManager'] => { 'load' => 'load_skill', 'unload' => 'unload_skill', 'get' => 'get_skill', From eb7ea532432916101dbf81199b5738de2c16b0a1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 15:09:03 -0400 Subject: [PATCH 74/90] ledger(surface): delete 9 self-refuting "reference-oracle gap" omissions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit All nine entries assert a gap that the oracle does not have. Confirmed symbol-by-symbol with query_signatures.py against python_signatures.json: BedrockAgent.set_inference_params recorded (self, temperature?, top_p?, max_tokens?, ...) -> void BedrockAgent.set_llm_model recorded (self, model: string) -> void BedrockAgent.set_llm_temperature recorded (self, temperature: float) -> void BedrockAgent.set_post_prompt_llm_params recorded (self) -> void BedrockAgent.set_prompt_llm_params recorded (self) -> void BedrockAgent.set_voice recorded (self, voice_id: string) -> void ApiNinjasTriviaSkill.__init__ recorded (self, agent: AgentBase, params: optional>) -> void PlayBackgroundFileSkill.__init__ recorded (same) WeatherApiSkill.__init__ recorded (same) The three __init__ entries are stale copies of an already-fixed enumerator bug (EXCEPTION 2, enumerate_python_signatures.py) — the entries outlived their cause. The six BedrockAgent entries claim the oracle omits signalwire.agents.bedrock; it does not. Also drops the PORT_OMISSIONS.md category line "Bedrock (9 symbols under signalwire.agents.bedrock.*): omitted." — false prose, not an anchored entry (it excused nothing mechanically): the port DOES ship BedrockAgent and port_signatures.json records it in full. A/B with --omissions on both sides, compared as SETS: drift 7 -> 7 (no new, no gone) excused 1121 -> 1121 The excused count does not move because these entries were excusing NOTHING — the oracle records each symbol and the port implements each symbol, so there was never a divergence for them to cover. Pure dead paperwork. --- PORT_OMISSIONS.md | 1 - PORT_SIGNATURE_OMISSIONS.md | 9 --------- 2 files changed, 10 deletions(-) diff --git a/PORT_OMISSIONS.md b/PORT_OMISSIONS.md index 7a13aae6..5f4f880c 100644 --- a/PORT_OMISSIONS.md +++ b/PORT_OMISSIONS.md @@ -67,7 +67,6 @@ port surface; the diff tool will fail the build on unexcused drift. `signalwire.skills.web_search.skill_improved.*`, `signalwire.skills.web_search.skill_original.*`): vector search / indexing omitted per porting-sdk Phase 7 "What to Skip". -- **Bedrock** (9 symbols under `signalwire.agents.bedrock.*`): omitted. - **LiveKit shim** (~65 symbols under `signalwire.livewire.*`): deferred per PORTING_GUIDE.md "LiveKit Compatibility Shim" — added once core port stabilises. diff --git a/PORT_SIGNATURE_OMISSIONS.md b/PORT_SIGNATURE_OMISSIONS.md index 06f2d395..24c58254 100644 --- a/PORT_SIGNATURE_OMISSIONS.md +++ b/PORT_SIGNATURE_OMISSIONS.md @@ -172,17 +172,8 @@ signalwire.core.swml_service.SWMLService.security: Ruby SWMLService keeps securi signalwire.web.web_service.WebService.app: Ruby WebService wraps a Rack app via `rack_app`; Python exposes a Flask `.app` attribute — no direct equivalent (matches AgentServer.app / PORT_OMISSIONS) # --- Reference signature-oracle gaps (reference surface HAS the symbol) --- -signalwire.agents.bedrock.BedrockAgent.set_inference_params: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) -signalwire.agents.bedrock.BedrockAgent.set_llm_model: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) -signalwire.agents.bedrock.BedrockAgent.set_llm_temperature: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) -signalwire.agents.bedrock.BedrockAgent.set_post_prompt_llm_params: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) -signalwire.agents.bedrock.BedrockAgent.set_prompt_llm_params: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) -signalwire.agents.bedrock.BedrockAgent.set_voice: reference-oracle gap — the signature oracle omits `signalwire.agents.bedrock`, but the reference SURFACE records the full BedrockAgent surface and the port implements it (SURFACE-DIFF PASS) signalwire.core.agent_base.AgentBase.handle_request: reference-oracle gap — the reference SURFACE records AgentBase.handle_request (the AgentBase override of the decomposed dispatch core) and the port implements it, but the signature oracle enumerates handle_request only on SWMLService, not the AgentBase override (SURFACE-DIFF PASS). Same signature as SWMLService.handle_request(method, url, headers, body) -> [status, headers, body_string], rendering agent SWML. signalwire.core.swml_handler.AIVerbHandler.validate_config: reference-oracle gap — the reference surface records AIVerbHandler.validate_config but the signature oracle omits it (SURFACE-DIFF PASS) -signalwire.skills.api_ninjas_trivia.skill.ApiNinjasTriviaSkill.__init__: reference-oracle gap — the reference surface records this skill class but the signature oracle omits its `__init__` (SURFACE-DIFF PASS) -signalwire.skills.play_background_file.skill.PlayBackgroundFileSkill.__init__: reference-oracle gap — the reference surface records this skill class but the signature oracle omits its `__init__` (SURFACE-DIFF PASS) -signalwire.skills.weather_api.skill.WeatherApiSkill.__init__: reference-oracle gap — the reference surface records this skill class but the signature oracle omits its `__init__` (SURFACE-DIFF PASS) # --- True Ruby-only additions (absent from reference surface too) --- signalwire.core.swaig_function.SWAIGFunction.call: reference-oracle gap — port `call` is Ruby's callable primitive (surface reconciles it to `__call__`, which the reference surface records but the signature oracle omits) (SURFACE-DIFF PASS) From fc8732098f8fe1192b8a4e31ef99445e780e31ab Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 15:10:56 -0400 Subject: [PATCH 75/90] fold(enumerator): mirror the skills instance_key alias into the signature side MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit porting-sdk 8496c77 took the signature oracle from 7 of 18 skill modules to 18 of 18 (a per-method skip emptied classes whose every method was a base-identical override, and an emptied class was dropped outright). The newly-visible modules declare a `get_instance_key` OVERRIDE, and ruby drifted on 7 of them. Root cause: enumerate_surface.rb has carried SKILLS_MODULE_METHOD_ALIASES (`instance_key` -> `get_instance_key`, applied by module prefix) since it was written, but enumerate_signatures.py only ever had the single explicit SIG_METHOD_ALIASES row for `SkillBase`. That sufficed while none of the 7 visible skill modules declared an override. It stopped sufficing the moment all 18 were enumerated, and each un-renamed override drifted twice: a missing-port for the reference name plus a missing-reference for the Ruby one. ruby ships every one of these overrides at source (lib/signalwire/skills/builtin/{claude_skills,datasphere,datasphere_serverless, info_gatherer,native_vector_search,swml_transfer,web_search}.rb) — this was a projection gap, never absent code. Fixed by mirroring the by-prefix rule into the signature enumerator, so the two audits reconcile the SAME rename. A/B with --omissions on both sides, compared as SETS: drift 7 -> 0 all 7 get_instance_key findings gone, none new excused 1121 -> 1114 The excused drop is 10 stale `.instance_key` missing-reference entries retiring, minus 3 that reappear under the reference name (see below). RESIDUAL — an oracle hole 8496c77 did not close. Three classes are enumerated but still under-enumerated: the oracle records only ApiNinjasTriviaSkill -> [__init__, get_tools] PlayBackgroundFileSkill -> [__init__, get_tools] SpiderSkill -> [__init__, remove_xpaths] while the reference source declares get_instance_key on each (signalwire/skills/api_ninjas_trivia/skill.py:146, play_background_file/skill.py:138, spider/skill.py:201), along with setup / register_tools. Ruby's overrides for these three therefore project to `get_instance_key` and land as excused missing-reference additions carrying the now-inaccurate "port-side state accessor (no Python counterpart)" rationale. Not a ruby defect and not fixable from this repo — flagged for the oracle. Deliberately NOT re-excused. No omission or allow-list entry added. --- port_signatures.json | 104 ++++++++++++++++---------------- scripts/enumerate_signatures.py | 47 +++++++++++++-- 2 files changed, 94 insertions(+), 57 deletions(-) diff --git a/port_signatures.json b/port_signatures.json index ac13e954..30f76583 100644 --- a/port_signatures.json +++ b/port_signatures.json @@ -37993,7 +37993,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38002,7 +38002,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38011,7 +38011,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38020,7 +38020,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38029,7 +38029,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -38153,7 +38153,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38162,7 +38162,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38171,7 +38171,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38180,7 +38180,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38189,7 +38189,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -38260,7 +38260,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38269,7 +38269,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38278,7 +38278,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38287,7 +38287,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38296,7 +38296,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -38358,7 +38358,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38367,7 +38367,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38376,7 +38376,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38385,7 +38385,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38394,7 +38394,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -38589,7 +38589,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38598,7 +38598,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38607,7 +38607,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38616,7 +38616,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38625,7 +38625,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -38909,7 +38909,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -38918,7 +38918,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -38927,7 +38927,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -38936,7 +38936,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -38945,7 +38945,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -39010,7 +39010,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -39019,7 +39019,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -39028,7 +39028,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -39037,7 +39037,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -39046,7 +39046,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -39293,7 +39293,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -39302,7 +39302,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -39311,7 +39311,7 @@ ], "returns": "any" }, - "register_tools": { + "remove_xpaths": { "params": [ { "name": "self", @@ -39320,7 +39320,7 @@ ], "returns": "any" }, - "remove_xpaths": { + "setup": { "params": [ { "name": "self", @@ -39329,7 +39329,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -39338,7 +39338,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -39391,7 +39391,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -39400,7 +39400,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -39409,7 +39409,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -39418,7 +39418,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -39427,7 +39427,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "get_instance_key": { "params": [ { "name": "self", @@ -39572,7 +39572,7 @@ ], "returns": "any" }, - "instance_key": { + "name": { "params": [ { "name": "self", @@ -39581,7 +39581,7 @@ ], "returns": "any" }, - "name": { + "register_tools": { "params": [ { "name": "self", @@ -39590,7 +39590,7 @@ ], "returns": "any" }, - "register_tools": { + "setup": { "params": [ { "name": "self", @@ -39599,7 +39599,7 @@ ], "returns": "any" }, - "setup": { + "supports_multiple_instances": { "params": [ { "name": "self", @@ -39608,7 +39608,7 @@ ], "returns": "any" }, - "supports_multiple_instances": { + "version": { "params": [ { "name": "self", @@ -39617,7 +39617,7 @@ ], "returns": "any" }, - "version": { + "get_instance_key": { "params": [ { "name": "self", diff --git a/scripts/enumerate_signatures.py b/scripts/enumerate_signatures.py index 20783308..d474468c 100644 --- a/scripts/enumerate_signatures.py +++ b/scripts/enumerate_signatures.py @@ -439,12 +439,49 @@ def _build_ref_method_index() -> dict: } +# Built-in skill classes rename their Ruby ``instance_key`` OVERRIDE to the +# reference's ``get_instance_key`` — the same rename SIG_METHOD_ALIASES already +# does for the SkillBase declaration, applied by MODULE PREFIX so each per-skill +# override compares equal without one table row per skill. MIRRORS +# enumerate_surface.rb's SKILLS_MODULE_METHOD_ALIASES, which has always applied +# it surface-side. +# +# Why this was invisible until now: before porting-sdk 8496c77 the signature +# oracle enumerated only 7 of 18 skill modules (a per-method skip emptied classes +# whose every method was a base-identical override, and an emptied class was +# dropped outright). None of the 7 declared an override, so the base-only rename +# sufficed. With all 18 modules enumerated the oracle records the override on 7 +# skill subclasses, and the un-renamed Ruby ``instance_key`` drifted twice per +# class (missing-port for the reference name + missing-reference for the Ruby +# one). +SIG_SKILLS_MODULE_METHOD_ALIASES: dict[str, str] = {"instance_key": "get_instance_key"} + + +def _sig_aliases_for(mod: str, cls: str) -> dict[str, str]: + """The effective Ruby->reference method aliases for one class: the explicit + per-[module, class] table, plus the by-prefix skills alias on every + ``signalwire.skills.*.skill`` module.""" + table = dict(SIG_METHOD_ALIASES.get((mod, cls), {})) + if mod.startswith("signalwire.skills.") and mod.endswith(".skill"): + merged = dict(SIG_SKILLS_MODULE_METHOD_ALIASES) + merged.update(table) + return merged + return table + + def apply_sig_method_aliases(out_modules: dict) -> None: - """Rename Ruby-idiom methods to their reference name (see SIG_METHOD_ALIASES). - Only fires when the port has the Ruby-named method and does NOT already carry - the reference name (so it never clobbers a real reference-named method). In - place.""" - for (mod, cls), aliases in SIG_METHOD_ALIASES.items(): + """Rename Ruby-idiom methods to their reference name (see SIG_METHOD_ALIASES + and SIG_SKILLS_MODULE_METHOD_ALIASES). Only fires when the port has the + Ruby-named method and does NOT already carry the reference name (so it never + clobbers a real reference-named method). In place.""" + keys = set(SIG_METHOD_ALIASES) + for mod, me in out_modules.items(): + for cls in me.get("classes", {}): + keys.add((mod, cls)) + for mod, cls in keys: + aliases = _sig_aliases_for(mod, cls) + if not aliases: + continue ce = out_modules.get(mod, {}).get("classes", {}).get(cls) if not ce: continue From ada5e3e1230a7c2e1d5c2371c10a0a964cc688b7 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 15:14:49 -0400 Subject: [PATCH 76/90] test(tls): prove an https/wss client never silently downgrades to cleartext MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit #90's failure that matters is a client the user configured for TLS quietly sending the request in the clear — encryption asked for, not delivered, never reported. tests/tls already proved verified HTTPS + verified WSS and rejected untrusted peers, but nothing covered the downgrade. Three probes, all driving the REAL clients: 1. BEHAVIOURAL — a REST client with an https:// base_url pointed at a plain TCP listener that answers a valid HTTP 200. The listener captures the raw opening bytes, so a downgrade is caught as CLEARTEXT ON THE WIRE, not just as a missing exception. Observed: first byte 0x16 (TLS ClientHello), and SignalWireRestTransportError "SSL_connect ... wrong version number". No cleartext request line ever reaches the socket. Negative-controlled: patching build_http to skip configure_ssl (the exact silent-downgrade shape) turns this test RED ("SignalWireRestError expected but nothing was raised") and the listener sees the plaintext GET. Reverted. 2. REST default scheme is https:// for an ordinary space (no base_url, no env override) — TLS is the default, not an opt-in. 3. RELAY default scheme is wss:// with SIGNALWIRE_RELAY_SCHEME unset. Findings from the wider audit, no code change needed: * Certificate verification is on by default on every transport. REST configure_ssl hardcodes VERIFY_PEER with no VERIFY_NONE path; RELAY wss_tls_options forces VERIFY_PEER with a store seeded from the OpenSSL defaults (websocket-client-simple otherwise leaves a fresh SSLContext at VERIFY_NONE). * The skill/ai_chat transports (spider, datasphere, native_vector_search, web_search, google_maps, ai_chat) set use_ssl and leave verify_mode unset. Verified behaviourally against a live self-signed TLS listener that this is NOT a hole: Net::HTTP with verify_mode nil rejects it — "certificate verify failed (self-signed certificate)". * The one VERIFY_NONE in the tree (mcp_gateway) is an explicit operator opt-out, `verify_ssl` defaulting to true, at exact parity with the reference (signalwire/skills/mcp_gateway/skill.py:146 `self.params.get("verify_ssl", True)`). Not a divergence. * SIGNALWIRE_REST_CA_FILE and SIGNALWIRE_RELAY_CA_FILE both work and are already covered live by tests/tls (13 runs, 0 skips). ruby is clean on #90. --- tests/tls/tls_no_downgrade_test.rb | 146 +++++++++++++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 tests/tls/tls_no_downgrade_test.rb diff --git a/tests/tls/tls_no_downgrade_test.rb b/tests/tls/tls_no_downgrade_test.rb new file mode 100644 index 00000000..57e7eb59 --- /dev/null +++ b/tests/tls/tls_no_downgrade_test.rb @@ -0,0 +1,146 @@ +# frozen_string_literal: true + +# TLS capability test: an https:// / wss:// client NEVER silently falls back to +# cleartext. +# +# The three existing tests/tls tests prove the SDK completes a verified HTTPS +# request and a verified WSS handshake, and that an untrusted client is +# rejected. They do NOT cover the failure this test exists for: a client the +# user configured for TLS that quietly sends the request in the clear. The user +# asked for encryption, did not get it, and was never told. +# +# Three independent probes, all driving the REAL clients against a REAL socket: +# +# 1. REST, https:// -> plain-HTTP listener. The client must RAISE. If it +# downgraded, the listener would receive a readable "GET /... HTTP/1.1" +# request line and the client would get a 200 back. The listener records +# what it actually received, so a downgrade is caught as CLEARTEXT ON THE +# WIRE, not merely as a missing exception. +# 2. REST default scheme. A client constructed with a real space name (no +# base_url, no env override) must address https://, so the ordinary +# no-configuration path is encrypted. +# 3. RELAY default scheme. Same question for the WebSocket transport: +# SIGNALWIRE_RELAY_SCHEME unset must resolve to wss://, not ws://. +# +# Probe 1 is the load-bearing one and is behavioural end-to-end; 2 and 3 close +# the "the secure thing is the default" half. + +require 'minitest/autorun' +require 'socket' +require 'timeout' +require_relative '../../lib/signalwire/rest/rest_client' +require_relative '../../lib/signalwire/relay/client' + +class TlsNoDowngradeTest < Minitest::Test + # A one-shot plain-HTTP listener. Accepts a single connection, reads whatever + # bytes arrive, answers 200 with a JSON body, and records the raw first bytes + # so the test can tell a TLS ClientHello from a cleartext request line. + class PlainHttpProbe + attr_reader :thread + + def initialize + @server = TCPServer.new('127.0.0.1', 0) + @mutex = Mutex.new + @seen = nil + @thread = Thread.new { accept_one } + end + + def port = @server.addr[1] + + def seen + @mutex.synchronize { @seen } + end + + def close + @thread.kill + @thread.join(2) + @server.close unless @server.closed? + end + + private + + # Accept one connection, capture the opening bytes, and reply with a valid + # plain-HTTP 200 so a downgraded client would SUCCEED (making the downgrade + # unmistakable rather than an ambiguous connection error). + def accept_one + sock = @server.accept + first = read_opening_bytes(sock) + @mutex.synchronize { @seen = first } + body = '{"data":[]}' + sock.write("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n" \ + "Content-Length: #{body.bytesize}\r\n\r\n#{body}") + sock.close + rescue StandardError + nil + end + + # Read up to 512 bytes with a short deadline. A TLS client sends a binary + # ClientHello (first byte 0x16); a cleartext HTTP client sends "GET ...". + def read_opening_bytes(sock) + Timeout.timeout(3) { sock.readpartial(512) } + rescue StandardError + nil + end + end + + def setup + @probe = PlainHttpProbe.new + end + + def teardown + @probe&.close + end + + # PROBE 1 (behavioural): a REST client configured with an https:// base_url + # pointed at a PLAIN-HTTP listener must fail. It must not retry in the clear, + # and no cleartext HTTP request line may reach the socket. + def test_https_rest_client_never_downgrades_to_cleartext + client = SignalWire::REST::RestClient.new( + project: 'test_proj', token: 'test_tok', + base_url: "https://127.0.0.1:#{@probe.port}" + ) + + assert_raises(SignalWire::REST::SignalWireRestError) { client.addresses.list } + _assert_no_cleartext_request + end + + # The listener must never have seen a readable HTTP request line. Either it + # saw nothing (handshake aborted) or it saw a TLS record (0x16 = handshake). + def _assert_no_cleartext_request + seen = @probe.seen + return if seen.nil? || seen.empty? + + refute_match(/\A(GET|POST|PUT|PATCH|DELETE) /, seen, + 'SILENT DOWNGRADE: an https:// REST client sent a CLEARTEXT HTTP ' \ + "request to a plain listener. First bytes: #{seen[0, 64].inspect}") + assert_equal 0x16, seen.bytes.first, + 'expected a TLS ClientHello (0x16) on the wire from an https:// client; ' \ + "got: #{seen[0, 16].inspect}" + end + + # PROBE 2: with no base_url and no env override, an ordinary space name must + # resolve to https:// — TLS is the DEFAULT, not an opt-in. + def test_rest_default_scheme_is_https + saved = ENV.fetch('SIGNALWIRE_REST_BASE_URL', nil) + ENV.delete('SIGNALWIRE_REST_BASE_URL') + http = SignalWire::REST::HttpClient.new('p', 't', 'acme') + + assert_match(%r{\Ahttps://}, http.inspect[/base_url="([^"]+)"/, 1], + 'REST client defaulted to a non-TLS scheme for a normal space') + ensure + saved.nil? ? ENV.delete('SIGNALWIRE_REST_BASE_URL') : ENV['SIGNALWIRE_REST_BASE_URL'] = saved + end + + # PROBE 3: with SIGNALWIRE_RELAY_SCHEME unset, the RELAY transport must + # resolve to wss:// — the WebSocket default is encrypted too. + def test_relay_default_scheme_is_wss + saved = ENV.fetch('SIGNALWIRE_RELAY_SCHEME', nil) + ENV.delete('SIGNALWIRE_RELAY_SCHEME') + client = SignalWire::Relay::Client.new(project: 'p', token: 't', space: 'acme.signalwire.com') + + assert_equal 'wss', client.send(:relay_scheme), + 'RELAY client defaulted to a non-TLS scheme' + ensure + saved.nil? ? ENV.delete('SIGNALWIRE_RELAY_SCHEME') : ENV['SIGNALWIRE_RELAY_SCHEME'] = saved + end +end From 01c0c7c47a8b538462470fca7e5ed5233376db4e Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Thu, 30 Jul 2026 19:23:27 -0400 Subject: [PATCH 77/90] fold(enumerators): gate the skill-hook surface on the LIVE oracle, both axes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Re-drift against porting-sdk oracle 0e0f935. SURFACE-DIFF was red with 11 findings; the cause is in the reference, not the port. signalwire-python e9aa402 made `SkillBase.get_prompt_sections()` a FINAL template method that applies the `skip_prompt` guard and delegates to a PROTECTED `_get_prompt_sections()` hook (core/skill_base.py:89-96). 13 skills now override the protected hook, so the oracle records the PUBLIC member on the BASE ONLY. Ruby still overrides the public method on 12 skill classes, and a reflective dump reports each override as new public surface — 10 phantom `missing-reference` additions plus 1 omission gone dead. An override of a base member is INHERITANCE, not new surface: the capability is already published by the base the reference records it on. So both enumerators now ask the LIVE oracle rather than trusting a projection: on a `signalwire.skills.*.skill` class, drop a member the oracle records on `SkillBase` but NOT on that subclass. Self-correcting in both directions — the oracle dropping a member folds the port's override with no hand edit, and the oracle STARTING to record it on a subclass stands the fold down, because the rule tests the subclass and not just the base. `__init__` is exempt (construction shape is recorded per class, never inherited). MIRROR GAP, same shape as the `instance_key` alias last turn: the rule had to go in BOTH enumerators. The two project the SAME Ruby skill classes onto the SAME reference modules, so a projection rule on one side leaves the other reporting the same method as un-folded. The signature axis was green only by ACCIDENT and had to be fixed too: `get_prompt_sections` is a zero-arg reader, so diff_port_signatures.py swept all 12 into `excused` under the `port-side state accessor (no Python counterpart)` leniency — a rule about ports exposing state as properties, unrelated to a template method. The divergence was real and simply invisible on that axis. THE TWO ORACLES ARE NOT INTERCHANGEABLE. `python_signatures.json` deliberately SKIPS a subclass override whose signature is identical to the base's, so asking IT "does the subclass record this?" answers no for EVERY base-identical override. Measured: gating the signature side on the signature oracle folded 33 members instead of 12 — it would have deleted setup / register_tools / get_instance_key / get_parameter_schema / cleanup / get_hints from ApiNinjasTrivia, PlayBackgroundFile, Spider, WeatherApi and WikipediaSearch, all genuinely implemented and genuinely declared. That is a capability deletion, not a fold. Both sides now read `python_surface.json`, which records what each class DECLARES — the question the fold actually asks. enumerate_signatures.py gains that oracle as a second hard dependency, fail-loud on absence like the first. DEAD ENTRIES DELETED (required, not optional) — zero entries added: PORT_OMISSIONS.md NativeVectorSearchSkill.get_prompt_sections (absent from python_surface.json; excused nothing. The other NativeVectorSearch entries stay — `cleanup` and `get_global_data` are still recorded, and the Python-only ruling (§I.1) is untouched.) PORT_ADDITIONS.md ClaudeSkillsSkill.get_prompt_sections InfoGathererSkill.get_prompt_sections (both went dead the moment the fold stopped emitting them; the gate reports a dead addition as an error.) Measured, --omissions + --surface-omissions + --surface-additions on both sides: surface drift 11 -> 0 (10 additions + 1 dead omission) signature drift 0 -> 0 excused (sig) 1099 -> 1087 SET delta: 0 OPENED, 12 CLOSED, every one a `.get_prompt_sections` missing-reference. Absorbed nothing. PORT_OMISSIONS -1, PORT_ADDITIONS -2, PORT_SIGNATURE_OMISSIONS unchanged. Both enumerators fold exactly 12 members, matching member for member. Negative controls, both enumerators: - Perturb the oracle to record `get_prompt_sections` on JokeSkill again: both enumerators re-emit it on JokeSkill and ONLY JokeSkill (MathSkill and the other 10 stay folded). The gate is oracle-driven, not name-driven. - Empty the oracle's SkillBase member list: the fold stands down entirely and every skill class matches its pre-fold surface byte for byte — the fail-safe never emits a mass deletion when the oracle cannot be resolved. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01TSHZoWoxoPVK6FuNaNKWFh --- PORT_ADDITIONS.md | 2 - PORT_OMISSIONS.md | 1 - port_signatures.json | 108 -------------------------------- port_surface.json | 14 +---- scripts/enumerate_signatures.py | 98 +++++++++++++++++++++++++++++ scripts/enumerate_surface.rb | 69 +++++++++++++++++++- 6 files changed, 165 insertions(+), 127 deletions(-) diff --git a/PORT_ADDITIONS.md b/PORT_ADDITIONS.md index 0267a0c7..d07b3ba3 100644 --- a/PORT_ADDITIONS.md +++ b/PORT_ADDITIONS.md @@ -390,7 +390,6 @@ signalwire.skills.builtin.custom_skills_skill.CustomSkillsSkill.register_tools: signalwire.skills.builtin.custom_skills_skill.CustomSkillsSkill.setup: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.builtin.custom_skills_skill.CustomSkillsSkill.supports_multiple_instances?: port-only: Ruby predicate method (? suffix) signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.description: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) -signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.get_prompt_sections: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.name: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.supports_multiple_instances?: port-only: Ruby predicate method (? suffix) signalwire.skills.datasphere.skill.DataSphereSkill.description: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) @@ -404,7 +403,6 @@ signalwire.skills.datetime.skill.DateTimeSkill.name: port-only: Ruby attr_reader signalwire.skills.google_maps.skill.GoogleMapsSkill.description: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.google_maps.skill.GoogleMapsSkill.name: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.info_gatherer.skill.InfoGathererSkill.description: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) -signalwire.skills.info_gatherer.skill.InfoGathererSkill.get_prompt_sections: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.info_gatherer.skill.InfoGathererSkill.name: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) signalwire.skills.info_gatherer.skill.InfoGathererSkill.supports_multiple_instances?: port-only: Ruby predicate method (? suffix) signalwire.skills.joke.skill.JokeSkill.description: port-only: Ruby attr_reader on skill (matches Python __init__ stored attribute) diff --git a/PORT_OMISSIONS.md b/PORT_OMISSIONS.md index 5f4f880c..2ca81d99 100644 --- a/PORT_OMISSIONS.md +++ b/PORT_OMISSIONS.md @@ -129,7 +129,6 @@ signalwire.relay.client.RelayClient.relay_protocol: impossible: Python property signalwire.relay.message.Message.__repr__: impossible: Python object-repr dunder; Ruby provides the equivalent via the shared MessageSerialization module's inspect/to_s, but the __repr__ NAME itself has no standalone Ruby form (mirrors Call.__repr__; TS/PHP omit identically) signalwire.skills.native_vector_search.skill.NativeVectorSearchSkill.cleanup: approved: Python-only RAG/vector-search subsystem, not ported to any SDK — user, 2026-07 pass (§I.1) signalwire.skills.native_vector_search.skill.NativeVectorSearchSkill.get_global_data: approved: Python-only RAG/vector-search subsystem, not ported to any SDK — user, 2026-07 pass (§I.1) -signalwire.skills.native_vector_search.skill.NativeVectorSearchSkill.get_prompt_sections: approved: Python-only RAG/vector-search subsystem, not ported to any SDK — user, 2026-07 pass (§I.1) signalwire.skills.registry.SkillRegistry.get_skill_class: Ruby SignalWire::Skills::SkillRegistry#get_factory returns class-or-factory - different name