laiya 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 665e132b315d14e0d867411d06e49c015ed8bfe18f50e3ee15623eee73a90e6e
-  data.tar.gz: 693d030853123c19d1dda07fda06fac7d6c6b8a8d4b9db7a488cbda3e8ef2add
+  metadata.gz: f1d79e801894376e7f3a398c48d22f0c5b0100760751dc8fecb63c044f665de4
+  data.tar.gz: 9a72dbf43fc8eba78543c3d8de3acdbd25072b0db940688f21ffa0fff5dc9b93
 SHA512:
-  metadata.gz: 6bb1a3cc19e46eaf6908343327edeb7c4af1867b07016962b4a6a70c22d7f31e44aa3bdf644f6a26ad2ed4d152dfe041f3d416a912aea00005076f988f60c198
-  data.tar.gz: '015801fda685fe3fc0e3fe1d792784fdd4aaa6255e04d6e1d0ea29dc72b5c4360d513834e5681d4ca3b4092067231548e43bf87773b0066930ab4677bdaeac34'
+  metadata.gz: cc9253bf7a64e2ca4cf8b6fbdf316db4a625af93c9232943c5faa25f6d726002ece63158f38d1acc967b5b5db5fd849a7cc9801d5f207c9f0cca529da5ef968d
+  data.tar.gz: be8830a0dee2d6f0fc1219035ccce4de588704706aae3c2f4b3c459d3556e234f629dec67283c84be52cdbf3e429055d6019d4e965fa1448f01e50504ea16ab3

data/context/providers-and-models.md

@@ -73,6 +73,42 @@ token counts. OpenCode does not currently infer these custom fields from
 `limit.output` values on each client as well. The `context` limit should match
 the effective upstream model configuration (for Ollama, including `num_ctx`).
 
+## Expose Ollama Thinking Controls
+
+When Ollama model discovery is enabled, Laiya also queries `/api/show` for each
+model and publishes available thinking controls under `laiya.reasoning`. Named
+levels appear as `supported_efforts` with a `default_effort`; boolean-only
+controls appear as `thinking_values` with a `default_thinking`. If a model has
+no thinking metadata, advertises only `[false]`, or `/api/show` is unavailable,
+Laiya still lists it without reasoning metadata.
+
+The OpenAI-compatible proxy already forwards `reasoning_effort` requests to
+Ollama. OpenCode custom providers do not automatically turn Laiya's extension
+metadata into variants, so configure variants from the discovered values in
+each OpenCode model entry:
+
+```jsonc
+{
+	"providers": {
+		"laiya": {
+			"models": {
+				"qwen3-coder": {
+					"modelID": "qwen3-coder:latest",
+					"variants": [
+						{"id": "low", "body": {"reasoning_effort": "low"}},
+						{"id": "medium", "body": {"reasoning_effort": "medium"}},
+						{"id": "high", "body": {"reasoning_effort": "high"}},
+					],
+				},
+			},
+		},
+	},
+}
+```
+
+Only configure variants advertised by the selected model. Thinking metadata and
+supported levels are model-specific.
+
 ## Customize Discovery
 
 Subclass `Laiya::Models::Discover` to filter models or attach provider-specific

data/examples/chatgpt/readme.md

@@ -43,11 +43,13 @@ behind TLS and an access-controlled gateway. The service requires the caller to
 send the `LAIYA_API_KEY` as a Bearer token; this is separate from the Codex
 credentials used upstream.
 
-`LAIYA_CHATGPT_MODEL` selects the model exposed by `GET /v1/models` and sent to
-the Codex backend. It defaults to `gpt-6-luna`; set it to a model available to
-your account. Set `CODEX_HOME` if the credential file is in a non-default
-directory. `LAIYA_URL` can change the bind endpoint; do not bind publicly
-without TLS and network access controls.
+The Codex provider discovers account-visible, API-supported models from the
+authenticated Codex model catalog and refreshes the discovered list periodically.
+The provider detects the installed Codex CLI version for the catalog request;
+set `CODEX_CLIENT_VERSION` to override it if the CLI is unavailable on the
+service's `PATH` or you need to use a different version. Set `CODEX_HOME` if the
+credential file is in a non-default directory. `LAIYA_URL` can change the bind
+endpoint; do not bind publicly without TLS and network access controls.
 
 ## Try it
 
@@ -79,29 +81,43 @@ available because the Codex backend is used statelessly.
 ## Connect OpenCode from another computer
 
 Put the service behind TLS and an access-controlled network gateway, then add a
-custom Responses-capable OpenAI provider to OpenCode. Keep the Laiya API key in
-the client machine's secret configuration rather than committing it:
+custom Responses-compatible provider to OpenCode. Codex tool turns require
+`/v1/responses`; the Chat Completions adapter intentionally rejects them. Keep
+the Laiya API key in the client machine's secret configuration rather than
+committing it:
 
-```json
+```jsonc
 {
-  "$schema": "https://opencode.ai/config.json",
-  "provider": {
-    "laiya": {
-      "npm": "@ai-sdk/openai",
-      "name": "Laiya Codex",
-      "options": {
-        "baseURL": "https://laiya.example.com/v1",
-        "apiKey": "<LAIYA_API_KEY>"
-      },
-      "models": {
-        "gpt-6-luna": {"name": "GPT-6 Luna"}
-      }
-    }
-  },
-  "model": "laiya/gpt-6-luna"
+	"$schema": "https://opencode.ai/config.json",
+	"providers": {
+		"laiya-codex": {
+			"name": "Laiya Codex",
+			"env": ["LAIYA_API_KEY"],
+			"package": "@opencode/ai/providers/openai-compatible/responses",
+			"settings": {
+				"baseURL": "https://laiya.example.com/v1",
+			},
+			"models": {
+				"gpt-6-luna": {
+					"name": "GPT-6 Luna",
+					"variants": [
+						{"id": "low", "settings": {"reasoningEffort": "low"}},
+						{"id": "medium", "settings": {"reasoningEffort": "medium"}},
+						{"id": "high", "settings": {"reasoningEffort": "high"}},
+						{"id": "xhigh", "settings": {"reasoningEffort": "xhigh"}},
+						{"id": "max", "settings": {"reasoningEffort": "max"}},
+					],
+				},
+			},
+		},
+	},
+	"model": "laiya-codex/gpt-6-luna",
 }
 ```
 
-OpenCode uses `/v1/responses` for this provider. The model can return tool calls,
-which OpenCode executes on the client computer and reports back on subsequent
-requests; Laiya never executes client tools.
+Codex entries returned by `GET /v1/models` include the supported reasoning
+efforts in `laiya.reasoning.supported_efforts` and the default in
+`laiya.reasoning.default_effort`. Use those values to configure OpenCode's
+model variants; its custom-provider model list remains explicit. The model can
+return tool calls, which OpenCode executes on the client computer and reports
+back on subsequent requests; Laiya never executes client tools.

data/examples/chatgpt/service.rb

@@ -17,8 +17,8 @@ configuration = Async::Service::Configuration.build do
 		
 		configuration do
 			Laiya::Configuration.build do |builder|
-				builder.provider :codex, Laiya::Provider::Codex.new
-				builder.model ENV.fetch("LAIYA_CHATGPT_MODEL", "gpt-6-luna"), provider: :codex
+				codex = Laiya::Provider::Codex.new
+				builder.provider :codex, codex, models: :discover
 				builder.default_provider :codex
 			end
 		end

data/guides/providers-and-models/readme.md

@@ -73,6 +73,42 @@ token counts. OpenCode does not currently infer these custom fields from
 `limit.output` values on each client as well. The `context` limit should match
 the effective upstream model configuration (for Ollama, including `num_ctx`).
 
+## Expose Ollama Thinking Controls
+
+When Ollama model discovery is enabled, Laiya also queries `/api/show` for each
+model and publishes available thinking controls under `laiya.reasoning`. Named
+levels appear as `supported_efforts` with a `default_effort`; boolean-only
+controls appear as `thinking_values` with a `default_thinking`. If a model has
+no thinking metadata, advertises only `[false]`, or `/api/show` is unavailable,
+Laiya still lists it without reasoning metadata.
+
+The OpenAI-compatible proxy already forwards `reasoning_effort` requests to
+Ollama. OpenCode custom providers do not automatically turn Laiya's extension
+metadata into variants, so configure variants from the discovered values in
+each OpenCode model entry:
+
+```jsonc
+{
+	"providers": {
+		"laiya": {
+			"models": {
+				"qwen3-coder": {
+					"modelID": "qwen3-coder:latest",
+					"variants": [
+						{"id": "low", "body": {"reasoning_effort": "low"}},
+						{"id": "medium", "body": {"reasoning_effort": "medium"}},
+						{"id": "high", "body": {"reasoning_effort": "high"}},
+					],
+				},
+			},
+		},
+	},
+}
+```
+
+Only configure variants advertised by the selected model. Thinking metadata and
+supported levels are model-specific.
+
 ## Customize Discovery
 
 Subclass `Laiya::Models::Discover` to filter models or attach provider-specific

data/lib/laiya/provider/codex.rb

@@ -5,8 +5,10 @@
 
 require "async/http"
 require "json"
+require "open3"
 require "protocol/http/body/streamable"
 require "securerandom"
+require "uri"
 
 require_relative "interface"
 require_relative "codex/authentication"
@@ -26,20 +28,66 @@ module Laiya
 			DEFAULT_ENDPOINT = "https://chatgpt.com/backend-api/codex"
 			USER_AGENT = "laiya-codex/0.0.0"
 			
+			# Return the configured or installed Codex CLI version.
+			# @returns [String | Nil] The Codex CLI version, or `nil` when it cannot be detected.
+			def self.client_version
+				if version = ENV["CODEX_CLIENT_VERSION"]
+					return version unless version.empty?
+				end
+				
+				output, status = Open3.capture2("codex", "--version")
+				return unless status.success?
+				
+				return output[/\bcodex(?:-cli)?\s+(\S+)/, 1]
+			rescue Errno::ENOENT
+				nil
+			end
+			
 			# Initialize the experimental ChatGPT Codex API adapter.
 			# @option :authentication [Interface(:credentials) | Nil] A credential source.
 			# @option :codex_home [String] The Codex home directory containing `auth.json`.
+			# @option :client_version [String | Nil] The Codex CLI version used for model discovery; defaults to `CODEX_CLIENT_VERSION` or `codex --version`.
 			# @option :endpoint [String | Async::HTTP::Endpoint] The Codex backend endpoint.
 			# @option :client [Interface(:call) | Nil] An optional HTTP client.
-			def initialize(authentication: nil, codex_home: ENV.fetch("CODEX_HOME", Authentication::DEFAULT_CODEX_HOME), endpoint: DEFAULT_ENDPOINT, client: nil, **client_options)
+			def initialize(authentication: nil, codex_home: ENV.fetch("CODEX_HOME", Authentication::DEFAULT_CODEX_HOME), client_version: ENV["CODEX_CLIENT_VERSION"], endpoint: DEFAULT_ENDPOINT, client: nil, **client_options)
 				@endpoint = Async::HTTP::Endpoint[endpoint]
 				@authentication = authentication || Authentication.new(codex_home: codex_home)
+				@client_version = client_version
+				@client_version_detected = client_version && !client_version.empty?
 				@client = client || Async::HTTP::Client.new(@endpoint, **client_options)
 				@owns_client = client.nil?
 			end
 			
 			attr :endpoint
 			
+			# Fetch and normalize the authenticated Codex model catalog.
+			# @returns [Protocol::HTTP::Response] The OpenAI-compatible model list.
+			def models
+				client_version = self.client_version
+				unless client_version
+					return error_response(500, "Set CODEX_CLIENT_VERSION or install the Codex CLI to discover models", "server_error")
+				end
+				
+				credentials = @authentication.credentials
+				upstream = request_models(credentials, client_version)
+				
+				if upstream.status == 401
+					upstream.close
+					credentials = @authentication.credentials(refresh: true)
+					upstream = request_models(credentials, client_version)
+				end
+				
+				unless upstream.status >= 200 && upstream.status < 300
+					return upstream
+				end
+				
+				model_catalog_response(upstream)
+			rescue Authentication::Error
+				error_response(502, "Codex authentication failed", "server_error")
+			rescue StandardError
+				error_response(502, "Codex model discovery failed", "server_error")
+			end
+			
 			# Convert supported Chat Completions requests or proxy Responses requests.
 			# @parameter request [Protocol::HTTP::Request] The incoming OpenAI-compatible request.
 			# @returns [Protocol::HTTP::Response] The translated or proxied response.
@@ -107,6 +155,85 @@ module Laiya
 			
 			private
 			
+			def client_version
+				return @client_version if @client_version_detected
+				
+				@client_version_detected = true
+				@client_version = self.class.client_version
+			end
+			
+			def request_models(credentials, client_version)
+				path = "#{@endpoint.path.split("?", 2).first.sub(/\/+\z/, "")}/models?#{URI.encode_www_form(client_version: client_version)}"
+				
+				headers = Protocol::HTTP::Headers[
+					"accept" => "application/json",
+					"authorization" => "Bearer #{credentials.fetch(:access_token)}",
+					"originator" => "laiya",
+					"user-agent" => USER_AGENT,
+				]
+				
+				if account_id = credentials[:account_id]
+					headers["chatgpt-account-id"] = account_id
+				end
+				
+				if residency = credentials[:residency]
+					headers["x-openai-internal-codex-residency"] = residency
+				end
+				
+				return @client.call(Protocol::HTTP::Request["GET", path, headers])
+			end
+			
+			def model_catalog_response(upstream)
+				payload = JSON.parse(upstream.read)
+				models = payload.fetch("models")
+				unless models.is_a?(Array)
+					return error_response(502, "Codex model catalog was invalid", "server_error")
+				end
+				
+				data = models.filter_map{|model| normalize_model(model)}
+				return Protocol::HTTP::Response[
+					200,
+					{"content-type" => "application/json"},
+					[JSON.dump(object: "list", data: data)],
+				]
+			rescue JSON::ParserError, KeyError, TypeError
+				error_response(502, "Codex model catalog was invalid", "server_error")
+			ensure
+				upstream.close
+			end
+			
+			def normalize_model(model)
+				return unless model.is_a?(Hash)
+				return unless model["supported_in_api"] == true && model["visibility"] == "list"
+				
+				id = model["slug"]
+				return unless id.is_a?(String) && !id.empty?
+				
+				metadata = {}
+				metadata["name"] = model["display_name"] if model["display_name"].is_a?(String)
+				if (context = model["context_window"]).is_a?(Integer) && context.positive?
+					metadata["limits"] = {"context" => context}
+				end
+				efforts = Array(model["supported_reasoning_levels"]).filter_map do |level|
+					level["effort"] if level.is_a?(Hash) && level["effort"].is_a?(String) && !level["effort"].empty?
+				end.uniq
+				if efforts.any?
+					reasoning = {"supported_efforts" => efforts}
+					if efforts.include?(default_effort = model["default_reasoning_level"])
+						reasoning["default_effort"] = default_effort
+					end
+					metadata["reasoning"] = reasoning
+				end
+				
+				{
+					"id" => id,
+					"object" => "model",
+					"created" => 0,
+					"owned_by" => "codex",
+					"laiya" => metadata,
+				}
+			end
+			
 			def request_codex(payload, request, credentials)
 				headers = Protocol::HTTP::Headers[
 					"accept" => "text/event-stream",

data/lib/laiya/provider/ollama.rb

@@ -3,6 +3,8 @@
 # Released under the MIT License.
 # Copyright, 2026, by Samuel Williams.
 
+require "json"
+
 require_relative "openai"
 
 module Laiya
@@ -17,6 +19,90 @@ module Laiya
 			def initialize(endpoint: DEFAULT_ENDPOINT, api_key: "ollama", **options)
 				super(endpoint: endpoint, api_key: api_key, **options)
 			end
+			
+			# Fetch Ollama's model list and add supported thinking metadata.
+			# @returns [Protocol::HTTP::Response] The enriched OpenAI-compatible model list.
+			def models
+				response = super
+				return response unless response.status >= 200 && response.status < 300
+				
+				enrich_models(response)
+			end
+			
+			private
+			
+			def enrich_models(response)
+				payload = JSON.parse(response.read)
+				models = payload.fetch("data")
+				unless models.is_a?(Array)
+					return model_catalog_error
+				end
+				
+				payload["data"] = models.map{|model| enrich_model(model)}
+				return Protocol::HTTP::Response[
+					200,
+					{"content-type" => "application/json"},
+					[JSON.dump(payload)],
+				]
+			rescue JSON::ParserError, KeyError, TypeError
+				model_catalog_error
+			ensure
+				response.close
+			end
+			
+			def enrich_model(model)
+				return model unless model.is_a?(Hash)
+				return model unless model["id"].is_a?(String) && !model["id"].empty?
+				
+				response = self.call(Protocol::HTTP::Request[
+					"POST",
+					"/api/show",
+					{"content-type" => "application/json"},
+					[JSON.dump(model: model["id"])],
+				])
+				return model unless response.status >= 200 && response.status < 300
+				
+				thinking = JSON.parse(response.read)["thinking"]
+				reasoning = normalize_reasoning(thinking)
+				return model unless reasoning
+				
+				metadata = model["laiya"].is_a?(Hash) ? model["laiya"].dup : {}
+				metadata["reasoning"] = reasoning
+				return model.merge("laiya" => metadata)
+			rescue StandardError
+				return model
+			ensure
+				response&.close
+			end
+			
+			def normalize_reasoning(thinking)
+				return unless thinking.is_a?(Hash)
+				
+				values = Array(thinking["values"]).select do |value|
+					(value.is_a?(String) && !value.empty?) || value == true || value == false
+				end.uniq
+				return if values.empty? || values == [false]
+				
+				result = {"thinking_values" => values}
+				default = thinking["default"]
+				result["default_thinking"] = default if values.include?(default)
+				
+				efforts = values.grep(String)
+				unless efforts.empty?
+					result["supported_efforts"] = efforts
+					result["default_effort"] = default if efforts.include?(default)
+				end
+				
+				return result
+			end
+			
+			def model_catalog_error
+				Protocol::HTTP::Response[
+					502,
+					{"content-type" => "application/json"},
+					[JSON.dump(error: {message: "Ollama model catalog was invalid", type: "server_error"})],
+				]
+			end
 		end
 	end
 end

data/lib/laiya/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2026, by Samuel Williams.
 
 module Laiya
-	VERSION = "0.0.2"
+	VERSION = "0.0.3"
 end

data/readme.md

@@ -30,6 +30,12 @@ Please see the [project documentation](https://socketry.github.io/laiya/) for mo
 
 Please see the [project releases](https://socketry.github.io/laiya/releases/index) for all releases.
 
+### v0.0.3
+
+  - Enrich discovered Ollama models with thinking controls from `/api/show`.
+  - Discover account-visible Codex models and reasoning capabilities from the authenticated model catalog.
+  - Document a Responses-compatible OpenCode provider for Codex tool calling.
+
 ### v0.0.2
 
   - Add Laiya's OpenAI-compatible HTTP API and Async::Service launcher.

data/releases.md

@@ -1,5 +1,11 @@
 # Releases
 
+## v0.0.3
+
+  - Enrich discovered Ollama models with thinking controls from `/api/show`.
+  - Discover account-visible Codex models and reasoning capabilities from the authenticated model catalog.
+  - Document a Responses-compatible OpenCode provider for Codex tool calling.
+
 ## v0.0.2
 
   - Add Laiya's OpenAI-compatible HTTP API and Async::Service launcher.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: laiya
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Samuel Williams