pinecall 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0571abe150af681966473dd3a8e8123137743bbecf63d6c4144632f986eb304a
-  data.tar.gz: 55c632d74f2440250049ecc84bad96d611b7d270cea5130d01154674b84761ad
+  metadata.gz: f33416ca47b6dac53cbee96b457cd9d8961c27439b7f5568834ca64c561c5e89
+  data.tar.gz: deaf2b2a704a6dbda1a8b88f21f46fabb327ee7dc22eab9f858cf2e5dca7d694
 SHA512:
-  metadata.gz: c476476012157ce39d48b2e1b07ccd33c5533d217ff2d33037e423d05b48a49986e556638fbca2410890c739aeb00b13da0076415e1c2f62c6a8f1a0452a239e
-  data.tar.gz: d42a9901721b9e179fbddd3ffba1b2c4ff1805c3abceaaafe4b5d77aecf0990dc1265685e762164cdbad4d11b3a4b77a20f6bba5ceeab06ccd5b95cc8ee7445e
+  metadata.gz: 671735c18ef00423d7e4c7a1fbefbd87c0f5087b23a0d9fa556bc151a19df928fa0c7bbebcb9977858bdf3cb54645a7d570d0e3e0fe6ad5bb5fb8977575d45ea
+  data.tar.gz: 5ed8532ef612a31608e11e70016045e8da92d35dcfe078e6dd976680e729695b4e8b6eee2448cb4567991592294fe67cb4519ad53ed05bbf27878c81ed1d66e0

data/CHANGELOG.md

@@ -6,6 +6,23 @@ version number is the human's call.
 
 ## [Unreleased]
 
+## [0.0.7] — Every judge is a model's answer, and the class names the judge's model (2026-10-10)
+
+- `judge "<vendor>/<model>", builds:, options:`: the model the agent's calls are judged on, over
+  the org's choice and Pinecall's. On a key of the org's own — a local model through
+  `options: { base_url: "…" }` among them — its evals are never billed.
+- The wire reads what the runtime now writes: a judge's `na` and `classified` answers with their
+  `choice` or `score`, `call.score`'s `evals` and `own_key`, and `call.summary`'s `simulated`.
+
+## [0.0.6] — A greeting is words or :improvise, a hangup is words or true, and the ears choose who ends the turn (2026-10-10)
+
+- `greeting "…"` (said as written), `greeting :improvise` (the model opens on its prompt) and
+  `greeting improvise("…")` (with an instruction); `interruptible: true` for an opening the caller
+  may cut short, which by default they cannot. The `say:` / `reply:` keywords are gone.
+- `hangup "…"` (when, in your words) or `hangup true` (whenever the model judges); `when:` is gone.
+- `stt "…", end_of_turn: :stt | :livekit | :smart_turn`: who says the caller's turn is over, as
+  @pinecall/agents 0.9.26 says it. Needs runtime 0.1.43.
+
 ## [0.0.5] — The class declares its voice, its models and the rest, and wins (2026-10-10)
 
 - **A class declares its environment again, and it wins over the settings.** Class macros `voice

data/lib/pinecall/agent/config.rb

@@ -13,15 +13,41 @@ module Pinecall
       AS_WRITTEN = %i[phone whatsapp web channel_rules].freeze
 
       # The settings a class may declare. Must match the TypeScript package's `ENVIRONMENT`.
-      ENVIRONMENT = %i[language voice llm stt greeting hangup turn says hears knowledge docs memory record].freeze
+      ENVIRONMENT = %i[language voice llm stt judge greeting hangup turn says hears knowledge docs memory record].freeze
 
       # The ones written as the wire's own fields, keyword by keyword: `greeting say: "…"`.
-      AS_KEYWORDS = %i[greeting hangup turn knowledge docs memory].freeze
+      AS_KEYWORDS = %i[turn knowledge docs memory].freeze
 
       NO_VOICE = "a voice the class declares names its vendor and the voice: voice \"<vendor>\", \"<voice id>\""
 
+      NO_OPENING = "a greeting is the words, as a string, or :improvise for the model's own: improvise(\"…\") gives it an instruction"
+      NO_ENDING = "hangup is when the model may end the call, in your words, or true whenever it judges the call done"
+
+      # The model opens the call: on its prompt alone (an empty instruction), or with this one.
+      Improvised = Data.define(:instruction, :interruptible)
+
       NOTHING = Object.new.freeze
 
+      # An opening as the wire says it: words to `say`, or a `reply` the model opens on.
+      def self.greeting_of(opening, interruptible)
+        said = case opening
+               when :improvise then { reply: "" }
+               when Improvised then { reply: opening.instruction }
+               when String then { say: opening }
+               else raise DeclarationRefused, NO_OPENING
+               end
+        given = opening.is_a?(Improvised) ? opening.interruptible : interruptible
+        given.nil? ? said : { **said, allow_interruptions: given }
+      end
+
+      # When the model may end the call: an empty `when` is whenever it judges.
+      def self.hangup_of(ending)
+        return { when: "" } if ending == true
+        raise DeclarationRefused, NO_ENDING unless ending.is_a?(String) && !ending.strip.empty?
+
+        { when: ending }
+      end
+
       # `vendor/model`, or a vendor alone; the model id keeps every slash after the vendor's.
       def self.model_of(named)
         provider, _slash, model = named.to_s.partition("/")
@@ -55,11 +81,41 @@ module Pinecall
           environment[:llm] = { **Config.model_of(model), temperature:, builds:, options: }.compact
         end
 
-        # The ears, `vendor/model` or a vendor alone.
-        def stt(model = NOTHING, builds: nil, options: nil)
+        # The ears, `vendor/model` or a vendor alone, and who says the caller's turn is over:
+        # `end_of_turn: "stt"` the ears themselves (Deepgram Flux), `"livekit"` or `"smart-turn"`.
+        def stt(model = NOTHING, builds: nil, options: nil, end_of_turn: nil)
           return environment[:stt] if model.equal?(NOTHING)
 
-          environment[:stt] = { **Config.model_of(model), builds:, options: }.compact
+          ends = end_of_turn&.to_s&.tr("_", "-")
+          environment[:stt] = { **Config.model_of(model), builds:, options:, end_of_turn: ends }.compact
+        end
+
+        # The model the agent's calls are judged on, over the org's choice and the platform's:
+        # `judge "openai/qwen3-32b", options: { base_url: "http://gpu:8000/v1" }`. On a key of the
+        # org's own, a local model's server among them, its evals are never billed; `builds` and
+        # `options` run on the org's own key alone.
+        def judge(model = NOTHING, builds: nil, options: nil)
+          return environment[:judge] if model.equal?(NOTHING)
+
+          environment[:judge] = { **Config.model_of(model), builds:, options: }.compact
+        end
+
+        # How a call opens: the words, said as written, or :improvise for the model's own. The
+        # caller cannot cut it short unless `interruptible: true`.
+        def greeting(opening = NOTHING, interruptible: nil)
+          return environment[:greeting] if opening.equal?(NOTHING)
+
+          environment[:greeting] = Config.greeting_of(opening, interruptible)
+        end
+
+        # The model opens the call with this instruction: `greeting improvise("…")`.
+        def improvise(instruction = "", interruptible: nil) = Improvised.new(instruction, interruptible)
+
+        # When the model may end the call: in your words, or `true` whenever it judges it done.
+        def hangup(ending = NOTHING)
+          return environment[:hangup] if ending.equal?(NOTHING)
+
+          environment[:hangup] = Config.hangup_of(ending)
         end
 
         # `language "es"`, `says [{ word: "GSA", spoken: "ge ese a" }]`, `record false`.
@@ -78,8 +134,8 @@ module Pinecall
           environment[:hears] = words.flatten
         end
 
-        # `greeting say: "…"`, `hangup when: "…"`, `turn endpointing_ms: 300`, `docs base: "…", k: 4`,
-        # `memory remember: […], forget: […]`, `knowledge path: "…", text: "…"`.
+        # `turn endpointing_ms: 300`, `docs base: "…", k: 4`, `memory remember: […], forget: […]`,
+        # `knowledge path: "…", text: "…"`.
         AS_KEYWORDS.each do |field|
           define_method(field) do |**given|
             return environment[field] if given.empty?

data/lib/pinecall/version.rb

@@ -2,5 +2,5 @@
 
 module Pinecall
   # Set by the maintainer at release time.
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/pinecall/wire/enums.rb

@@ -34,9 +34,10 @@ module Pinecall
       # Whose action ended the call. platform covers timeouts, errors and a drained worker.
       ENDED_BY = %w[caller agent supervisor platform].freeze
       # What one judge answered about a finished call. Held: the rule held. Broken: it did not,
-      # and the reason names the evidence. Deferred: the judge was asked and could not settle it.
-      # Skipped: nobody asked it — no model was reachable inside the call's judging budget.
-      SCORE_VERDICT = %w[held broken deferred skipped].freeze
+      # and the reason names the evidence. Classified: a choice or a score was answered. N/A: the
+      # question did not apply. Deferred: the judge was asked and could not settle it. Skipped:
+      # nobody asked it — no model, the ceiling reached, or the org's evals used up.
+      SCORE_VERDICT = %w[held broken classified na deferred skipped].freeze
       # Cold: the caller is sent on with a REFER on their SIP leg and the call ends here. Warm:
       # the number is dialled into the call's own room, the agent stays on the line until the
       # other side answers and then falls silent; the call ends when either of them hangs up.

data/lib/pinecall/wire/shapes_call_events.rb

@@ -81,6 +81,8 @@ module Pinecall
           judges: { kind: :list, items: { kind: :ref, ref: "Judgment" }, required: true },
           panel: { kind: :list, items: { kind: :str } },
           judge_calls: { kind: :int, required: true },
+          evals: { kind: :int },
+          own_key: { kind: :bool },
           judge_cost_usd: { kind: :float },
           judged_by: { kind: :ref, ref: "JudgedBy" }
         }.freeze,
@@ -108,7 +110,8 @@ module Pinecall
           turns: { kind: :int, required: true },
           usage: { kind: :list, items: { kind: :ref, ref: "ModelUsage" }, required: true },
           cost: { kind: :ref, ref: "Cost", required: true },
-          recording: { kind: :str }
+          recording: { kind: :str },
+          simulated: { kind: :bool }
         }.freeze,
         "CallTransferred" => {
           to: { kind: :str, required: true },

data/lib/pinecall/wire/shapes_config.rb

@@ -23,7 +23,8 @@ module Pinecall
           model: { kind: :str, required: true },
           temperature: { kind: :float },
           builds: { kind: :str },
-          options: { kind: :json }
+          options: { kind: :json },
+          end_of_turn: { kind: :enum, values: %w[stt livekit smart-turn] }
         }.freeze,
         "TurnConfig" => {
           min_interruption_words: { kind: :int },

data/lib/pinecall/wire/shapes_doors.rb

@@ -23,6 +23,7 @@ module Pinecall
           voice: { kind: :ref, ref: "VoiceConfig" },
           llm: { kind: :ref, ref: "ModelConfig" },
           stt: { kind: :ref, ref: "ModelConfig" },
+          judge: { kind: :ref, ref: "ModelConfig" },
           turn: { kind: :ref, ref: "TurnConfig" },
           says: { kind: :list, items: { kind: :ref, ref: "Pronunciation" } },
           hears: { kind: :list, items: { kind: :str } },

data/lib/pinecall/wire/shapes_parts.rb

@@ -318,7 +318,9 @@ module Pinecall
           verdict: { kind: :ref, ref: "ScoreVerdict", required: true },
           criteria: { kind: :str, required: true },
           reason: { kind: :str, required: true },
-          evidence: { kind: :ref, ref: "JudgmentEvidence", required: true }
+          evidence: { kind: :ref, ref: "JudgmentEvidence", required: true },
+          choice: { kind: :str, null: true },
+          score: { kind: :int, null: true }
         }.freeze,
         "JudgmentEvidence" => {
           seqs: { kind: :list, items: { kind: :int }, required: true },

data/sig/pinecall.rbs

@@ -87,13 +87,15 @@ module Pinecall
     # the environment the class declares, each over the agent's settings
     def self.voice: (?String, ?String?, ?model: String?, ?builds: String?, ?options: Hash[untyped, untyped]?) -> untyped
     def self.llm: (?String, ?temperature: Float?, ?builds: String?, ?options: Hash[untyped, untyped]?) -> untyped
-    def self.stt: (?String, ?builds: String?, ?options: Hash[untyped, untyped]?) -> untyped
+    def self.stt: (?String, ?builds: String?, ?options: Hash[untyped, untyped]?, ?end_of_turn: (String | Symbol)?) -> untyped
+    def self.judge: (?String, ?builds: String?, ?options: Hash[untyped, untyped]?) -> untyped
     def self.language: (?String) -> untyped
     def self.says: (?Array[Hash[Symbol, String]]) -> untyped
     def self.record: (?bool) -> untyped
     def self.hears: (*String | Array[String]) -> untyped
-    def self.greeting: (**untyped) -> untyped
-    def self.hangup: (**untyped) -> untyped
+    def self.greeting: (?(String | Symbol | untyped), ?interruptible: bool?) -> untyped
+    def self.improvise: (?String, ?interruptible: bool?) -> untyped
+    def self.hangup: (?(String | true)) -> untyped
     def self.turn: (**untyped) -> untyped
     def self.knowledge: (**untyped) -> untyped
     def self.docs: (**untyped) -> untyped

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pinecall
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Pinecall