legion-llm 0.7.4 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43cc1358dabaa66c319b8e8c12810ed4c9b9dd344d74fe608c7607d745369618
-  data.tar.gz: 9388386688c739d59e69779ef950563f10259aa69ea4833dd2a5ef1f29caeda0
+  metadata.gz: 14ea97502e51c6baf291165f3e36bbf37b28b93eb119ad750e6157089b0058c6
+  data.tar.gz: 6881a3b870cbdb2b7f7bbc2ce3af39b7331f27aefd48e742073a5c1149a8d0bf
 SHA512:
-  metadata.gz: 25b3734d86e86107226fea78aa686132c9030ae3cb191388d88e962b9c5b66327524528e91af7ebb27d8df9b8d8057684cf10e030d37992b5d44e6ae5cf885cf
-  data.tar.gz: 8bdbbdd6cb270a40cf47de6391b36cab005f305a1b2a39628849c9c1747968b8eebea765bb745ecc4d7f5d36afa876510972c28a61a804770a62bd631e2cca55
+  metadata.gz: 83d59e98b5fe417f762bdf7aec41c8bdbe10246db47d9f9dcf620a9c5b7bc97768a0f05a13e5865a30400fb37c018ee019047fd68ddf717d760b213dd36c58e2
+  data.tar.gz: 43897c5332b7c641812f3e75981b1712a5d5262f607ce55bf8cd49f27c04a6a62f4bddd3d5f6abd8c0adc634a41b60e9b894383a211955ae1197d09d9c16bfb3

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.7.5] - 2026-04-14
+
+### Added
+- `Legion::LLM::Prompt` module — clean API replacing `chat`/`ask`/`chat_direct` surface
+  - `Prompt.dispatch(message, intent:, exclude:, tier:, tools:, ...)` — auto-routed via Router
+  - `Prompt.request(message, provider:, model:, ...)` — pinned dispatch, full pipeline
+  - `Prompt.summarize`, `Prompt.extract`, `Prompt.decide` — convenience methods (default `tools: []`)
+  - Nil provider/model guard raises `LLMError` with actionable message
+  - In-process pipeline execution (no DaemonClient HTTP roundtrip)
+  - Backward compat: `Legion::LLM.chat` delegates to `Prompt.dispatch` for non-streaming calls
+- `build_pipeline_request` uses `Pipeline::Request.from_chat_args` as base, preserving all pipeline kwargs
+
+## [0.7.4] - 2026-04-14
+
+### Fixed
+- PHI/PII classification hard gate: `TierAssigner` now routes `contains_phi`/`contains_pii`/`:restricted` to `tier: :local` (fail closed). Previously routed to `:cloud`.
+
 ## [0.7.3] - 2026-04-13
 
 ### Added

data/lib/legion/llm/prompt.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Legion
+  module LLM
+    module Prompt
+      module_function
+
+      # Auto-routed: Router picks the best provider+model based on intent.
+      # Primary entry point for most LLM calls.
+      # When provider/model are passed explicitly, they take precedence over routing.
+      def dispatch(message, # rubocop:disable Metrics/ParameterLists
+                   intent: nil,
+                   exclude: {}, # rubocop:disable Lint/UnusedMethodArgument -- forwarded to Router.resolve in WS-00E
+                   tier: nil,
+                   provider: nil,
+                   model: nil,
+                   schema: nil,
+                   tools: nil,
+                   escalate: nil,
+                   max_escalations: 3,
+                   thinking: nil,
+                   temperature: nil,
+                   max_tokens: nil,
+                   tracing: nil,
+                   agent: nil,
+                   caller: nil,
+                   cache: nil,
+                   quality_check: nil,
+                   **)
+        resolved_provider = provider
+        resolved_model = model
+
+        if resolved_provider.nil? && resolved_model.nil? && defined?(Router) && Router.routing_enabled?
+          resolution = Router.resolve(intent: intent, tier: tier)
+          resolved_provider = resolution&.provider
+          resolved_model = resolution&.model
+        end
+
+        resolved_provider ||= Legion::LLM.settings[:default_provider]
+        resolved_model ||= Legion::LLM.settings[:default_model]
+
+        request(message,
+                provider:        resolved_provider,
+                model:           resolved_model,
+                intent:          intent,
+                tier:            tier,
+                schema:          schema,
+                tools:           tools,
+                escalate:        escalate,
+                max_escalations: max_escalations,
+                thinking:        thinking,
+                temperature:     temperature,
+                max_tokens:      max_tokens,
+                tracing:         tracing,
+                agent:           agent,
+                caller:          caller,
+                cache:           cache,
+                quality_check:   quality_check,
+                **)
+      end
+
+      # Pinned: caller specifies exact provider+model. Full pipeline runs in-process.
+      def request(message, # rubocop:disable Metrics/ParameterLists
+                  provider:,
+                  model:,
+                  intent: nil,
+                  tier: nil,
+                  schema: nil,
+                  tools: nil,
+                  escalate: nil,
+                  max_escalations: 3,
+                  thinking: nil,
+                  temperature: nil,
+                  max_tokens: nil,
+                  tracing: nil,
+                  agent: nil,
+                  caller: nil,
+                  cache: nil,
+                  quality_check: nil,
+                  **)
+        if provider.nil? || model.nil?
+          raise LLMError, "Prompt.request: provider and model must be set (got provider=#{provider.inspect}, model=#{model.inspect}). " \
+                          'Configure Legion::Settings[:llm][:default_provider] and [:default_model], or pass them explicitly.'
+        end
+
+        pipeline_request = build_pipeline_request(
+          message, provider: provider, model: model, intent: intent, tier: tier,
+                   schema: schema, tools: tools,
+                   escalate: escalate, max_escalations: max_escalations,
+                   thinking: thinking, temperature: temperature, max_tokens: max_tokens,
+                   tracing: tracing, agent: agent, caller: caller, cache: cache,
+                   quality_check: quality_check, **
+        )
+
+        executor = Pipeline::Executor.new(pipeline_request)
+        executor.call
+      end
+
+      # Condense a conversation or feedback history into a shorter form.
+      def summarize(messages, tools: [], **)
+        prompt = build_summarize_prompt(messages)
+        dispatch(prompt, tools: tools, **)
+      end
+
+      # Extract structured data from unstructured text.
+      def extract(text, schema:, tools: [], **)
+        prompt = build_extract_prompt(text)
+        dispatch(prompt, schema: schema, tools: tools, **)
+      end
+
+      # Pick from a set of options with reasoning.
+      def decide(question, options:, tools: [], **)
+        prompt = build_decide_prompt(question, options)
+        dispatch(prompt, tools: tools, **)
+      end
+
+      # --- Private helpers ---
+
+      def build_pipeline_request(message, provider:, model:, intent:, tier:, schema:, tools:, # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+                                 escalate:, max_escalations:, thinking:, temperature:,
+                                 max_tokens:, tracing:, agent:, caller:, cache:,
+                                 quality_check:, **rest)
+        # Build base request via from_chat_args to preserve full pipeline kwargs
+        # (context_strategy, tool_choice, idempotency_key, ttl, enrichments, predictions, etc.)
+        chat_message = message.is_a?(Array) ? nil : message.to_s
+        chat_messages = message.is_a?(Array) ? message : nil
+
+        base = Pipeline::Request.from_chat_args(
+          message:         chat_message,
+          messages:        chat_messages,
+          model:           model,
+          provider:        provider,
+          intent:          intent,
+          tier:            tier,
+          tools:           tools,
+          thinking:        thinking,
+          tracing:         tracing,
+          agent:           agent,
+          caller:          caller,
+          cache:           cache,
+          escalate:        escalate,
+          max_escalations: max_escalations,
+          quality_check:   quality_check,
+          **rest
+        )
+
+        # Overlay Prompt-specific translations on top of the base request
+        generation = (base.generation || {}).dup
+        generation[:temperature] = temperature if temperature
+
+        tokens = (base.tokens || {}).dup
+        tokens[:max] = max_tokens if max_tokens
+
+        response_format = if schema
+                            { type: :json_schema, schema: schema }
+                          elsif base.response_format
+                            base.response_format
+                          else
+                            { type: :text }
+                          end
+
+        Pipeline::Request.build(
+          messages:         base.messages,
+          system:           base.system,
+          routing:          base.routing || { provider: provider, model: model },
+          tools:            base.tools || tools || [],
+          tool_choice:      base.tool_choice,
+          thinking:         base.thinking || thinking,
+          generation:       generation,
+          tokens:           tokens,
+          stop:             base.stop,
+          response_format:  response_format,
+          stream:           base.stream || false,
+          fork:             base.fork,
+          cache:            base.cache || cache || { strategy: :default, cacheable: true },
+          priority:         base.priority || :normal,
+          tracing:          base.tracing || tracing,
+          classification:   base.classification,
+          caller:           base.caller || caller,
+          agent:            base.agent || agent,
+          billing:          base.billing,
+          test:             base.test,
+          modality:         base.modality,
+          hooks:            base.hooks,
+          conversation_id:  base.conversation_id,
+          idempotency_key:  base.idempotency_key,
+          schema_version:   base.schema_version,
+          id:               base.id,
+          ttl:              base.ttl,
+          metadata:         base.metadata || {},
+          enrichments:      base.enrichments || {},
+          predictions:      base.predictions || {},
+          context_strategy: base.context_strategy,
+          extra:            base.extra || {}
+        )
+      end
+
+      def build_summarize_prompt(messages)
+        text = if messages.is_a?(Array)
+                 messages.map { |m| m.is_a?(Hash) ? m[:content] : m.to_s }.join("\n")
+               else
+                 messages.to_s
+               end
+        "Summarize the following content concisely, preserving key points:\n\n#{text}"
+      end
+
+      def build_extract_prompt(text)
+        "Extract structured data from the following text. Return only the JSON matching the provided schema.\n\n#{text}"
+      end
+
+      def build_decide_prompt(question, options)
+        options_text = options.each_with_index.map { |opt, i| "#{i + 1}. #{opt}" }.join("\n")
+        "#{question}\n\nOptions:\n#{options_text}\n\nPick the best option and explain your reasoning."
+      end
+
+      private_class_method :build_pipeline_request,
+                           :build_summarize_prompt, :build_extract_prompt, :build_decide_prompt
+    end
+  end
+end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.7.4'
+    VERSION = '0.7.5'
   end
 end

data/lib/legion/llm.rb

@@ -37,6 +37,7 @@ require_relative 'llm/cost_tracker'
 require_relative 'llm/token_tracker'
 require_relative 'llm/override_confidence'
 require_relative 'llm/routes'
+require_relative 'llm/prompt'
 
 begin
   require_relative 'llm/skills'
@@ -543,7 +544,17 @@ module Legion
           "tier=#{tier} escalate=#{escalate} max_escalations=#{max_escalations} " \
           "quality_check=#{quality_check} message_present=#{!message.nil?} kwargs=#{kwargs.keys.sort}"
         )
-        if pipeline_enabled? && (message || kwargs[:messages])
+        if pipeline_enabled? && (message || kwargs[:messages]) && !block_given?
+          return Prompt.dispatch(
+            message || kwargs[:messages],
+            intent: intent, tier: tier, provider: provider, model: model,
+            escalate: escalate, max_escalations: max_escalations,
+            quality_check: quality_check, **kwargs.except(:messages)
+          )
+        end
+
+        # Streaming with pipeline — old path (Prompt does not handle streaming yet)
+        if pipeline_enabled? && (message || kwargs[:messages]) && block_given?
           return chat_via_pipeline(model: model, provider: provider, intent: intent, tier: tier,
                                    message: message, escalate: escalate, max_escalations: max_escalations,
                                    quality_check: quality_check, **kwargs, &)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors:
 - Esity
@@ -307,6 +307,7 @@ files:
 - lib/legion/llm/pipeline/tool_adapter.rb
 - lib/legion/llm/pipeline/tool_dispatcher.rb
 - lib/legion/llm/pipeline/tracing.rb
+- lib/legion/llm/prompt.rb
 - lib/legion/llm/provider_registry.rb
 - lib/legion/llm/providers.rb
 - lib/legion/llm/quality_checker.rb