little_ghost 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16d2003f8e5b79a2532ab16b9a0a1d95a9ee65b21025371290aeccacacd0f8a1
-  data.tar.gz: 0c4db0710a8650ebb1ae159bc59a62078c442a035b64c3f549cbfb686c881c32
+  metadata.gz: cfcd337b2268f123e2e64e4bdb63a68e3f093395888dac5b0e4fe18ce0f800c6
+  data.tar.gz: 31dc093cea43764a4f8526c140bb57d56752da34c2cbced63d96f2a68eeab41b
 SHA512:
-  metadata.gz: c435a0f6ef9b9d4508d66f72610b32b58f45ed724af5d8b9fbf8cc20fc27eaa8a41dcffc1c4fe0e109fbfc3603dffdf393f0bc38444a554009b41d8302b74f1a
-  data.tar.gz: 1945188f5019cd2b115f74df481a344124d793eaa74ace0e6efc57b84d9bc117ee20879a2764818c78918e1dcd0609f3c1230e27b9a6b2885b4db4288a9e8b6b
+  metadata.gz: b1ad15e0aa91583641dcd752a0b4157151b216672c0431c77d6b76293ee73e2841e9e39b49988c9517533f10f22014e376bb5c86d41929c62f6d2de83df3a81e
+  data.tar.gz: d39231bad7f80f01db55a6c8ba6af68292205f81f06f887149cb03bc68f777d4e759bc1c64bae661ebe25ba8b3118240c19a6876a2cf0e24712652776de52426

data/README.md

@@ -6,26 +6,13 @@
 
 <hr>
 
-Bring agents and agentic workflows into an existing Ruby system, or use them as the core of a dedicated AI service. LittleGhost brings model providers, tools, streaming, sessions, delegation, deterministic composition, and observability together behind one coherent set of Ruby APIs.
+Bring agents and agentic workflows into an existing Ruby system, or use them as the core of a dedicated AI service. LittleGhost connects model providers, tools, streaming, sessions, delegation, deterministic workflows, and observability through Ruby APIs.
 
-Here is the shape of a small customer support agent. `CustomerSupportModels` keeps provider details out of agent behavior, `HelpCenterLookupTool` exposes one narrow, validated help center lookup, and `CustomerSupportAgent` brings them together:
+Set `OPENAI_API_KEY`, then paste this customer support agent into a Ruby console or file. It selects a model directly and exposes one validated application tool:
 
 ```ruby
 require "little_ghost"
 
-class CustomerSupportModels < LittleGhost::ModelRegistry
-  def initialize
-    super
-    provider(:openai) do |model:, **|
-      LittleGhost::Providers::OpenAI.new(
-        api_key: ENV.fetch("OPENAI_API_KEY"),
-        model:
-      )
-    end
-    profile "customer_support", provider: :openai, model: "gpt-5"
-  end
-end
-
 class HelpCenterLookupTool < LittleGhost::Tool
   description "Look up a help center entry by topic."
   input_schema(
@@ -43,80 +30,96 @@ end
 
 class CustomerSupportAgent < LittleGhost::Agent
   description "Answers customer support questions."
-  model "customer_support"
+  model "openai:gpt-5.6-luna"
   system_prompt "Answer clearly. Check the help center before stating company guidance."
   tools HelpCenterLookupTool
 end
 
-LittleGhost.configure { |config| config.models CustomerSupportModels }
-
 run = CustomerSupportAgent.ask("Can I get a refund after two weeks?")
 puts run.response
 # One possible response:
 # Refunds are available within 30 days, so your purchase is eligible.
 ```
 
-The result is a normal Ruby object. You can inspect its outcome, final response, normalized messages, token usage, and error instead of parsing provider-specific payloads.
-
-LittleGhost keeps the model loop provider-neutral. Tools can run in parallel, mutating tools can opt into a run-wide exclusive lock, and oversized tool results are truncated to the configured limit before they enter model context. Strict result schemas, cancellation, deadlines, session checkpoints, structured events, and OpenTelemetry integration are available when an application needs them; none are required to define the first agent.
+The completed `LittleGhost::Run` exposes its outcome, final response, normalized messages, token usage, and terminal error. Streaming callers receive `LittleGhost::StreamEvent` objects instead of provider-specific payloads:
 
-The core stays dependency-light, while provider SDKs and deployment choices remain with the application.
+```ruby
+CustomerSupportAgent.stream_ask("Can I get a refund?").each do |event|
+  print event.data.fetch(:text) if event.type == :text_delta
+end
+```
 
-## How it fits together
+## How the pieces fit
 
 ```text
-application configuration ──> CustomerSupportModels ──> provider
-                                      │
+provider connections + model selections ──> ModelResolver ──> provider
+                                               │
 request ──> CustomerSupportAgent ──> HelpCenterLookupTool
                   │
-                  └────────> ResearchAgent (when delegated)
+                  └────────> ResearchAgent subagent
 
 request ──> ResponseWorkflow ──> ResearchAgent ──> CustomerSupportAgent
 ```
 
-Configuration owns shared services such as model registries, sessions, lookup paths, workspaces, sandboxes, and instrumentation. Agent classes own behavior: their logical model role, prompt, tools, limits, structured result, and delegation policy. A tool is a validated boundary around application code. A subagent lets the model delegate work within configured turn, concurrency, and depth limits; a workflow uses ordinary Ruby when your application must choose the sequence.
+Configuration owns shared services such as model resolution, sessions, lookup paths, workspaces, sandboxes, and instrumentation. Agent classes own behavior: their model selection, prompt, tools, limits, result schema, and delegation policy. Tools expose narrow application operations. A subagent lets the model delegate within configured limits; a workflow uses ordinary Ruby when the application must control ordering.
 
-`CustomerSupportAgent.ask(...)` creates a standalone entrypoint, consumes its run, and returns the completed `LittleGhost::Run`. Create an instance explicitly when reusing a runtime or when an interface should render progress as `LittleGhost::StreamEvent` objects:
+Each top-level execution owns a run lifecycle. The run checkpoints session state, closes its resources, aggregates usage, and emits framework events whether the entrypoint is an agent or a workflow.
 
-`LittleGhost::Agent.ask("hi")` uses the built-in default model selection and the system prompt `You are a helpful agent.` for a general-purpose agent.
+## Installation and configuration
+
+LittleGhost requires Ruby 3.3 or newer. Add it to your bundle:
 
 ```ruby
-CustomerSupportAgent.new.stream_ask("Can I get a refund?").each do |event|
-  print event.data[:text] if event.type == :text_delta
-end
+gem "little_ghost"
 ```
 
-Applications can add a `ResearchAgent` as a subagent for open-ended investigation, or place both agents behind a deterministic `ResponseWorkflow`. The same run lifecycle checkpoints session state, closes owned resources, aggregates usage, and emits framework events in each form.
+Then run `bundle install`. Built-in OpenAI-compatible, OpenRouter, Anthropic, Gemini, Vertex AI, and Amazon Bedrock integrations use Ruby's standard library and normalize responses into the same protocol.
 
-## Installation
+Configuration does not require a particular directory layout. Provider connections and model profiles resolve independently in this order:
 
-LittleGhost requires Ruby 3.3 or newer. Add it to your bundle:
+1. An inline `config.providers` or `config.models` declaration.
+2. The corresponding explicit `config.providers_path` or `config.models_path`.
+3. The optional conventional file under `config/little_ghost/`.
+4. Environment-based provider selection and the built-in `default` profile.
 
-```ruby
-gem "little_ghost"
+An explicit path must exist. A missing conventional file is valid. The conventional form keeps connection policy separate from model roles:
+
+```yaml
+# config/little_ghost/providers.yml
+providers:
+  openai:
+    adapter: openai
+    api_key: <%= ENV.fetch("OPENAI_API_KEY") %>
 ```
 
-Then run `bundle install`. Provider SDKs and OpenTelemetry exporters are optional application dependencies. The built-in OpenAI, OpenAI-compatible, OpenRouter, and Amazon Bedrock integrations normalize their responses into the same LittleGhost protocol.
+```yaml
+# config/little_ghost/models.yml
+default_model: customer_support
+models:
+  customer_support:
+    target: openai:gpt-5.6-luna
+```
 
-By default, LittleGhost maps the `default` role to GPT-5.6 Terra. It selects the first nonblank API key from `LITTLEGHOST_OPENROUTER_API_KEY`, `LITTLEGHOST_OPENAI_API_KEY`, `OPENROUTER_API_KEY`, and `OPENAI_API_KEY`, in that order. Setting one of these keys authorizes model inputs—including prompts, conversation history, tool data, and attachments—to be sent to the selected external provider. Applications with provider or data-residency requirements should configure a model registry explicitly.
+By default, LittleGhost maps `default` to GPT-5.6 Luna. It configures conventional OpenRouter and OpenAI connections from nonblank `LITTLEGHOST_OPENROUTER_API_KEY`, `LITTLEGHOST_OPENAI_API_KEY`, `OPENROUTER_API_KEY`, and `OPENAI_API_KEY` values; that order determines the default when more than one provider is available. Model inputs—including prompts, history, tool data, and attachments—leave the application for the selected external provider. Configure providers explicitly when provider choice or data residency matters.
 
-By default, structured framework events have no console destination. Hosted applications can emit redacted JSON lines to standard output with `LittleGhost.configure { |config| config.log_events_to :stdout }`; `:stderr` selects standard error instead, and `nil` disables a configured destination. Event emission and severity levels are the same with or without a console destination.
+Applications that need custom routing can subclass `LittleGhost::ModelResolver` and install the class with `config.model_resolver`. A custom resolver owns its profiles and default role; configuring `models`, `models_path`, or `default_model` at the same time is an error. Provider configuration remains available to the resolver.
 
-Prompts can stay inline while an agent is small, then move into conventional ERB templates under `app/prompts`. Agents and tools under `app/agents` and `app/tools` are loaded from the configured application root, keeping framework setup separate from product behavior.
+LittleGhost runs inside the surrounding Ruby process; it does not prescribe an HTTP server, CLI, job system, or application layout. `config/little_ghost`, `app/agents`, `app/prompts`, `app/tools`, and `app/skills` are optional conventions. Every path can be configured, and agents, prompts, and tools may live wherever the application loads them.
 
 ## Documentation
 
-- [LittleGhost website](https://mattyr.github.io/little_ghost/) is the quickest way to meet the framework and find your next step.
-- [Getting Started](docs/guides/Getting%20Started.md) builds the customer support example from an empty application and runs it.
-- [Core Concepts](docs/guides/Core%20Concepts.md) explains models, agents, tools, delegation, workflows, sessions, and streaming through the same example.
-- [API reference](rdoc-ref:LittleGhost) covers exact signatures, options, and lifecycle details.
+- [Getting Started](docs/guides/getting_started.md) builds and streams the customer support example.
+- [Core Concepts](docs/guides/core_concepts.md) explains models, agents, tools, runs, delegation, workflows, and sessions.
+- [API reference](rdoc-ref:LittleGhost) covers exact signatures, options, and lifecycle behavior.
 
-LittleGhost is licensed under the MIT License.
+## Contributing
 
-## Development
+See the [contributing guide](https://github.com/mattyr/little_ghost/blob/main/CONTRIBUTING.md), [Code of Conduct](https://github.com/mattyr/little_ghost/blob/main/CODE_OF_CONDUCT.md), and [security policy](https://github.com/mattyr/little_ghost/blob/main/SECURITY.md).
 
 ```sh
 bundle install
 bundle exec rake test
 bundle exec standardrb --no-fix
 ```
+
+LittleGhost is licensed under the MIT License.

data/docs/guides/{Core Concepts.md → core_concepts.md}

@@ -1,10 +1,10 @@
 # Core Concepts
 
-LittleGhost gives Ruby software two ways to compose AI behavior. Agents can choose among validated tools and delegated specialists, while agentic workflows keep required ordering and branching under application control. The customer support example makes that boundary visible: CustomerSupportModels chooses provider-backed models, CustomerSupportAgent owns behavior, HelpCenterLookupTool exposes a narrow help center lookup, ResearchAgent handles delegated investigation, and ResponseWorkflow imposes a deterministic sequence when the surrounding system requires one.
+LittleGhost gives Ruby software two ways to compose AI behavior. Agents can choose among validated tools and delegated specialists, while agentic workflows keep required ordering and branching under application control. The customer support example makes that boundary visible: ModelResolver chooses provider-backed models, CustomerSupportAgent owns behavior, HelpCenterLookupTool exposes a narrow help center lookup, ResearchAgent handles delegated investigation, and ResponseWorkflow imposes a deterministic sequence when the surrounding system requires one.
 
 ```text
 shared configuration
-└── CustomerSupportModels ── resolves logical roles ──> provider clients
+└── ModelResolver ── resolves model selections ──> provider clients
 
 one request
 └── Run
@@ -17,28 +17,48 @@ one deterministic request
 └── Run ──> ResponseWorkflow ──> ResearchAgent ──> CustomerSupportAgent
 ```
 
-## Models are selected by role
+## Models can be selected directly or by role
 
-An agent names a logical role such as `customer_support`, not a vendor model. `CustomerSupportModels` maps that stable application vocabulary to a provider and model identifier:
+An agent can name a canonical target directly when the choice belongs beside its behavior:
 
 ```ruby
-class CustomerSupportModels < LittleGhost::ModelRegistry
-  def initialize
-    super
-    provider(:openai) do |model:, **|
-      LittleGhost::Providers::OpenAI.new(
-        api_key: ENV.fetch("OPENAI_API_KEY"),
-        model:
-      )
-    end
-    profile "customer_support", provider: :openai, model: "gpt-5"
-  end
+class CustomerSupportAgent < LittleGhost::Agent
+  model "openai:gpt-5.6-luna"
+end
+```
+
+It can also attach trusted model settings without defining a shared profile:
+
+```ruby
+class DeliberateSupportAgent < LittleGhost::Agent
+  model(provider: "openai", model: "gpt-5.6-luna", reasoning_effort: "high")
+end
+```
+
+In both forms, `provider` is the name of a configured connection. A role such as `customer_support` adds stable application vocabulary when several agents or deployments should share routing policy:
+
+```ruby
+LittleGhost.configure do |config|
+  config.providers = {
+    openai: {adapter: :openai, api_key: ENV.fetch("OPENAI_API_KEY")}
+  }
+  config.models = {
+    customer_support: {target: "openai:gpt-5.6-luna"}
+  }
 end
 ```
 
-Dotted roles inherit from the nearest registered parent. `ResearchAgent` can request `customer_support.research` and initially use the `customer_support` profile; registering `customer_support.research` later specializes it. Per-invocation profile overrides can vary a request without mutating the registry or agent class. Because an override can select a different registered provider, model, and settings, it is trusted application configuration and must be constructed or allowlisted by the application rather than copied from unchecked request data.
+```ruby
+class CustomerSupportAgent < LittleGhost::Agent
+  model :customer_support
+end
+```
+
+Strings and symbols without a colon are roles; strings containing a colon are canonical targets; mappings require `provider` and `model`, with remaining keys treated as model settings. Role names cannot contain a colon. Direct targets and mappings bypass role inheritance and overlays.
+
+Dotted roles inherit from the nearest registered parent. `ResearchAgent` can request `customer_support.research` and initially use the `customer_support` profile; registering `customer_support.research` later specializes it. A resolver caller may pass an explicit `profiles:` overlay without mutating the configured profiles or agent class. Because an overlay can select a different registered provider, model, and settings, it is trusted application configuration and must be constructed or allowlisted by the application rather than copied from unchecked request data. The base resolver does not inspect application-specific invocation fields.
 
-The provider performs model I/O. The registry resolves application intent into a `LittleGhost::Model`, which carries the provider, settings, metadata, model identifier, and role for a run.
+The provider performs model I/O. `LittleGhost::ModelResolver` resolves application intent into a `LittleGhost::Model`, which carries the provider, target, settings, details, and role for a run.
 
 ## Agents declare behavior
 
@@ -56,7 +76,7 @@ end
 
 The class-level DSL is inheritable. It can declare prompts, limits, callbacks, tool classes, structured results, context management, skills, and delegation. A capability mixin may be included in `LittleGhost::Agent`, but its behavior remains inactive until the corresponding DSL is called.
 
-`CustomerSupportAgent.ask` creates a standalone, console-friendly entrypoint, builds and consumes a `LittleGhost::Run`, and returns that run. Create `CustomerSupportAgent.new` explicitly to reuse a runtime or call `#stream_ask` for the run's events. Agents built by a runtime are instead scoped to their owning run and return a `LittleGhost::RunResult` from `#call`.
+`CustomerSupportAgent.ask` creates a standalone entrypoint, builds and consumes a `LittleGhost::Run`, and returns that run. `CustomerSupportAgent.stream_ask` creates the same kind of entrypoint and yields the run's events. Create `CustomerSupportAgent.new(runtime:)` explicitly when several calls should reuse one runtime. Agents built by a runtime are instead scoped to their owning run and return a `LittleGhost::RunResult` from `#call`.
 
 That distinction explains two useful return paths:
 
@@ -195,9 +215,9 @@ Streams expose generic framework events rather than provider wire formats. Consu
 
 The core design can be summarized as four choices:
 
-- Put shared construction and provider policy in configuration and model registries.
+- Put shared construction and provider policy in configuration; use inline declarations or independent YAML files according to the application's needs.
 - Put model behavior and available capabilities on agent classes.
 - Put privileged application operations behind narrow, authorized tools.
 - Put mandatory ordering in workflows; leave optional delegation to subagents.
 
-Return to [Getting Started](Getting%20Started.md) for the complete first-run setup. The API reference covers exact signatures and lifecycle details for `LittleGhost::Runtime`, `LittleGhost::Run`, `LittleGhost::Agent`, `LittleGhost::Tool`, `LittleGhost::Workflow`, and `LittleGhost::ModelRegistry`.
+Return to [Getting Started](getting_started.md) for the complete first-run setup. The API reference covers exact signatures and lifecycle details for `LittleGhost::Runtime`, `LittleGhost::Run`, `LittleGhost::Agent`, `LittleGhost::Tool`, `LittleGhost::Workflow`, and `LittleGhost::ModelResolver`.

data/docs/guides/getting_started.md

@@ -0,0 +1,164 @@
+# Getting Started with LittleGhost
+
+This guide builds a customer support agent that checks a small help center before answering. It focuses on the Ruby objects needed for one useful run: a tool, an agent, and the call that starts it.
+
+LittleGhost runs inside your Ruby process. It does not choose how your application is hosted or where these definitions live.
+
+## Install LittleGhost
+
+LittleGhost requires Ruby 3.3 or newer. Add the gem to your `Gemfile`:
+
+```ruby
+gem "little_ghost"
+```
+
+Install the bundle and set a provider credential:
+
+```sh
+$ bundle install
+$ export OPENAI_API_KEY="..."
+```
+
+With `OPENAI_API_KEY` present, LittleGhost can connect the `openai` provider name used below. OpenRouter credentials work as well. Use application secret management outside a local shell, and do not commit provider credentials.
+
+## Give the agent a tool
+
+Start by requiring LittleGhost and defining a narrow help center lookup:
+
+```ruby
+require "little_ghost"
+
+class HelpCenterLookupTool < LittleGhost::Tool
+  HELP_CENTER_ENTRIES = {
+    "refunds" => "Refunds are available within 30 days of purchase.",
+    "shipping" => "Standard shipping takes three to five business days."
+  }.freeze
+
+  description "Look up a help center entry by topic."
+  input_schema(
+    type: "object",
+    properties: {
+      topic: {type: "string", enum: HELP_CENTER_ENTRIES.keys}
+    },
+    required: ["topic"],
+    additionalProperties: false
+  )
+
+  def call(input)
+    HELP_CENTER_ENTRIES.fetch(input.fetch("topic"))
+  end
+end
+```
+
+A tool gives the model one application operation with a name, description, and validated JSON input. LittleGhost validates the input before calling `#call` and turns the returned value into model context.
+
+The schema checks shape, not authorization. A tool that reads customer data or performs an action must enforce the application's trust rules inside its implementation.
+
+## Define the agent
+
+Now describe the agent's behavior and make the lookup available to it:
+
+```ruby
+class CustomerSupportAgent < LittleGhost::Agent
+  description "Answers customer support questions."
+  model "openai:gpt-5.6-luna"
+  system_prompt <<~PROMPT
+    Answer clearly and do not invent company guidance.
+    Use the help center lookup tool before stating company guidance.
+  PROMPT
+
+  tools HelpCenterLookupTool
+end
+```
+
+An agent class is a reusable behavior definition. It owns its prompt, tools, model selection, limits, and other capabilities. This agent names an OpenAI connection and model directly, so the first example does not need a separate model profile.
+
+## Ask a question
+
+Call the agent class to run one request to completion:
+
+```ruby
+run = CustomerSupportAgent.ask(
+  "I bought an item two weeks ago. Can I get a refund?"
+)
+
+if run.completed?
+  puts run.response
+else
+  warn "Support request ended as #{run.outcome}: #{run.error&.class}"
+end
+```
+
+`CustomerSupportAgent.ask` creates and consumes a `LittleGhost::Run`. A successful run exposes its final text through `#response`; it also retains the normalized result, outcome, usage, messages, and any terminal error.
+
+The model can call `HelpCenterLookupTool` with `{"topic":"refunds"}` and answer along these lines:
+
+```text
+Refunds are available within 30 days, so a purchase from two weeks ago is eligible.
+```
+
+Model wording and tool selection are not deterministic. The prompt directs the agent to ground company guidance in the validated lookup; applications that must enforce a lookup should put that ordering in a workflow.
+
+## Stream the same agent
+
+Use `.stream_ask` when a console, HTTP response, or user interface should receive progress while the run is active:
+
+```ruby
+CustomerSupportAgent.stream_ask("Can I get a refund?").each do |event|
+  case event.type
+  when :text_delta
+    print event.data.fetch(:text)
+  when :run_error
+    warn event.data.fetch(:message)
+  end
+end
+```
+
+The stream yields `LittleGhost::StreamEvent` objects. Text, tool activity, usage, traces, and terminal lifecycle facts share this interface, so callers do not need provider-specific response handling.
+
+Both calls use the same agent definition and active LittleGhost configuration. Core Concepts explains reusable runtimes when an application needs more control over shared services.
+
+## Add a model role when the application grows
+
+Direct targets keep a small application easy to read. A larger application can give the same selection a stable role, then change the underlying provider, model, and defaults without editing each agent class:
+
+```ruby
+LittleGhost.configure do |config|
+  config.providers = {
+    openai: {adapter: :openai, api_key: ENV.fetch("OPENAI_API_KEY")}
+  }
+  config.models = {
+    customer_support: {
+      target: "openai:gpt-5.6-luna",
+      settings: {temperature: 0.2}
+    }
+  }
+  config.default_model = :customer_support
+end
+
+class CustomerSupportAgent < LittleGhost::Agent
+  model :customer_support
+end
+```
+
+An agent may also keep a small amount of model-specific configuration beside its behavior:
+
+```ruby
+class DeliberateSupportAgent < LittleGhost::Agent
+  model(
+    provider: "openai",
+    model: "gpt-5.6-luna",
+    reasoning_effort: "high"
+  )
+end
+```
+
+Here, `provider` names a configured connection and every other key after `model` is a trusted model setting. Provider connections and model profiles may instead come from independent YAML files under `config/little_ghost`, or from paths selected in `LittleGhost.configure`. Inline declarations take precedence over explicit paths, which take precedence over conventional files; environment-based selection and the built-in default are the final fallback. `LittleGhost::Agent` and `LittleGhost::Configuration` document the complete shapes and precedence.
+
+## Fit LittleGhost into your application
+
+LittleGhost does not require an application layout. Keep agents and tools beside related application code when your framework or loader already has a home for them. If you want LittleGhost to eager-load these definitions, `app/agents` and `app/tools` are available conventions, and every lookup path is configurable.
+
+Hosting remains the surrounding application's responsibility. A Rails controller, Rack endpoint, background job, CLI, or another Ruby entrypoint can call the same agent APIs shown above.
+
+Read [Core Concepts](core_concepts.md) next for model selection, reusable runtimes, subagents, workflows, sessions, and the boundaries between them. The API reference covers exact signatures for `LittleGhost::Agent`, `LittleGhost::Tool`, `LittleGhost::Configuration`, and `LittleGhost::Run`.

data/lib/little_ghost/ag_ui/adapter.rb

@@ -9,7 +9,7 @@ module LittleGhost
     # Adapter turns a LittleGhost stream into AG-UI event hashes. It lets a Ruby
     # agent drive compatible chat interfaces without changing the agent itself.
     #
-    #   events = CustomerSupportAgent.new.stream_ask("Where is my order?")
+    #   events = CustomerSupportAgent.stream_ask("Where is my order?")
     #   adapter = LittleGhost::AGUI::Adapter.new
     #   adapter.stream(events, thread_id: "thread-1", run_id: "run-1").each do |event|
     #     websocket.write(JSON.generate(event))

data/lib/little_ghost/agent/context_management.rb

@@ -259,10 +259,7 @@ module LittleGhost
       end
 
       def model_context_window_tokens(configuration)
-        value = model.respond_to?(:metadata) && (
-          model.metadata[:context_window_tokens] || model.metadata["context_window_tokens"] ||
-          model.metadata[:context_window] || model.metadata["context_window"]
-        )
+        value = model.details.context_window
         value = Integer(value) if value
         value&.positive? ? value : configuration.fetch(:context_window_tokens)
       rescue ArgumentError, TypeError