laiya 0.0.2

data/lib/laiya/provider/codex/authentication.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async"
+require "async/http"
+require "base64"
+require "fileutils"
+require "json"
+require "tempfile"
+require "time"
+require "uri"
+
+module Laiya
+	module Provider
+		class Codex < Interface
+			# Loads and refreshes the local Codex CLI ChatGPT credentials.
+			class Authentication
+				CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
+				ISSUER = "https://auth.openai.com"
+				DEFAULT_CODEX_HOME = File.expand_path("~/.codex")
+				REFRESH_AFTER = 7 * 24 * 60 * 60
+				EXPIRY_SAFETY_MARGIN = 5 * 60
+				
+				# Raised when Codex credentials are missing, invalid, or cannot be refreshed.
+				class Error < StandardError
+				end
+				
+				# Initialize credential loading for a Codex home directory.
+				# @option :codex_home [String] The directory containing `auth.json`.
+				# @option :client [Interface(:call) | Nil] An optional OAuth HTTP client.
+				# @option :endpoint [String | Async::HTTP::Endpoint] The OAuth issuer endpoint.
+				def initialize(codex_home: ENV.fetch("CODEX_HOME", DEFAULT_CODEX_HOME), client: nil, endpoint: ISSUER)
+					@codex_home = codex_home
+					@auth_path = File.join(codex_home, "auth.json")
+					@endpoint = Async::HTTP::Endpoint[endpoint]
+					@client = client || Async::HTTP::Client.new(@endpoint)
+					@owns_client = client.nil?
+					@semaphore = Async::Semaphore.new(1)
+				end
+				
+				# Load valid credentials and refresh them when requested or stale.
+				# @option :refresh [Boolean] Force a credential refresh.
+				# @returns [Hash] The access token, account ID, and optional residency.
+				# @raises [Laiya::Provider::Codex::Authentication::Error] If the credentials cannot be used.
+				def credentials(refresh: false)
+					@semaphore.acquire do
+						with_auth_lock do
+							document = read_auth
+							validate_auth(document)
+							tokens = document.fetch("tokens")
+							
+							if refresh || stale?(tokens, document)
+								document = refresh_auth(document)
+								tokens = document.fetch("tokens")
+							end
+							
+							account = account_id(tokens)
+							raise Error, "Codex ChatGPT account ID is missing" unless account
+							
+							{
+								access_token: tokens.fetch("access_token"),
+								account_id: account,
+								residency: residency(tokens.fetch("access_token")),
+							}
+						end
+					end
+				end
+				
+				# Close the OAuth client when this object created it.
+				def close
+					@client.close if @owns_client
+				end
+				
+				private
+				
+				def with_auth_lock
+					FileUtils.mkdir_p(@codex_home, mode: 0o700)
+					File.open("#{@auth_path}.laiya.lock", File::RDWR|File::CREAT, 0o600) do |lock|
+						lock.flock(File::LOCK_EX)
+						return yield
+					ensure
+						lock.flock(File::LOCK_UN)
+					end
+				end
+				
+				def read_auth
+					JSON.parse(File.read(@auth_path))
+				rescue Errno::ENOENT
+					raise Error, "Codex auth.json is missing; log in with `codex login` and use file credential storage"
+				rescue JSON::ParserError
+					raise Error, "Codex auth.json could not be parsed"
+				end
+				
+				def validate_auth(document)
+					unless document["auth_mode"] == "chatgpt" && document["tokens"].is_a?(Hash)
+						raise Error, "Codex auth.json does not contain a ChatGPT login"
+					end
+					
+					unless document.dig("tokens", "access_token") && document.dig("tokens", "refresh_token")
+						raise Error, "Codex ChatGPT credentials are incomplete"
+					end
+				end
+				
+				def stale?(tokens, document)
+					if expires_at = jwt_claims(tokens["access_token"])&.fetch("exp", nil)
+						return expires_at.to_i <= Time.now.to_i + EXPIRY_SAFETY_MARGIN
+					end
+					
+					last_refresh = Time.parse(document["last_refresh"]) rescue nil
+					return true unless last_refresh
+					
+					Time.now - last_refresh >= REFRESH_AFTER
+				end
+				
+				def refresh_auth(document)
+					tokens = document.fetch("tokens")
+					form = URI.encode_www_form({
+						grant_type: "refresh_token",
+						refresh_token: tokens.fetch("refresh_token"),
+						client_id: CLIENT_ID,
+					})
+					headers = {"content-type" => "application/x-www-form-urlencoded", "accept" => "application/json"}
+					request = Protocol::HTTP::Request["POST", "/oauth/token", headers, [form]]
+					
+					response = @client.call(request)
+					unless response.status == 200
+						status = response.status
+						response.close
+						raise Error, "Codex credential refresh failed with HTTP #{status}"
+					end
+					
+					begin
+						refreshed = JSON.parse(response.read)
+					ensure
+						response.close
+					end
+					tokens["access_token"] = refreshed.fetch("access_token")
+					tokens["refresh_token"] = refreshed["refresh_token"] || tokens.fetch("refresh_token")
+					document["last_refresh"] = Time.now.utc.iso8601
+					save_auth(document)
+					
+					return document
+				rescue JSON::ParserError, KeyError
+					raise Error, "Codex credential refresh returned an invalid response"
+				end
+				
+				def save_auth(document)
+					Tempfile.create("auth.json", @codex_home) do |file|
+						file.chmod(0o600)
+						file.write(JSON.pretty_generate(document))
+						file.flush
+						file.fsync
+						File.rename(file.path, @auth_path)
+					end
+				end
+				
+				def account_id(tokens)
+					return tokens["account_id"] if tokens["account_id"]
+					
+					claims = jwt_claims(tokens["id_token"])
+					claims&.fetch("chatgpt_account_id", nil) || claims&.dig("https://api.openai.com/auth", "chatgpt_account_id")
+				end
+				
+				def residency(access_token)
+					claims = jwt_claims(access_token)
+					value = claims&.fetch("chatgpt_compute_residency", nil) || claims&.dig("https://api.openai.com/auth", "chatgpt_compute_residency")
+					value unless value.nil? || value == "no_constraint"
+				end
+				
+				def jwt_claims(token)
+					return unless token.is_a?(String)
+					
+					payload = token.split(".")[1]
+					return unless payload
+					
+					JSON.parse(Base64.urlsafe_decode64(payload))
+				rescue ArgumentError, JSON::ParserError
+					nil
+				end
+			end
+		end
+	end
+end

data/lib/laiya/provider/codex/request.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+
+module Laiya
+	module Provider
+		class Codex < Interface
+			# Converts OpenAI Chat Completions requests into Codex Responses input.
+			module Request
+				module_function
+				
+				# Transform a Chat Completions payload into a Codex Responses request.
+				# @parameter payload [Hash] The Chat Completions request object.
+				# @returns [Hash] The Codex Responses request payload.
+				# @raises [ArgumentError, KeyError] If the request contains unsupported input.
+				def transform(payload)
+					messages = payload.fetch("messages")
+					raise ArgumentError, "messages must be an array" unless messages.is_a?(Array)
+					
+					instructions = []
+					input = []
+					
+					messages.each do |message|
+						raise ArgumentError, "each message must be an object" unless message.is_a?(Hash)
+						
+						role = message.fetch("role", "user")
+						
+						case role
+						when "system", "developer"
+							instructions << text(message.fetch("content", ""))
+						when "tool"
+							input << {
+								type: "function_call_output",
+								call_id: message.fetch("tool_call_id"),
+								output: text(message.fetch("content", "")),
+							}
+						else
+							raise ArgumentError, "unsupported message role: #{role}" unless %w[user assistant].include?(role)
+							
+							content = message.fetch("content", "")
+							input << {role: role, content: text(content)} unless text(content).empty?
+							
+							if role == "assistant"
+								Array(message["tool_calls"]).each do |tool_call|
+									function = tool_call.fetch("function")
+									input << {
+										type: "function_call",
+										call_id: tool_call.fetch("id"),
+										name: function.fetch("name"),
+										arguments: function.fetch("arguments", "{}"),
+									}
+								end
+							end
+						end
+					end
+					
+					result = {
+						model: payload.fetch("model"),
+						input: input,
+						store: false,
+						stream: true,
+						include: ["reasoning.encrypted_content"],
+					}
+					
+					unless instructions.empty?
+						result[:instructions] = instructions.join("\n\n")
+					end
+					
+					%w[parallel_tool_calls temperature top_p].each do |key|
+						result[key.to_sym] = payload[key] if payload.key?(key)
+					end
+					
+					if max_tokens = payload["max_completion_tokens"] || payload["max_tokens"]
+						result[:max_output_tokens] = max_tokens
+					end
+					
+					if effort = payload["reasoning_effort"]
+						result[:reasoning] = {effort: effort, summary: "auto"}
+					end
+					
+					if response_format = transform_response_format(payload["response_format"])
+						result[:text] = {format: response_format}
+					end
+					
+					return result
+				end
+				
+				# Convert an OpenAI response format into Codex text formatting options.
+				# @parameter format [Hash | Nil] The requested response format.
+				# @returns [Hash | Nil] The corresponding Codex format, if provided.
+				# @raises [ArgumentError, KeyError] If the format is invalid or unsupported.
+				def transform_response_format(format)
+					return unless format
+					raise ArgumentError, "response_format must be an object" unless format.is_a?(Hash)
+					
+					case format["type"]
+					when "text"
+						{type: "text"}
+					when "json_object"
+						{type: "json_object"}
+					when "json_schema"
+						schema = format.fetch("json_schema")
+						{
+							type: "json_schema",
+							name: schema.fetch("name"),
+						schema: schema.fetch("schema"),
+						strict: schema["strict"],
+						}.compact
+					else
+						raise ArgumentError, "unsupported response_format"
+					end
+				end
+				
+				# Extract text from supported message content shapes.
+				# @parameter content [String | Array | Nil] The message content.
+				# @returns [String] The concatenated text content.
+				# @raises [ArgumentError] If the content type is unsupported.
+				def text(content)
+					return "" if content.nil?
+					return content if content.is_a?(String)
+					
+					if content.is_a?(Array)
+						return content.filter_map do |part|
+							part["text"] if part.is_a?(Hash) && %w[text input_text].include?(part["type"])
+						end.join
+					end
+					
+					raise ArgumentError, "only text message content is currently supported"
+				end
+			end
+		end
+	end
+end

data/lib/laiya/provider/codex/response.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+require "securerandom"
+
+module Laiya
+	module Provider
+		class Codex < Interface
+			# Converts Codex Responses API results into OpenAI Chat Completions.
+			module Response
+				module_function
+				
+				# Convert a completed Responses object to Chat Completions format.
+				# @parameter response [Hash] The completed Codex response.
+				# @option :requested_model [String | Nil] The model requested by the client.
+				# @returns [Hash] A Chat Completions response object.
+				def completed(response, requested_model: nil)
+					output = response.fetch("output", [])
+					content = []
+					tool_calls = []
+					
+					output.each do |item|
+						case item["type"]
+						when "message"
+							Array(item["content"]).each do |part|
+								content << part["text"] if part["type"] == "output_text" && part["text"]
+								content << part["refusal"] if part["type"] == "refusal" && part["refusal"]
+							end
+						when "function_call"
+							tool_calls << {
+								id: item["call_id"] || item["id"],
+								type: "function",
+								function: {
+									name: item["name"],
+									arguments: json_arguments(item["arguments"]),
+								},
+							}
+						end
+					end
+					
+					message = {role: "assistant", content: content.empty? ? nil : content.join}
+					message[:tool_calls] = tool_calls unless tool_calls.empty?
+					usage = usage(response["usage"])
+					result = {
+						id: completion_id(response["id"]),
+						object: "chat.completion",
+						created: response["created_at"] || Time.now.to_i,
+						model: response["model"] || requested_model,
+						choices: [{index: 0, message: message, finish_reason: tool_calls.empty? ? "stop" : "tool_calls"}],
+					}
+					result[:usage] = usage if usage
+					
+					return result
+				end
+				
+				# Build a Chat Completions streaming chunk.
+				# @parameter response_id [String | Nil] The Codex response ID.
+				# @parameter model [String | Nil] The response model name.
+				# @parameter created [Integer | Nil] The creation timestamp.
+				# @parameter delta [Hash] The incremental assistant message.
+				# @option :finish_reason [String | Nil] The terminal reason, if final.
+				# @option :usage [Hash | Nil] Token usage for the response.
+				# @returns [Hash] A Chat Completions chunk.
+				def stream_chunk(response_id:, model:, created:, delta:, finish_reason: nil, usage: nil)
+					chunk = {
+						id: completion_id(response_id),
+						object: "chat.completion.chunk",
+						created: created || Time.now.to_i,
+						model: model,
+						choices: [{index: 0, delta: delta, finish_reason: finish_reason}],
+					}
+					chunk[:usage] = usage if usage
+					return chunk
+				end
+				
+				# Convert Codex input and output token counts to OpenAI usage fields.
+				# @parameter value [Hash | Nil] Codex usage information.
+				# @returns [Hash | Nil] OpenAI-compatible usage details.
+				def usage(value)
+					return unless value.is_a?(Hash)
+					
+					input_tokens = value["input_tokens"]
+					output_tokens = value["output_tokens"]
+					return unless input_tokens && output_tokens
+					
+					{
+						prompt_tokens: input_tokens,
+						completion_tokens: output_tokens,
+						total_tokens: value["total_tokens"] || input_tokens + output_tokens,
+						prompt_tokens_details: {cached_tokens: value.dig("input_tokens_details", "cached_tokens") || 0},
+					}
+				end
+				
+				# Encode function arguments as a JSON string.
+				# @parameter arguments [String | Object | Nil] The function arguments.
+				# @returns [String] The serialized function arguments.
+				def json_arguments(arguments)
+					return arguments if arguments.is_a?(String)
+					
+					JSON.dump(arguments || {})
+				end
+				
+				# Produce an OpenAI-style completion ID.
+				# @parameter response_id [String | Nil] An optional Codex response ID.
+				# @returns [String] A `chatcmpl-` ID.
+				def completion_id(response_id)
+					return "chatcmpl-#{response_id}" if response_id
+					
+					"chatcmpl-#{SecureRandom.hex(12)}"
+				end
+			end
+		end
+	end
+end

data/lib/laiya/provider/codex/responses.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Laiya
+	module Provider
+		class Codex < Interface
+			# Applies the Codex-specific settings while preserving the Responses API payload.
+			module Responses
+				module_function
+				
+				# Apply stateless and streaming options to a native Responses payload.
+				# @parameter payload [Hash] The Responses request object.
+				# @returns [Hash] A copied request configured for the Codex backend.
+				# @raises [ArgumentError] If the request refers to stored prior state.
+				def prepare(payload)
+					if payload["previous_response_id"]
+						raise ArgumentError, "Codex stateless mode requires the client to send full input history"
+					end
+					
+					result = payload.dup
+					result["store"] = false
+					result["stream"] = true
+					
+					include_items = Array(result["include"])
+					include_items << "reasoning.encrypted_content" unless include_items.include?("reasoning.encrypted_content")
+					result["include"] = include_items
+					
+					return result
+				end
+				
+				# Rebuilds output items from streamed events when the terminal Codex
+				# response omits them (some Codex responses return an empty output array).
+				class Collector
+					# Initialize an empty streamed-output collector.
+					def initialize
+						@items = {}
+					end
+					
+					# Accumulate one Codex Responses streaming event.
+					# @parameter event [Hash] The event to record.
+					def accept(event)
+						case event["type"]
+						when "response.output_item.added"
+							@items[event.fetch("output_index", @items.length)] = duplicate(event.fetch("item"))
+						when "response.output_text.delta", "response.refusal.delta"
+							append_text(event)
+						when "response.function_call_arguments.delta"
+							append_arguments(event)
+						when "response.output_item.done"
+							@items[event.fetch("output_index", @items.length)] = duplicate(event.fetch("item"))
+						end
+					end
+					
+					# Fill missing output items in a terminal response from collected events.
+					# @parameter response [Hash] The completed Responses object.
+					# @returns [Hash] The response with reconstructed output items.
+					def complete(response)
+						unless response["output"].is_a?(Array) && !response["output"].empty?
+							response["output"] = @items.sort_by{|index, _item| index}.map(&:last)
+						end
+						
+						return response
+					end
+					
+					private
+					
+					def append_text(event)
+						index = event.fetch("output_index", 0)
+						item = @items[index] ||= {"type" => "message", "role" => "assistant", "content" => []}
+						content_index = event.fetch("content_index", 0)
+						part = item.fetch("content")
+						part[content_index] ||= {"type" => event["type"] == "response.refusal.delta" ? "refusal" : "output_text", "text" => ""}
+						key = event["type"] == "response.refusal.delta" ? "refusal" : "text"
+						part[content_index][key] = part[content_index].fetch(key, "") + event.fetch("delta", "")
+					end
+					
+					def append_arguments(event)
+						index = event.fetch("output_index", 0)
+						item = @items[index] ||= {"type" => "function_call", "arguments" => ""}
+						item["arguments"] = item.fetch("arguments", "") + event.fetch("delta", "")
+						item["id"] ||= event["item_id"]
+					end
+					
+					def duplicate(value)
+						JSON.parse(JSON.dump(value))
+					end
+				end
+			end
+		end
+	end
+end

data/lib/laiya/provider/codex/server_sent_events.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+
+module Laiya
+	module Provider
+		class Codex < Interface
+			# Incrementally decodes Codex Responses API server-sent events.
+			module ServerSentEvents
+				module_function
+				
+				# Decode an HTTP body as server-sent events.
+				# @parameter body [Enumerable(String)] The streamed event body.
+				# @yields {|event| ...} Each decoded event.
+				#  @parameter event [Hash] The event data.
+				# @returns [Enumerator | Nil] An enumerator without a block, otherwise `nil`.
+				def each(body, &block)
+					return enum_for(__method__, body) unless block
+					
+					buffer = String.new
+					data = []
+					event_name = nil
+					
+					body.each do |chunk|
+						buffer << chunk
+						while newline = buffer.index("\n")
+							line = buffer.slice!(0, newline + 1).delete_suffix("\n").delete_suffix("\r")
+							
+							if line.empty?
+								yield_event(event_name, data, &block) unless data.empty?
+								data.clear
+								event_name = nil
+							elsif line.start_with?("data:")
+								data << line.delete_prefix("data:").sub(/\A /, "")
+							elsif line.start_with?("event:")
+								event_name = line.delete_prefix("event:").strip
+							end
+						end
+					end
+					
+					unless buffer.empty?
+						line = buffer.delete_suffix("\r")
+						data << line.delete_prefix("data:").sub(/\A /, "") if line.start_with?("data:")
+						event_name = line.delete_prefix("event:").strip if line.start_with?("event:")
+					end
+					
+					yield_event(event_name, data, &block) unless data.empty?
+				end
+				
+				# Collect all decoded events from a body.
+				# @parameter body [Enumerable(String)] The event body.
+				# @returns [Array(Hash)] The decoded events.
+				def parse(body)
+					events = []
+					each(body) {|event| events << event}
+					return events
+				end
+				
+				# Parse event data and yield a non-terminal event.
+				# @parameter event_name [String | Nil] The optional event name.
+				# @parameter data [Array(String)] The event data lines.
+				# @yields {|event| ...} The parsed event object.
+				# @parameter event [Hash] The decoded JSON data.
+				def yield_event(event_name, data)
+					joined = data.join("\n")
+					return if joined == "[DONE]"
+					
+					event = JSON.parse(joined)
+					event["type"] ||= event_name if event_name
+					yield event
+				end
+			end
+		end
+	end
+end