laiya 0.0.2

data/lib/laiya/provider/codex.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http"
+require "json"
+require "protocol/http/body/streamable"
+require "securerandom"
+
+require_relative "interface"
+require_relative "codex/authentication"
+require_relative "codex/request"
+require_relative "codex/response"
+require_relative "codex/responses"
+require_relative "codex/server_sent_events"
+
+module Laiya
+	module Provider
+		# Adapts OpenAI Chat Completions HTTP to the ChatGPT Codex Responses backend.
+		#
+		# This experimental integration uses the Codex-specific backend, not the public
+		# OpenAI Platform API. Responses API tool calls are returned to the HTTP client;
+		# this provider never executes them.
+		class Codex < Interface
+			DEFAULT_ENDPOINT = "https://chatgpt.com/backend-api/codex"
+			USER_AGENT = "laiya-codex/0.0.0"
+			
+			# 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 :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)
+				@endpoint = Async::HTTP::Endpoint[endpoint]
+				@authentication = authentication || Authentication.new(codex_home: codex_home)
+				@client = client || Async::HTTP::Client.new(@endpoint, **client_options)
+				@owns_client = client.nil?
+			end
+			
+			attr :endpoint
+			
+			# 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.
+			def call(request)
+				path = request.path.split("?", 2).first
+				unless request.method == "POST" && %w[/v1/chat/completions /v1/responses].include?(path)
+					return error_response(404, "Only /v1/chat/completions and /v1/responses are supported", "not_found_error")
+				end
+				
+				payload = JSON.parse(request.read)
+				return error_response(400, "Expected a JSON object", "invalid_request_error") unless payload.is_a?(Hash)
+				
+				responses_api = path == "/v1/responses"
+				if responses_api
+					transformed = Responses.prepare(payload)
+				else
+					if payload["n"] && payload["n"] != 1
+						return error_response(400, "Codex Chat Completions supports n=1 only", "invalid_request_error")
+					end
+					
+					if chat_tools?(payload)
+						return error_response(400, "Codex tool turns require the /v1/responses endpoint", "invalid_request_error")
+					end
+					
+					transformed = Request.transform(payload)
+				end
+				
+				credentials = @authentication.credentials
+				upstream = request_codex(transformed, request, credentials)
+				
+				if upstream.status == 401
+					upstream.close
+					credentials = @authentication.credentials(refresh: true)
+					upstream = request_codex(transformed, request, credentials)
+				end
+				
+				unless upstream.status >= 200 && upstream.status < 300
+					return upstream
+				end
+				
+				if responses_api && payload["stream"]
+					return upstream
+				elsif responses_api
+					return responses_response(upstream)
+				end
+				
+				if payload["stream"]
+					return streaming_response(upstream, request, payload, transformed[:model])
+				end
+				
+				return completion_response(upstream, transformed[:model])
+			rescue JSON::ParserError, KeyError, ArgumentError, TypeError => error
+				error_response(400, error.message, "invalid_request_error")
+			rescue Authentication::Error
+				error_response(502, "Codex authentication failed", "server_error")
+			rescue StandardError
+				error_response(502, "Codex provider request failed", "server_error")
+			end
+			
+			# Close the HTTP client and authentication source when owned.
+			def close
+				@client.close if @owns_client
+				@authentication.close if @authentication.respond_to?(:close)
+			end
+			
+			private
+			
+			def request_codex(payload, request, credentials)
+				headers = Protocol::HTTP::Headers[
+					"accept" => "text/event-stream",
+					"content-type" => "application/json",
+					"authorization" => "Bearer #{credentials.fetch(:access_token)}",
+					"openai-beta" => "responses=experimental",
+					"originator" => "laiya",
+					"user-agent" => USER_AGENT,
+					"session-id" => session_id(request),
+				]
+				
+				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
+				
+				codex_request = Protocol::HTTP::Request[
+					"POST",
+					"#{@endpoint.path.split("?", 2).first.sub(/\/+\z/, "")}/responses",
+					headers,
+					[JSON.dump(payload)],
+				]
+				
+				return @client.call(codex_request)
+			end
+			
+			def completion_response(upstream, model)
+				completed = nil
+				collector = Responses::Collector.new
+				ServerSentEvents.each(upstream.body) do |event|
+					collector.accept(event)
+					case event["type"]
+					when "response.completed", "response.done"
+						completed = collector.complete(event["response"] || event)
+					when "response.failed", "error"
+						message = event.dig("response", "error", "message") || event.dig("error", "message") || "Codex response failed"
+						return error_response(502, message, "server_error")
+					end
+				end
+				
+				unless completed
+					return error_response(502, "Codex ended without a completed response", "server_error")
+				end
+				
+				body = JSON.dump(Response.completed(completed, requested_model: model))
+				return Protocol::HTTP::Response[200, {"content-type" => "application/json"}, [body]]
+			ensure
+				upstream.close
+			end
+			
+			def responses_response(upstream)
+				completed = nil
+				collector = Responses::Collector.new
+				ServerSentEvents.each(upstream.body) do |event|
+					collector.accept(event)
+					case event["type"]
+					when "response.completed", "response.done"
+						completed = collector.complete(event["response"] || event)
+					when "response.failed", "error"
+						message = event.dig("response", "error", "message") || event.dig("error", "message") || "Codex response failed"
+						return error_response(502, message, "server_error")
+					end
+				end
+				
+				unless completed
+					return error_response(502, "Codex ended without a completed response", "server_error")
+				end
+				
+				return Protocol::HTTP::Response[200, {"content-type" => "application/json"}, [JSON.dump(completed)]]
+			ensure
+				upstream.close
+			end
+			
+			def streaming_response(upstream, request, payload, model)
+				body = Protocol::HTTP::Body::Streamable.response(request) do |stream|
+					stream_codex_response(upstream, stream, payload, model)
+				end
+				
+				return Protocol::HTTP::Response[
+					200,
+					{"content-type" => "text/event-stream", "cache-control" => "no-cache"},
+					body,
+				]
+			end
+			
+			def stream_codex_response(upstream, stream, payload, model)
+				state = {
+					id: nil,
+					model: model,
+					created: Time.now.to_i,
+					tools: {},
+					has_tools: false,
+					role_sent: false,
+					completed: false,
+				}
+				
+				ServerSentEvents.each(upstream.body) do |event|
+					stream_chunks(event, state, payload).each do |chunk|
+						stream.write("data: #{JSON.dump(chunk)}\n\n")
+					end
+				end
+				
+				unless state[:completed]
+					stream.write("data: #{JSON.dump(error: {message: "Codex ended without a completed response", type: "server_error"})}\n\n")
+				end
+				
+				stream.write("data: [DONE]\n\n")
+			ensure
+				upstream.close
+				stream.close
+			end
+			
+			def stream_chunks(event, state, payload)
+				case event["type"]
+				when "response.created", "response.in_progress"
+					response = event["response"] || {}
+					state[:id] = response["id"] || state[:id]
+					state[:model] = response["model"] || state[:model]
+					state[:created] = response["created_at"] || state[:created]
+					return [] if state[:role_sent]
+					state[:role_sent] = true
+					return [Response.stream_chunk(**stream_metadata(state), delta: {role: "assistant"})]
+				when "response.output_text.delta"
+					return [Response.stream_chunk(**stream_metadata(state), delta: {content: event["delta"]})]
+				when "response.refusal.delta"
+					return [Response.stream_chunk(**stream_metadata(state), delta: {refusal: event["delta"]})]
+				when "response.output_item.added"
+					item = event["item"] || {}
+					return [] unless item["type"] == "function_call"
+					
+					index = event["output_index"] || state[:tools].length
+					state[:tools][item["id"] || item["call_id"]] = index
+					state[:has_tools] = true
+					tool_call = {index: index, id: item["call_id"] || item["id"], type: "function", function: {name: item["name"], arguments: ""}}
+					return [Response.stream_chunk(**stream_metadata(state), delta: {tool_calls: [tool_call]})]
+				when "response.function_call_arguments.delta"
+					index = state[:tools][event["item_id"]] || event["output_index"] || 0
+					tool_call = {index: index, function: {arguments: event["delta"]}}
+					return [Response.stream_chunk(**stream_metadata(state), delta: {tool_calls: [tool_call]})]
+				when "response.completed", "response.done"
+					response = event["response"] || event
+					state[:id] = response["id"] || state[:id]
+					state[:model] = response["model"] || state[:model]
+					state[:created] = response["created_at"] || state[:created]
+					state[:has_tools] ||= Array(response["output"]).any?{|item| item["type"] == "function_call"}
+					state[:completed] = true
+					finish_reason = state[:has_tools] ? "tool_calls" : "stop"
+					chunks = [Response.stream_chunk(**stream_metadata(state), delta: {}, finish_reason: finish_reason)]
+					
+					if payload.dig("stream_options", "include_usage") && usage = Response.usage(response["usage"])
+						chunks << {id: state[:id], object: "chat.completion.chunk", created: state[:created], model: state[:model], choices: [], usage: usage}
+					end
+					
+					return chunks
+				when "response.failed", "error"
+					message = event.dig("response", "error", "message") || event.dig("error", "message") || "Codex response failed"
+					return [{error: {message: message, type: "server_error"}}]
+				end
+				
+				return []
+			end
+			
+			def stream_metadata(state)
+				{response_id: state[:id], model: state[:model], created: state[:created]}
+			end
+			
+			def session_id(request)
+				Array(request.headers["session-id"]).first || Array(request.headers["x-session-id"]).first || SecureRandom.uuid
+			end
+			
+			def chat_tools?(payload)
+				return true if payload["tools"] && !payload["tools"].empty?
+				return true if payload["tool_choice"]
+				
+				Array(payload["messages"]).any? do |message|
+					message.is_a?(Hash) && (message["role"] == "tool" || message["tool_calls"])
+				end
+			end
+			
+			def error_response(status, message, type)
+				body = {error: {message: message, type: type, param: nil, code: nil}}
+				Protocol::HTTP::Response[status, {"content-type" => "application/json"}, [JSON.dump(body)]]
+			end
+		end
+	end
+end

data/lib/laiya/provider/interface.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Laiya
+	module Provider
+		# Base interface for OpenAI-compatible HTTP providers.
+		class Interface
+			# Forward an HTTP request to the provider.
+			# @parameter request [Protocol::HTTP::Request] The request to forward.
+			# @returns [Protocol::HTTP::Response] The upstream response.
+			# @raises [NotImplementedError] When a subclass does not implement this method.
+			def call(request)
+				raise NotImplementedError
+			end
+		end
+	end
+end

data/lib/laiya/provider/ollama.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "openai"
+
+module Laiya
+	module Provider
+		# Proxies Ollama's OpenAI-compatible HTTP API.
+		class Ollama < OpenAI
+			DEFAULT_ENDPOINT = "http://localhost:11434"
+			
+			# Initialize a provider with Ollama's local endpoint and API-key default.
+			# @option :endpoint [String | Async::HTTP::Endpoint] The Ollama HTTP endpoint.
+			# @option :api_key [String | Nil] The optional bearer token.
+			def initialize(endpoint: DEFAULT_ENDPOINT, api_key: "ollama", **options)
+				super(endpoint: endpoint, api_key: api_key, **options)
+			end
+		end
+	end
+end

data/lib/laiya/provider/openai.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http"
+require_relative "interface"
+
+module Laiya
+	module Provider
+		# Forwards OpenAI-compatible HTTP requests to the OpenAI API.
+		class OpenAI < Interface
+			DEFAULT_ENDPOINT = "https://api.openai.com"
+			HOP_BY_HOP_HEADERS = %w[
+				connection
+				keep-alive
+				proxy-authenticate
+				proxy-authorization
+				te
+				trailer
+				transfer-encoding
+				upgrade
+			].freeze
+			
+			# Initialize a provider for OpenAI or another compatible endpoint.
+			# @option :api_key [String | Nil] The bearer token for the upstream service.
+			# @option :endpoint [String | Async::HTTP::Endpoint] The upstream HTTP endpoint.
+			# @option :client [Interface(:call) | Nil] An optional externally managed HTTP client.
+			# @option :organization [String | Nil] An optional OpenAI organization ID.
+			# @option :project [String | Nil] An optional OpenAI project ID.
+			def initialize(api_key: ENV["OPENAI_API_KEY"], endpoint: DEFAULT_ENDPOINT, client: nil, organization: nil, project: nil, **client_options)
+				@endpoint = Async::HTTP::Endpoint[endpoint]
+				@api_key = api_key
+				@organization = organization
+				@project = project
+				@client = client || Async::HTTP::Client.new(@endpoint, **client_options)
+				@owns_client = client.nil?
+			end
+			
+			attr :endpoint
+			
+			# Fetch the upstream model-list response.
+			# @returns [Protocol::HTTP::Response] The raw model-list response.
+			# Fetch the upstream OpenAI-compatible model list as a raw HTTP response.
+			def models
+				self.call(Protocol::HTTP::Request["GET", "/v1/models"])
+			end
+			
+			# Forward a request without transforming its body.
+			# @parameter request [Protocol::HTTP::Request] The request to send upstream.
+			# @returns [Protocol::HTTP::Response] The unmodified upstream response.
+			def call(request)
+				headers = forwarded_headers(request.headers)
+				headers["authorization"] = "Bearer #{@api_key}" if @api_key
+				headers["openai-organization"] = @organization if @organization
+				headers["openai-project"] = @project if @project
+				
+				upstream_request = Protocol::HTTP::Request.new(
+					@endpoint.scheme,
+					@endpoint.authority,
+					request.method,
+					request.path,
+					request.version,
+					headers,
+					request.body,
+					request.protocol,
+					request.interim_response,
+				)
+				
+				return @client.call(upstream_request)
+			end
+			
+			# Close the HTTP client when this provider created it.
+			def close
+				@client.close if @owns_client
+			end
+			
+			private
+			
+			def forwarded_headers(headers)
+				forwarded = headers.dup
+				connection_headers = Array(headers["connection"]).flat_map{|value| value.split(",")}.map(&:strip)
+				
+				(HOP_BY_HOP_HEADERS + connection_headers + ["host"]).uniq.each do |name|
+					forwarded.delete(name)
+				end
+				
+				return forwarded
+			end
+		end
+	end
+end

data/lib/laiya/provider.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Laiya
+	# Provider interfaces and built-in provider implementations.
+	module Provider
+	end
+end

data/lib/laiya/router.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+
+module Laiya
+	# Selects a configured provider for each OpenAI-compatible HTTP request.
+	class Router
+		MODEL_ENDPOINTS = %w[
+			/v1/chat/completions
+			/v1/completions
+			/v1/embeddings
+			/v1/responses
+			/v1/images/generations
+		].freeze
+		
+		# Initialize a router for the given configuration.
+		# @parameter configuration [Laiya::Configuration] The provider and model routes.
+		def initialize(configuration)
+			@configuration = configuration
+		end
+		
+		# Route an HTTP request to its configured provider.
+		# @parameter request [Protocol::HTTP::Request] The incoming request.
+		# @returns [Protocol::HTTP::Response] The provider response or a routing error.
+		def call(request)
+			provider = provider_for_model(model_for(request))
+			
+			unless provider
+				return Protocol::HTTP::Response[
+					404,
+					{"content-type" => "application/json"},
+					[JSON.dump(error: {message: "No provider is configured for this request", type: "not_found_error"})],
+				]
+			end
+			
+			return provider.call(request)
+		end
+		
+		# Return the configured model catalog, if present.
+		def models_response
+			return if @configuration.models.empty?
+			models = @configuration.models.each(default_provider: @configuration.default_provider).to_a
+			
+			Protocol::HTTP::Response[
+				200,
+				{"content-type" => "application/json"},
+				[JSON.dump(object: "list", data: models)],
+			]
+		end
+		
+		# Close configured providers that support closing.
+		def close
+			@configuration.providers.values.uniq.each do |provider|
+				provider.close if provider.respond_to?(:close)
+			end
+		end
+		
+		private
+		
+		def provider_for_model(model)
+			return @configuration.provider_for_model(model)
+		end
+		
+		def model_for(request)
+			return unless request.method == "POST" && MODEL_ENDPOINTS.include?(request.path.split("?", 2).first)
+			return unless request.headers["content-type"]&.start_with?("application/json")
+			return unless request.body
+			
+			request.buffered!
+			
+			begin
+				body = request.body.chunks.join
+				payload = JSON.parse(body)
+				payload["model"] if payload.is_a?(Hash)
+			rescue JSON::ParserError, TypeError
+				nil
+			ensure
+				request.rewind!
+			end
+		end
+	end
+end

data/lib/laiya/service/application.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http"
+require "async/service/managed/service"
+require_relative "../web/application"
+
+module Laiya
+	# @namespace
+	module Service
+		# Runs the Laiya API application on Async::HTTP::Server.
+		class Application < Async::Service::Managed::Service
+			# Bind the service endpoint when the service starts.
+			# @returns [Nil] The result of the superclass start hook.
+			def start
+				super
+				
+				@endpoint = @evaluator.endpoint
+				@bound_endpoint = Sync{@endpoint.bound}
+			end
+			
+			# Close the bound endpoint and API application when stopping.
+			# @returns [Nil] The result of the superclass stop hook.
+			def stop
+				@bound_endpoint&.close
+				@application&.close
+				
+				super
+			end
+			
+			# Run one Async HTTP server instance.
+			# @parameter instance [Object] The managed service instance.
+			# @parameter evaluator [Object] The service environment evaluator.
+			# @returns [Object] The running HTTP server task.
+			def run(instance, evaluator)
+				@application = evaluator.application
+				server = Async::HTTP::Server.new(
+					@application,
+					@bound_endpoint,
+					protocol: @endpoint.protocol,
+					scheme: @endpoint.scheme,
+				)
+				
+				return server.run
+			end
+		end
+	end
+end

data/lib/laiya/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Laiya
+	VERSION = "0.0.2"
+end

data/lib/laiya/web/application.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+require "protocol/http/middleware"
+require_relative "../router"
+
+module Laiya
+	# @namespace
+	module Web
+		# OpenAI-compatible HTTP API application.
+		class Application < Protocol::HTTP::Middleware
+			# Initialize the API middleware with a configuration.
+			# @parameter configuration [Laiya::Configuration] Provider and model routing settings.
+			def initialize(configuration:)
+				@configuration = configuration
+				@router = Laiya::Router.new(configuration)
+			end
+			
+			attr :configuration
+			
+			# Handle a model-list request or proxy a request to its provider.
+			# @parameter request [Protocol::HTTP::Request] The incoming HTTP request.
+			# @returns [Protocol::HTTP::Response] The API response.
+			def call(request)
+				if request.method == "GET" && request.path == "/v1/models" && (response = @router.models_response)
+					return response
+				end
+				
+				return @router.call(request)
+			rescue StandardError
+				return Protocol::HTTP::Response[
+					502,
+					{"content-type" => "application/json"},
+					[JSON.dump(error: {message: "Upstream provider request failed", type: "server_error"})],
+				]
+			end
+			
+			# Close all providers owned by the application.
+			def close
+				@router.close
+			end
+			
+		end
+	end
+end

data/lib/laiya/web.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "web/application"

data/lib/laiya.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "laiya/version"
+require_relative "laiya/models/discover"
+require_relative "laiya/configuration"
+require_relative "laiya/provider"
+require_relative "laiya/provider/interface"
+require_relative "laiya/provider/openai"
+require_relative "laiya/provider/codex"
+require_relative "laiya/provider/ollama"
+require_relative "laiya/router"
+require_relative "laiya/web/application"
+
+# @namespace
+module Laiya
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.