cequence-io/openai-scala-client
58.4
Adequate · 7 November 2026
89.3k
lines of production code
Scala
primary language
4
measurements over time
What this system is
Features
Add Anthropic Managed Agents domain models
Introduces the complete set of Scala case classes for the Anthropic Managed Agents API, covering Agents, Deployments, Sessions, Environments, Vaults, Credentials, Memory Stores, and related configuration (tools, permissions, multi-agent coordination, and self-hosted work queues). These types provide the structured domain layer for serializing and deserializing the Managed Agents endpoints, enabling users to interact with agent lifecycles, session events, and resource management.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/managedagents · high confidence
Add support for Model Context Protocol (MCP) tools in the Responses API
This change introduces a new set of domain models in the Responses API to support tool invocation via the Model Context Protocol (MCP). Users can now configure MCP servers using \MCPTool\, specifying connection details via \serverUrl\ or \connectorId\ (with predefined connectors for services like Dropbox, Gmail, and Google Drive), along with optional OAuth authorization, HTTP headers, and tool filtering. The update includes types for listing available tools (\MCPListTools\, \MCPToolRef\), handling tool execution (\MCPToolCall\), and managing approval workflows (\MCPApprovalRequest\, \MCPApprovalResponse\). Error handling is also extended to cover both standard tool execution errors and specific MCP protocol errors (\MCPToolError\).
openai-core/src/main/scala/io/cequence/openaiscala/domain/responsesapi/tools/mcp · high confidence
Added AWS SigV4 signing and credentials provider to core library
The library now includes built-in support for AWS Signature Version 4 request signing and credential resolution within the core module. This introduces an \AwsCredentialsProvider\ trait that allows users to supply static credentials or automatically resolve them from standard AWS environment variables (with fallback to Bedrock-specific variables), enabling seamless credential rotation without service restarts. Additionally, the \AwsSigV4\ object provides a service-agnostic signer that computes the necessary headers (Authorization, X-Amz-Date, etc.) for AWS services like Bedrock, ensuring correct RFC 3986 encoding and signature calculation for both permanent and temporary (STS) credentials.
openai-core/src/main/scala/io/cequence/openaiscala/aws · high confidence
Added JSON serialization support for Perplexity Sonar API models
The Perplexity Sonar client now includes dedicated JSON format definitions for its domain models, enabling proper serialization and deserialization of chat completion requests and responses. This change adds support for specific response formats such as \json\_schema\ and \regex\ via the \SolarResponseFormat\ type, and ensures that message roles (system, user, assistant) are correctly mapped to their JSON representations. This infrastructure is required for the client to correctly handle the structured data exchanged with the Perplexity Sonar API.
perplexity-sonar-client/src/main/scala/io/cequence/openaiscala/perplexity · high confidence
Added Together AI examples for Meta Muse Glimmer 30B and Llama 4 models
New example files have been added to the Together AI provider section: a smoke test for the Meta Muse Glimmer 30B model (covering reasoning, tools, and image input) and a chat completion example using the Llama 4 Maverick model. These additions allow users to verify integration with these specific non-OpenAI models via the Together AI provider.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/togetherai · high confidence
Anthropic-specific settings and MCP connector support
The client now exposes configuration options for Anthropic-specific features, including system and user message caching, thinking budget tokens, and a fast-speed mode. It also adds support for native Anthropic tools and remote MCP servers, allowing the adapter to handle server-side tool calls and automatically continue turns when the API returns a pause\_turn signal.
anthropic-client/src/main/scala/io/cequence/openaiscala/domain · high confidence
Expanded Google Vertex AI example coverage
The Google Vertex AI examples directory now includes comprehensive demonstrations for batch prediction jobs, provider-agnostic chat-completion batching via the OpenAI adapter, JSON schema-constrained responses, and streamed completions. It also adds examples for file content handling (including PDFs and multi-file attachments), tool usage (function declarations, code execution, and Google Search grounding), and multi-candidate tool completions, alongside a region-round-robin example for load testing across multiple Vertex AI locations.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/googlevertexai · high confidence
Gemini-specific settings and thinking configuration support
The Gemini client now exposes domain settings for configuring Gemini-specific features, including system caching, tool usage, and the new 'thinking' capabilities. Users can enable system caching via \enableCacheSystemMessage\ and \setSystemCacheName\ on chat completion settings, and configure Gemini tools and tool configs using \setGeminiTools\ and \setGeminiToolConfig\. Additionally, the \GenerationConfig\ now includes \ThinkingConfig\, allowing users to control the model's internal reasoning depth via \thinkingLevel\ (for Gemini 3.x) or \thinkingBudget\ (for Gemini 2.5), and optionally include thought summaries in the response via \includeThoughts\.
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/domain/settings · high confidence
Initial Anthropic client implementation with Bedrock support and Managed Agents scaffolding
This change introduces the core Anthropic service implementation (\AnthropicServiceImpl\) and its AWS Bedrock variant (\AnthropicBedrockServiceImpl\), enabling chat completions, streaming, and message batching. The Bedrock implementation adds support for batch inference jobs via S3, SigV4 authentication, and STS session token generation. It also includes the initial scaffolding for Anthropic Managed Agents (agents, environments, sessions, deployments, vaults, memory stores) and specific beta features like structured outputs, thinking blocks, and MCP servers.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl · high confidence
Initial Anthropic client service layer and Managed Agents API support
The \anthropic-client\ service package now provides the complete service trait hierarchy for the Anthropic API, including the core \AnthropicService\ (messages, skills, streaming) and the full suite of Anthropic Managed Agents APIs (agents, environments, sessions, deployments, memory stores, and vaults). It also introduces AWS Bedrock integration via \AnthropicBedrockBatchInferenceService\ for batch inference jobs and \AnthropicServiceFactory\ for configuring direct API, Bedrock (SigV4, STS, Bearer), and Bedrock Mantle connections. Error handling is standardized through a new set of \AnthropicScalaClientException\ types, and default token limits are now model-aware to prevent silent truncation.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service · high confidence
Initial domain model for Perplexity Sonar chat completion API
This change introduces the core domain types required to interact with the Perplexity Sonar chat completion API. It defines the message structure (System, User, Assistant) via ChatRole and Message classes, and establishes the request settings in SonarCreateChatCompletionSettings, which supports parameters like temperature, max\_tokens, and structured output formats (JSON schema and Regex). Additionally, it includes response models for both standard and streamed (chunked) completions, specifically handling citations and usage information.
perplexity-sonar-client/src/main/scala/io/cequence/openaiscala/perplexity/domain · high confidence
Introduce Gemini client implementation with OpenAI adapter and MCP support
This change adds the core implementation files for the Google Gemini client within the \google-gemini-client\ module. It introduces \GeminiServiceImpl\ to handle API interactions (including streaming with SSE support and explicit timeouts) and \OpenAIGeminiChatCompletionService\ to wrap Gemini responses in the OpenAI chat-completion format. The update also includes \GeminiThinking\ to manage model-specific thinking configurations, \GeminiRawHttp\ for secure file operations using header-based authentication, and \EndPoint\/\Param\ definitions for API routing. Additionally, it adds error mapping logic to translate Gemini-specific exceptions into OpenAI-compatible errors.
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/service/impl · high confidence
Introduce Guice-based OpenAI client application with Akka integration
Adds a new base application structure in the openai-guice module that integrates Google Guice for dependency injection with Akka for actor systems and execution contexts. This includes configuration modules for loading Typesafe Config, providers for Akka ActorSystem and Materializer, and a dedicated blocking dispatcher. The module provides a BaseOpenAIClientApp trait that simplifies client usage by exposing the OpenAIService and providing a closeAndExit helper for clean shutdown, along with an example application demonstrating model listing.
openai-guice/src · high confidence
Introduce System One decision-model domain types and JSON serialization
The \typesafe-client\ now includes a complete domain layer for the System One decision protocol, enabling structured, type-safe interactions with decision models (such as Jev, Perplexity deciders, and Liquid AI) rather than raw JSON. This adds case classes for questions (Noul, Choice, Score, and the experimental Box type), their corresponding answers, and the request/response envelopes, along with Play JSON codecs that enforce the wire format and handle unknown answer types gracefully. It also introduces \DecisionModelId\ (renaming the previous \TypeSafeModelId\) to centralize model identifiers across providers like OpenRouter and Vercel, and \DecisionProvider\ to configure host-specific behaviors such as image handling modes and API protocols.
typesafe-client/src/main/scala/io/cequence/openaiscala/typesafe/domain · high confidence
Introduces configurable model-based guardrails for input and output content safety
The library now includes a guardrails system that allows you to check chat inputs and outputs against safety policies using a dedicated guard model. You can configure specific checks (such as prompt injection, hate speech, or system prompt extraction) for both user messages and assistant replies, define custom policies, and choose how the system handles failures (fail-open or fail-closed). The guardrail sends a single request with a JSON schema to the guard model to classify the text, and you can decide whether to reject the call or return a filtered response when a violation is detected.
openai-core/src/main/scala/io/cequence/openaiscala/domain/guardrails, openai-core/src/main/scala/io/cequence/openaiscala/service/guardrails · high confidence
Introduces domain models for the OpenAI Responses API
Adds the core Scala domain types for the OpenAI Responses API, including \CreateModelResponseSettings\ for request configuration (supporting new fields like \prompt\, \serviceTier\, \multiAgent\, and \topLogprobs\), \Input\ and \Output\ hierarchies for message and tool-call items, and \Response\ for the result payload. Includes JSON serialization formats and helper objects to enable structured interaction with the API.
openai-core/src/main/scala/io/cequence/openaiscala/domain/responsesapi · high confidence
Introduction of comprehensive JSON serialization formats for Anthropic API
The Anthropic client now includes a dedicated \JsonFormats\ module that defines the serialization and deserialization logic for the full range of Anthropic API data structures. This enables proper handling of complex content blocks (such as text, images, documents, and tool use/results), streaming delta events, and the new Managed Agents domain objects (including sessions, environments, credentials, and deployments). Users benefit from accurate mapping of API responses to typed Scala models, supporting features like thinking blocks, citations, and structured output.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic · high confidence
Managed Agents API settings and chat model configuration types
This change introduces the domain settings classes required for the new Anthropic Managed Agents lifecycle (agents, environments, sessions, deployments, credentials, memory stores, and vaults) and updates the chat message settings. For Managed Agents, you can now configure creation and updates for agents (including tools, MCP servers, and skills), deployments (with scheduling and initial events), environments, sessions (with resource mounting), credentials, memory stores, and vaults. For chat interactions, the AnthropicCreateMessageSettings now supports extended thinking (with adaptive and summarized display modes), structured output via JSON schema, output effort levels (low, medium, high, xhigh, max), and a fast inference mode.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/settings · high confidence
New Anthropic Bedrock examples for batch inference, structured outputs, and cross-region usage
Added a suite of examples for using Anthropic models via AWS Bedrock, demonstrating batch inference (including multimodal VLM batches and split-flow submission), structured JSON outputs via schema, reasoning effort controls, PDF/file content handling, and cross-region inference profiles (eu/us prefixes). The examples also cover multiple authentication methods, including standard AWS credentials, STS session tokens, and Bedrock API bearer tokens, as well as the Bedrock Mantle endpoint.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/anthropic · high confidence
New Anthropic Managed Agents example suite
Added a new \managedagents\ subpackage of live examples demonstrating the full Anthropic Managed Agents lifecycle. These examples cover creating, updating, and archiving agents, environments, sessions, deployments, memory stores, and credentials (including vaults). They also demonstrate two authentication methods—standard API keys and OAuth/bearer tokens (via \ant auth\ profiles or static tokens)—and show how to use the OpenAI-style chat completion adapter for both streaming and non-streaming completions backed by managed agents.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/anthropic/managedagents · high confidence
New Anthropic skills and files example programs
Added example programs in the Anthropic skills and files directories to demonstrate file management (create, list, get metadata, download, delete) and skill management (create, list, get, delete, and versioning) via the Anthropic API. The skills examples also show how to use built-in skills like pptx and xlsx through both the native Anthropic message API and the provider-neutral OpenAI-style chat tool completion API.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/anthropic/skills · high confidence
New Anthropic tool domain models and factory methods
The Anthropic client now includes a comprehensive set of domain models for tools, enabling users to configure and invoke specific capabilities. New tool types include Bash, Code Execution, Computer Use, Memory, Text Editor, Web Search, and Web Fetch, each with versioned types and configuration options (e.g., display dimensions for Computer Use, domain filtering for Web Search/Fetch). Additionally, MCP (Model Context Protocol) support is introduced via MCPServerURLDefinition and MCPToolset, allowing users to connect to external MCP servers and configure tool access (enabling/disabling, deferred loading). A ToolChoice mechanism is added to control how the model uses tools (auto, any, specific tool, or none), with notes on compatibility for newer model versions. Factory methods in the Tool object provide convenient ways to instantiate these tools with sensible defaults.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/tools · high confidence
New Anthropic tool usage examples for bash, code execution, web search, web fetch, and MCP servers
Added seven new Scala example files in the \anthropic/tools\ directory demonstrating how to use the Anthropic \createMessage\ API with various tool configurations. These examples cover built-in tools such as \bash\, \codeExecution\, \webSearch\, and \webFetch\, as well as custom tools with JSON schemas and external Model Context Protocol (MCP) servers (e.g., DeepWiki, Semgrep). The examples illustrate how to configure \AnthropicCreateMessageSettings\ with specific tools, handle tool use blocks in responses, and process results like generated files or web fetch content.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/anthropic/tools · high confidence
New Bedrock examples demonstrate SigV4 authentication and unified endpoint matrix
Added three new example programs in the Bedrock examples directory that showcase AWS SigV4 authentication (using IAM credentials) alongside the existing Bearer token method. The examples illustrate how to configure the OpenAI-compatible Bedrock path for both the Mantle and Runtime hosts, including a shared-engine matrix test that validates all authentication and endpoint combinations, as well as a dedicated streamed completion example for SigV4.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/bedrock · high confidence
New Cerebras provider examples for chat, JSON, streaming, and tools
Added five new Scala example files in the Cerebras provider directory to demonstrate how to use the library with Cerebras's API. These include standard chat completion, JSON schema-enforced responses, streamed responses, tool/function calling, and a file content example (which documents that Cerebras currently rejects PDF inputs). The examples use specific model IDs like \cerebras\_qwen\_3\_8\_27b\ and \gpt\_oss\_120b\ and require the \CEREBRAS\_API\_KEY\ environment variable.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/cerebras · high confidence
New Claude CLI agent client module
Added a new \claude-agent-client\ module that wraps the Claude CLI as a subprocess, enabling bidirectional, event-driven sessions via NDJSON. This introduces a domain model for CLI events (system init, assistant turns, user echoes, results, streaming deltas, and tool permission requests) and a service layer that manages the subprocess lifecycle, including sending user messages, tool results, interrupts, and responding to tool permission prompts. The module also includes configuration settings for model, permissions, and session management, along with tests to verify the JSON wire format and service lifecycle.
claude-agent-client · high confidence
New Claude CLI agent examples demonstrating one-shot queries and tool permission handling
Added two Scala example programs in the \claudeagent\ package that demonstrate interacting with the Claude CLI subprocess via the new \ClaudeAgentService\. \ClaudeAgentOneShotQueryExample\ shows a basic single-turn query using the \claude-haiku-4-5\ model, while \ClaudeAgentToolPermissionExample\ demonstrates handling mid-turn tool permission requests (specifically for Bash commands) by auto-approving them, highlighting the bidirectional session capabilities distinct from the HTTP-based managed agent service.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/claudeagent · high confidence
New Fireworks AI examples for chat, streaming, tool use, and document inlining
Added a new set of Scala examples in the \fireworksai\ package demonstrating how to use the Fireworks AI provider. These include basic and streamed chat completions, streamed reasoning output from DeepSeek models (now surfaced via \reasoningText\ instead of requiring tag filtering), tool completion with parallel tool calls, and document inlining features supporting both remote PDF URLs and local base64-encoded files. A standalone test for the MiniMax-M2.7 model is also included.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/fireworksai · high confidence
New Gemini domain models for batch processing, caching, and MCP tools
The Gemini client now includes domain classes for several new capabilities: batch generation jobs (GenerateContentBatch, BatchState, BatchStats) for asynchronous processing; content caching (CachedContent, Expiration) to reuse context; and Model Context Protocol (MCP) integration (McpServer, StreamableHttpTransport) allowing the model to invoke remote tools server-side. Additionally, new domain types support the Gemini Files API (GeminiFile), granular content parts (Part, PartPrefix including executable code and code execution results), and safety controls (HarmCategory, HarmBlockThreshold, HarmProbability).
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/domain · high confidence
New Gemini examples for batch processing, reasoning effort, and file handling
Added a suite of new example programs in the Google Gemini examples directory demonstrating provider-agnostic chat-completion batch support via the OpenAI adapter (including context caching), configurable reasoning effort (mapping to Gemini's thinking levels/budgets), JSON schema response formatting, and multi-modal file inputs (PDFs and images). The examples also cover native Gemini features like code execution, function declarations, Google Search grounding, and remote MCP server tool usage.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/googlegemini · high confidence
New Gemini response domain models for content, grounding, and metadata
This change introduces the core Scala domain classes for Google Gemini API responses within the \google-gemini-client\ module. It adds \GenerateContentResponse\ and \Candidate\ to handle model outputs, including support for filtering out 'thought' parts in thinking models and exposing safety ratings, citation metadata, and grounding attributions. New types such as \FinishReason\ and \BlockReason\ allow users to understand why generation stopped or was blocked. Additionally, it defines \GroundingAttribution\ and \GroundingMetadata\ to expose source citations and retrieval details, as well as \ListCachedContentsResponse\ and \ListModelsResponse\ for managing cached content and model listings.
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/domain/response · high confidence
New Gemini service client with typed exceptions and OpenAI adapter
The Gemini client now provides a dedicated service layer (\GeminiService\) that supports content generation (including streaming), model listing, and cached content management. It introduces a hierarchy of typed exceptions (e.g., \GeminiScalaTokenCountExceededException\, \GeminiScalaUnauthorizedException\) for precise error handling, including specific handling for MCP call failures. The service also includes an OpenAI-compatible adapter (\asOpenAI\) to allow Gemini to be used as a drop-in replacement for OpenAI chat completions, and supports explicit timeout configuration via the factory.
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/service · high confidence
New Grok integration examples for chat, JSON, streaming, and vision
Added four new example files in the \openai-examples/src/main/scala/io/cequence/openaiscala/examples/grok\ directory demonstrating how to use the Grok provider via the OpenAI-compatible interface. These examples cover basic chat completion (\GrokCreateChatCompletion.scala\), structured JSON output with schema validation (\GrokCreateChatCompletionJSON.scala\), streamed responses (\GrokCreateChatCompletionStreamed.scala\), and multi-modal image analysis (\GrokCreateChatCompletionWithImage.scala\). Each example uses the \ChatCompletionProvider.grok\ service and specific Grok model IDs (e.g., \grok\_4\_20\_0309\_reasoning\, \grok\_3\_beta\, \grok\_2\_vision\_latest\), requiring the \GROK\_API\_KEY\ environment variable.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/grok · high confidence
New Groq provider examples for chat, audio, and batch operations
Added a suite of example files in the Groq provider directory demonstrating how to use the library with Groq's API. These include standard and streamed chat completions, JSON mode with strict schemas, tool/function calling, audio transcription, and batch processing. The examples also showcase provider-specific features such as reasoning format control, service tier flexibility, and round-robin load balancing between standard and flex tiers.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/groq · high confidence
New Perplexity Sonar and Agent API client module
Added a new \perplexity-sonar-client\ module providing a Scala client for Perplexity's Sonar chat completions and the new Agent API. The Sonar chat completion endpoints are deprecated and will be removed on 2026-09-27. The Agent API support includes creating and streaming agent responses, retrieving and canceling background runs, downloading shared files, and listing models. It supports web search, URL fetching, finance and people search, sandbox execution, MCP servers, custom functions, and built-in/inline/custom skills. Response formats can be structured as JSON schemas or regex. Citations are returned as URL annotations and can be included in the text response. The client handles streaming with server-sent events, supports background mode with resumption, and classifies Perplexity-specific HTTP errors into typed exceptions with retry logic for rate limits, timeouts, and server errors. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 2 commits (0 fixes) modifying google-gemini-client, perplexity-sonar-client.
perplexity-sonar-client/src/main/scala/io/cequence/openaiscala/perplexity/service/impl · medium confidence · unverified
New Perplexity Sonar client with Agent API and native error handling
The \perplexity-sonar-client\ module now provides a dedicated Scala client for Perplexity's services, introducing the native Agent API (\createAgentResponse\, \createAgentResponseStreamed\) alongside the legacy Sonar chat completions API, which is deprecated as of version 1.4.0 and will lose support on 2026-09-27. The client includes a comprehensive hierarchy of \PerplexityScalaClientException\ types to classify HTTP errors (e.g., rate limits, invalid models) and supports an OpenAI adapter (\agentAsOpenAI\) for the Agent API, allowing users to interact with Perplexity's agent capabilities using standard OpenAI-compatible interfaces.
perplexity-sonar-client/src/main/scala/io/cequence/openaiscala/perplexity/service · high confidence
New Responses API example suite for model responses, tools, and streaming
Added a comprehensive set of Scala examples in the \responsesapi\ package demonstrating the OpenAI Responses API. These include basic text, image, and message handling, as well as advanced features like tool usage (functions, web search, file search, code interpreter, image generation, and MCP servers), structured output with strict JSON schemas, and streamed responses. The examples also cover specific model capabilities like GPT-5.5 Pro, GPT-5.6 Sol Max Reasoning, and multi-agent execution, along with integration via Amazon Bedrock Mantle and chat completion adapters.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/responsesapi · high confidence
New Responses API tool types and JSON serialization
Added domain models and JSON serialization for new Responses API tool types, including Code Interpreter, Computer Use, Custom, File Search, Function, Image Generation, Local Shell, Shell, Web Search, and MCP tools, along with their corresponding calls and outputs.
openai-core/src/main/scala/io/cequence/openaiscala/domain/responsesapi/tools · high confidence
New Sonar examples and Perplexity Agent API smoke tests
Added example scripts and live smoke tests for Perplexity's Sonar service, including direct chat completion (with JSON schema output), streamed responses, and an OpenAI-compatible adapter. The new smoke tests validate the Perplexity Agent API, covering model listing, web search, structured output, function calling, and multi-turn conversations.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/sonar · high confidence
New TypeSafe System One decision service with structured output and multi-provider support
This change introduces the \TypeSafeService\ and its factory (\TypeSafeServiceFactory\) to interact with decision models via the System One API, allowing users to evaluate structured questions against a state in a single call. It includes built-in support for multiple decision providers (TypeSafe Jev, Liquid AI d1, Perplexity Deciders, OpenAI, OpenRouter, and local llama.cpp) via \DecisionProviderSettings\, and provides an OpenAI chat-completion adapter (\asOpenAI\) that maps JSON schemas to questions for structured output. The service also features a native exception hierarchy (\TypeSafeScalaClientException\ and subclasses) for precise error handling and a retry adapter for transient failures.
typesafe-client/src/main/scala/io/cequence/openaiscala/typesafe/service · high confidence
New adapter examples for routing, streaming, and interception
The examples/adapters directory now includes a comprehensive suite of new example files demonstrating advanced service composition patterns. These include ChatCompletionRouterAdapterExample and ChatCompletionStreamedRouterExample for routing requests across multiple providers (OpenAI, Anthropic, Fireworks AI, Ollama, etc.), ChatCompletionInputAdapterForFireworksAI for handling provider-specific constraints, ChatCompletionErrorInterceptAdapterExample and ChatCompletionInterceptAdapterExample for monitoring and error handling, and examples for round-robin, random order, and retry strategies. The streamed router examples also demonstrate sharing a single stateless engine across multiple providers to optimize resource usage.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/adapters · high confidence
New assistant scenario examples with file search and polling
Added two new example scenarios in the scenario package: Assistants.scala demonstrates creating an assistant with file search capabilities, uploading a document, and retrieving messages, while CreateThreadAndRunScenario.scala shows how to use the createThreadAndRun endpoint with polling to wait for run completion before fetching results.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/scenario · high confidence
New chat-completion adapter infrastructure and emulation support
The \openai-core\ adapter package now includes a suite of new service adapters to enhance chat-completion flexibility and reliability. A \ChatCompletionBatchEmulationAdapter\ allows services without native batch support to emulate batch behavior by running requests synchronously in parallel, enabling mixed-provider batch routing. New interceptors (\ChatCompletionErrorInterceptAdapter\, \ChatCompletionInterceptAdapter\) provide hooks for error handling and request/response logging. Input and output adapters (\ChatCompletionInputAdapter\, \ChatCompletionOutputAdapter\) allow message and setting transformations, while \ChatCompletionServiceAdapter\ facilitates service swapping. A \ChatToCompletionAdapter\ bridges legacy completion APIs to the chat interface. Additionally, \OpenAIAgentsChatCompletionService\ exposes the OpenAI Agents API (beta) as a standard chat-completion service, and \OpenAIChatCompletionServiceRouter\ introduces model-based routing with support for batch-capable and mixed-capability providers.
openai-core/src/main/scala/io/cequence/openaiscala/service/adapter · high confidence
New decision-model smoke tests and latency benchmarks for the TypeSafe client
The examples directory now includes a suite of smoke tests and benchmarks for the TypeSafe client's decision-model capabilities. These new files verify that decision models from providers like TypeSafe (Jev), Liquid AI, Perplexity, OpenAI, Microsoft Foundry, SubQ, ScaleDown, OpenRouter, and Vercel correctly handle structured questions (noul, choice, score) and image inputs. The tests also benchmark execution latency against varying context sizes and question counts, providing users with performance data and validation for the new decision API adapters.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/typesafe · high confidence
New domain models for Anthropic batch inference, skills, and structured content
The Anthropic client now includes domain types for AWS Bedrock batch inference jobs (status tracking and creation settings), the Anthropic Skills API (skill definitions, versions, containers, and list/delete responses), and expanded message content blocks including thinking, redacted thinking, tool use/results, web search/fetch results, MCP tool interactions, and document citations. It also adds support for structured JSON schema output formats, file metadata operations, and system/user/assistant message variants with cache control.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain · high confidence
New domain settings for chat, embeddings, speech, and tool approval
The library introduces a comprehensive set of new domain settings classes in the \openai-core\ module, providing structured configuration for modern API capabilities. \CreateChatCompletionSettings\ now supports advanced parameters including \reasoning\_effort\ (with \minimal\, \low\, \medium\, \high\, \xhigh\, and \max\ tiers), \verbosity\ for GPT-5 models, \service\_tier\ (auto, default, flex, priority/fast, ultrafast), \parallel\_tool\_calls\, and \json\_schema\ for strict structured output. New settings classes cover \CreateEmbeddingsSettings\ (with \dimensions\ and \encoding\_format\), \CreateSpeechSettings\ (with \instructions\ and \stream\_format\), \CreateTranscriptionSettings\, \CreateTranslationSettings\, \CreateRunSettings\, \CreateThreadAndRunSettings\, \CreateModerationSettings\, \CreateImageSettings\, \CreateImageEditSettings\, \CreateFineTuneSettings\, \CreateCompletionSettings\, and \CreateEditSettings\. Additionally, provider-specific extensions are added via \GroqCreateChatCompletionSettingsOps\ (for \reasoning\_format\ and \max\_completion\_tokens\) and \ResponsesChatCompletionSettingsOps\ (for native Responses API tools, reasoning modes, and multi-agent execution). A new \ToolApprovalSettingsOps\ enables human-in-the-loop tool approval workflows by carrying approval decisions in settings, while \WebSearchOptions\ and \JsonSchemaDef\ support web search context and typed JSON schema definitions.
openai-core/src/main/scala/io/cequence/openaiscala/domain/settings · high confidence
New examples for batch processing, assistants, audio, and Bedrock integration
The examples directory now includes runnable demonstrations for the new batch API (CreateBatch, CreateChatCompletionBatch, CreateChatCompletionBatchSplitFlow, CancelBatch), the Assistants API (CreateAssistant with function, code interpreter, and file search tools), and audio endpoints (CreateAudioTranscription, CreateAudioTranslation, CreateAudioSpeech). It also adds Bedrock-specific smoke tests for JSON schema structured output and VLM content (images/PDFs), a latency benchmark comparing Bedrock vs. OpenAI for gpt-5.5, and a demo of the batch emulation router for providers without native batch support.
openai-examples/src/main/scala/io/cequence/openaiscala/examples · high confidence
New grader domain models and JSON serialization
The \openai-core\ module now includes a new \graders\ package that defines the domain models and JSON formats for various evaluation graders. This introduces case classes for string checks (\StringGrader\), text similarity (\TextSimilarityGrader\), model-based scoring (\ScoreModelGrader\), model-based labeling (\LabelModelGrader\), Python script execution (\PythonGrader\), and combined multi-graders (\MultiGrader\). It also adds support for complex input content types (text, images, audio, arrays) and sampling parameters, along with the necessary Play JSON formats to serialize and deserialize these structures.
openai-core/src/main/scala/io/cequence/openaiscala/domain/graders · high confidence
New grader example scripts for running and validating evaluations
Added two new example scripts, RunGrader.scala and ValidateGrader.scala, in the graders package to demonstrate how to use the grader service. RunGrader.scala shows how to execute a ScoreModelGrader to evaluate model responses, while ValidateGrader.scala provides examples for validating various grader types including StringGrader, ScoreModelGrader, LabelModelGrader, PythonGrader, and MultiGrader.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/graders · high confidence
New provider-specific chat completion examples for Novita, OctoML, and Ollama
Added example files for Novita, OctoML, and Ollama chat completions, each with both standard and streamed variants. The Novita examples use the OpenAIChatCompletionServiceFactory with ChatProviderSettings.novita and require the NOVITA\_API\_KEY environment variable. The OctoML examples use the ChatCompletionProvider.octoML singleton and require the OCTOAI\_TOKEN environment variable. The Ollama examples use the OpenAIChatCompletionServiceFactory and OpenAIChatCompletionStreamedServiceFactory with a local coreUrl of http://localhost:11434/v1/ and require a running local Ollama service. All examples demonstrate creating chat completions with specific non-OpenAI model IDs and settings, and the streamed variants use Akka Streams Sink.foreach to print content chunks.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/novita, openai-examples/src/main/scala/io/cequence/openaiscala/examples/octoml, openai-examples/src/main/scala/io/cequence/openaiscala/examples/ollama · high confidence
New service factories and AWS Bedrock SigV4 signing support
The client now provides dedicated factory entry points for Chat Completions (\OpenAIChatCompletionServiceFactory\) and Core services (\OpenAICoreServiceFactory\), allowing users to instantiate these specific capabilities independently of the full \OpenAIService\. Additionally, Amazon Bedrock support has been expanded to include AWS SigV4 authentication via a new \SigningWSClientEngine\ that signs requests per-call, enabling secure access to Bedrock's OpenAI-compatible endpoints without static credentials.
openai-client/src/main/scala · high confidence
New service layer for OpenAI Agents API and provider-agnostic streaming
The library introduces a dedicated service layer for the OpenAI Agents API (beta) via the new \OpenAIAgentsService\ trait, enabling users to create and manage durable cloud agents, sessions, and environments. Streaming capabilities are significantly enhanced with the introduction of \ChatChunks\, which maps provider-specific chat-completion chunks and Responses API events into a unified, provider-neutral typed stream (\ChatChunk\), and \OpenAIChatCompletionStreamedServiceExtra\, which adds \createChatToolCompletionStreamed\ for streaming tool calls and \createChatToolCompletionStreamedWithApprovals\ for handling human-in-the-loop approval pauses. Additionally, \OpenAIChatCompletionBatchService\ provides a provider-agnostic interface for asynchronous batch processing across multiple providers, and \BedrockAuth\/\BedrockEndpoint\ unify AWS Bedrock authentication and endpoint configuration.
openai-core/src/main/scala/io/cequence/openaiscala/service · high confidence
New typed streaming API and response models for chat completions
The library introduces a provider-agnostic, typed streaming model for chat completions, replacing the previous untyped approach. Consumers can now use \ChatChunk\ to process streamed events (text, tool calls, code execution, web search, thinking blocks) and \AssembledChatCompletion\ to fold these chunks into a complete result, including support for human-in-the-loop tool approvals. The response domain has been expanded with new case classes such as \ChatToolCompletionResponse\, \ChatFunCompletionResponse\, and \ChatWebSearchCompletionResponse\ to handle specific tool and function call scenarios, alongside updated \Assistant\ and \FineTuneJob\ models to reflect current API structures.
openai-core/src/main/scala/io/cequence/openaiscala/domain/response · high confidence
Streaming chat completion services now support input/output conversion, round-robin load balancing, and model routing
Users can now transform chat completion inputs and outputs in streaming services using the new \OpenAIChatCompletionIOConversionAdapter\, which applies configurable conversions to messages, settings, and streamed chunks. The library introduces \OpenAIChatCompletionStreamedRoundRobinService\ to distribute requests across multiple underlying services, and \OpenAIChatCompletionStreamedServiceRouter\ to direct requests to specific services based on model names or mapped model aliases. Additionally, new factory classes (\OpenAIChatCompletionStreamedServiceFactory\ and \OpenAIStreamedServiceFactory\) and implicits (\OpenAIStreamedServiceImplicits\) simplify the creation of streaming-enabled services, allowing seamless integration of streaming capabilities into existing non-streaming service instances.
openai-client-stream/src/main/scala/io/cequence/openaiscala/service · high confidence
Streaming service implementations for chat, core, and responses APIs
The streaming service layer now includes concrete implementations for chat completion, core completions, and the Responses API. Users can stream chat completions with tool support (subject to model compatibility and approval settings), stream legacy text completions, and stream agent session events or model responses via the new Responses API endpoints. The implementation handles SSE frame size limits and classifies streaming errors appropriately for each endpoint.
openai-client-stream/src/main/scala/io/cequence/openaiscala/service/impl · high confidence
Support for OpenAI Agents API (beta)
Added domain models and JSON serialization for the OpenAI Agents API (beta), enabling the creation and management of reusable agents and agent sessions. This includes configuration for reasoning effort, service tiers, and multi-agent execution, as well as support for various tool types such as MCP servers, web search, and computer use. The update also introduces streaming event handling for session updates, turn progress, and item changes, along with input handling for messages, tool results, and computer-use approvals.
openai-core/src/main/scala/io/cequence/openaiscala/domain/agents · high confidence
TypeSafe System One adapter for OpenAI chat-completion and Decisions APIs
The TypeSafe client now exposes System One decision services through the standard OpenAI interfaces. For chat completion, requests using \response\_format\_type = json\_schema\ are translated into System One questions (noul, choice, score, box) derived from the schema, and the structured answers are returned as the assistant's JSON content; unsupported sampling parameters are dropped with warnings. For the Decisions API, the adapter translates inputs and questions to the host's protocol (OpenAI, ScaleDown, or native System One), handling image inputs via lifted fields, base64 objects, or asset placeholders, and repacks native TypeSafe exceptions into the OpenAI exception hierarchy.
typesafe-client/src/main/scala/io/cequence/openaiscala/typesafe/service/impl · high confidence
Vertex AI batch prediction and tool support
The Vertex AI client now supports batch prediction jobs for Gemini models, allowing inputs from Cloud Storage (JSONL) or BigQuery and outputs to either destination, with results staged in a configurable GCS bucket. It also adds support for Vertex AI tools including function declarations, Google Search grounding, and code execution, along with tool configuration for controlling function calling behavior (AUTO, ANY, NONE modes). Additionally, the client now supports Vertex AI's thinking configuration, allowing users to request and receive model thoughts in streaming responses. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 2 commits (0 fixes) modifying google-vertexai-client.
google-vertexai-client/src/main, google-vertexai-client/src/test/scala/io/cequence/openaiscala/vertexai/service · medium confidence
Behavioural changes
3 commits (0 fixes) modifying openai-examples/src/main/scala/io/cequence/openaiscala/examples/minimax
A change to existing behaviour in openai-examples/src/main/scala/io/cequence/openaiscala/examples/minimax — 3 commits, 2 files: “MiniMax-M3: split its thinking out of the content, none as thinking disabled”; “MiniMax-M3.1-Flash: conversions per MiniMax's docs, wire specs (follow-up to \#131)”; “feat: add MiniMax-M3.1-Flash text defaults” (refs \#131).
openai-examples/src/main/scala/io/cequence/openaiscala/examples/minimax · medium confidence · unverified
3 commits (0 fixes) modifying openai-examples/src/main/scala/io/cequence/openaiscala/examples/mistral
A change to existing behaviour in openai-examples/src/main/scala/io/cequence/openaiscala/examples/mistral — 3 commits, 4 files: “Examples - package per provider + relocation”; “Provider clients: decision providers on either API, Perplexity v1.1, Liquid images, Haiku 5.5, access modes”; “Mistral Large 4: reasoning\_effort low / medium / high”.
openai-examples/src/main/scala/io/cequence/openaiscala/examples/mistral · medium confidence · unverified
4 commits (0 fixes) modifying anthropic-client
A change to existing behaviour in anthropic-client — 4 commits, 13 files: “MiniMax-M3.1-Flash: conversions per MiniMax's docs, wire specs (follow-up to \#131)”; “PathSegment: an id is one URL path segment, a bad one fails the call (security)”; “Anthropic OAuth profiles: a bounded token refresh, no waiting under the lock”; and 1 more (refs \#131). Also in this area: Added test coverage for Anthropic client JSON formats, streaming, and authentication.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/auth, anthropic-client/src/test/scala/io/cequence/openaiscala/anthropic/service/auth, openai-core/src/test/scala/io/cequence/openaiscala · medium confidence · unverified
Added validation for the Noul probability threshold in chat completion settings
The chat-completion adapter now includes a configurable 'noul' probability threshold (defaulting to 0.5) to control boolean property behavior. Users can set this threshold via the \setTypeSafeNoulThreshold\ method, which enforces that the value is between 0 and 1. If the threshold is manually configured in \extra\_params\ with an invalid value, the adapter will throw an \OpenAIScalaClientException\ to prevent misuse.
typesafe-client/src/main/scala/io/cequence/openaiscala/typesafe/domain/settings · high confidence
Configurable JSON Schema model support via openai-scala-client.conf
A new configuration file, openai-scala-client.conf, has been added to centralize the list of models that support JSON schema structured output. This change moves model registration from code into a config file, allowing users to easily manage which models (including GPT-6, GPT-5.x, Claude Opus/Sonnet variants, and specific Bedrock IDs) are enabled for JSON schema features. The configuration explicitly lists supported model IDs and comments out unsupported Bedrock models to prevent errors, ensuring the client correctly routes structured output requests only to compatible providers.
openai-client/src/main/resources · high confidence
Domain model overhaul: typed messages, provider-neutral tools, and batch support
The domain layer has been refactored to replace the legacy \BaseMessageSpec\ with a typed message hierarchy (\SystemMessage\, \UserMessage\, \AssistantMessage\, \ToolMessage\, etc.) and a new \ChatRole\ enum that introduces a \Developer\ role. Provider-neutral tool support is now available via \ChatCompletionTool\ (including \MCPServerTool\ and \SkillTool\), while assistant-specific capabilities are modeled by \AssistantTool\ and \AssistantToolResource\. The API also gains provider-agnostic batch processing types (\ChatCompletionBatchRequest\, \ChatCompletionBatchInfo\) and updated JSON schema definitions (\JsonSchema\) with deterministic serialization. Model registries (\ModelId\, \NonOpenAIModelId\) have been swept to deprecate retired models and register new ones (e.g., Claude Opus 5.5, GPT-6 Astra, Gemini 3.0 Flash).
openai-core/src/main/scala/io/cequence/openaiscala/domain · high confidence
Improved token counting accuracy for newer OpenAI models and function definitions
The token counting logic has been updated to correctly route newer OpenAI model families (such as gpt-4.1, gpt-4.5, o1, o3, o4, and chatgpt-4o) to the o200k\_base encoding, preventing misclassification as older cl100k\_base encodings. Additionally, a new serializer for function call definitions has been introduced to accurately format tool parameters for token estimation, and the underlying jtokkit library has been upgraded to version 1.1.0 to support these encoding changes and new message types like DeveloperMessage.
openai-count-tokens/src/main · high confidence
New typed domain models for Anthropic streaming and message responses
The Anthropic client now uses newly defined Scala case classes to represent message responses and streaming events, replacing previous ad-hoc or less structured handling. CreateMessageResponse models the full message payload, including content blocks (text, thinking, tool use, citations) and usage statistics with optional cache token counts. CreateMessageChunkResponse and MessageStreamEvent provide a typed, sealed-hierarchy representation of SSE stream events, distinguishing between message start, content block deltas (text, thinking, signature, input JSON, citations), block stops, and message deltas. This enables more robust parsing and access to streaming data, including support for thinking blocks and citation deltas in real-time responses.
anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/response · high confidence
Robust JSON serialization and deserialization for Gemini API responses
This change introduces a dedicated JSON format layer for the Google Gemini client that significantly improves resilience against API evolution. It implements lenient enum parsing for fields like finish reasons and block reasons, allowing the client to gracefully handle new or unknown enum values from Google without failing the entire response. Additionally, it corrects serialization logic for \Part\ objects to properly handle \thoughtSignature\ fields required by Gemini 3, ensures empty content is handled correctly, and fixes Scala 3 compatibility issues in \Content\ serialization.
google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini · high confidence
Scala 2 JSON schema derivation now uses runtime reflection
The Scala 2 implementation of JSON schema derivation has been updated to use runtime reflection (via \scala.reflect.runtime.universe\) instead of the previous approach. New files \InferredJsonSchemaDerivation\, \JsonSchemaOfDerivation\, and \JsonSchemaReflectionHelper\ in \openai-core/src/main/scala-2\ now handle schema inference for case classes, primitives, collections, enums, and value classes at runtime, aligning the Scala 2 behavior with the Scala 3 macro-based implementation.
openai-core/src/main/scala-2 · high confidence
Structured error handling, retry logic, and JSON format consolidation in core
The core library now centralizes JSON serialization logic in a new \JsonFormats\ object and introduces a dedicated \EnvHelper\ trait for environment variable access. Error handling has been significantly enhanced with a hierarchy of specific exceptions (such as \OpenAIScalaRateLimitException\ and \OpenAIScalaTokenCountExceededException\) and a \RetryHelpers\ module that implements exponential backoff with jitter for transient failures. Additionally, a \TypeJsonWrapper\ ensures type safety for polymorphic JSON structures, and a \ProviderErrorDetails\ trait standardizes the extraction of error metadata across different providers.
openai-core/src/main/scala/io/cequence/openaiscala · high confidence
Test coverage
1 commit adding/updating tests in google-vertexai-client/src/test/scala/io/cequence/openaiscala/vertexai; 1 commit adding/updating tests in openai-client-stream/src/test/resources/openrouter; 1 commit adding/updating tests in openai-client-stream/src/test/resources/tool-approval, openai-core/src/test/scala/io/cequence/openaiscala/domain/response; 2 commits adding/updating tests in openai-client-stream/src/test/resources/agents, openai-examples/src/main/scala/io/cequence/openaiscala/examples/agents; Added JSON serialization tests for chat chunks, messages, and retry logic; Added comprehensive JSON serialization tests for Responses API tools; Added smoke tests for Meta's Muse models across multiple providers; Added smoke tests for guardrails functionality; Added test configuration for OpenAI token counting; Added test coverage for Anthropic JSON formats and streaming events; Added test fixtures for OpenAI Agents API (beta); Added test fixtures for OpenAI Agents API multi-agent sessions; Added test fixtures for OpenAI Agents and Responses APIs; Added test fixtures for Perplexity Sonar client API responses; Added tests for AWS SigV4 signing in the OpenAI-compatible Bedrock client; Added tests for AWS SigV4 signing logic; Added tests for Anthropic adapter service implementation; Added tests for Anthropic authentication and error handling; Added tests for Bedrock integration, error code handling, and streaming configuration; Added tests for DecisionImage and DecisionModelId domain types; Added tests for Gemini JSON serialization and lenient parsing; Added tests for Gemini client service implementation details; Added tests for JSON schema derivation behavior in Scala 2 and Scala 3; Added tests for OpenAI Agents API (beta) JSON parsing; Added tests for VLMContent image format handling; Added tests for chat tool body parameters, model routing, and test infrastructure; Added tests for grader JSON serialization formats; Added tests for service-layer streaming, JSON schema, and error handling; Added tests for the TypeSafe AI client's JSON serialization, API conformance, and error handling; Added tests for the TypeSafe adapter's decision and chat-completion codecs; Added tests for token counting with function call schemas and encoding fallbacks; Added wire tests for new API capabilities and streaming behavior; Test configuration for logging and API credentials; Test configuration updates for logging and dependency mapping; Test configuration updates for logging and reasoning budget mapping.
Dependencies
Automated dependency updates and code quality tooling
The repository now includes configuration files for Scala Steward, Scalafmt, and Scalafix to automate dependency updates and enforce code formatting. Scala Steward is configured to run weekly, grouping related updates (such as the scalatest stack and sbt plugins) into single pull requests to maintain CI stability. It also pins specific versions for Akka (2.6.x) and Logback (1.4.x) to avoid breaking changes from newer major versions, while ignoring sibling libraries and Scala cross-build versions that require coordinated updates. Additionally, Scalafmt is set to version 3.7.4 with Scala 2.13 dialect rules, and Scalafix is configured with rules like DisableSyntax, ExplicitResultTypes, and RemoveUnused to enforce code quality standards.
(repo-wide) · high confidence
Initial build infrastructure setup
Established the project's build configuration by defining version constants for the wsClient (1.1.1) and scalaMock (6.0.0) dependencies, setting the sbt version to 1.9.0, and adding plugins for code formatting (scalafmt), static analysis (scalafix), and code coverage (scoverage).
project · high confidence
Initial project structure and dependency configuration for OpenAI Scala Client
This change introduces the foundational build configuration for the OpenAI Scala Client library, establishing a multi-module SBT project structure. It defines the core modules (openai-core, openai-client, openai-client-stream) along with provider-specific clients for Anthropic, Google Vertex AI, Google Gemini, Perplexity Sonar, TypeSafe AI, and a Claude Agent subprocess client, plus a Guice DI module and an examples project. The configuration sets Scala 2.12.18, 2.13.11, and 3.2.2 as supported versions, with 2.13 as the default, and pins key dependencies including ws-client (via version variable), scalactic, scalatest, scalamock, scala-logging (3.9.5), logback-classic (1.4.14), google-cloud-vertexai (1.52.0), jtokkit (1.1.0), and scala-guice (5.1.1).
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 58 (+5.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 53 → 53 (+0.2)
- Architecture 93 → 93 (-0.1)
- Maturity 43 → 67 (+24.6)
- Readiness 74 → 61 (-12.7)
- Security 79 → 64 (-14.2)
- Performance 60 → 60 (+0.0)
Resolved (16)
- ChatCompletionBodyMaker.handleJsonSchema (cognitive 18) (openai-client/src/main/scala/io/cequence/openaiscala/service/impl/OpenAIChatCompletionServiceImpl.scala)
- Duplicated block (11 lines × 2) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/OpenAIVertexAIChatCompletionService.scala)
- Duplicated block (24–25 lines × 2) (openai-client/src/main/scala/io/cequence/openaiscala/service/impl/OpenAIChatCompletionServiceImpl.scala)
- Duplicated block (9 lines × 2) (openai-client/src/main/scala/io/cequence/openaiscala/service/impl/OpenAIServiceImpl.scala)
- JsonFormats.jsonSchemaWrites (cognitive 16) (openai-core/src/main/scala/io/cequence/openaiscala/JsonFormats.scala)
- JsonFormats.jsonSchemaWrites (cyclomatic 17) (openai-core/src/main/scala/io/cequence/openaiscala/JsonFormats.scala)
- Low cohesion: OpenAIAnthropicChatCompletionService (LCOM4 5) (anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/OpenAIAnthropicChatCompletionService.scala)
- Near-duplicate member pair (59 shared lines) (openai-examples/src/main/scala/io/cequence/openaiscala/examples/typesafe/DecisionContextLatencyBenchmark.scala)
- Outdated: ch.qos.logback:logback-classic
- Outdated: com.typesafe.scala-logging:scala-logging_2.13
- Outdated: net.codingwell:scala-guice_2.13
- Outdated: org.scalactic:scalactic_2.13
- Split anthropic-client
- Split openai-core
- impl.toNonSystemVertexAI (cognitive 16) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala)
- impl.toNonSystemVertexAI (cyclomatic 16) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala)
New (18)
- Boundary-crossing change coupling: NonOpenAIModelId.scala ↔ DecisionProviderSettings.scala (openai-core/src/main/scala/io/cequence/openaiscala/domain/NonOpenAIModelId.scala)
- Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
- Duplicated block (10 lines × 2) (openai-client/src/main/scala/io/cequence/openaiscala/service/impl/OpenAIServiceImpl.scala)
- Duplicated block (12–15 lines × 2) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/OpenAIVertexAIChatCompletionService.scala)
- Duplicated block (15–18 lines × 2) (google-gemini-client/src/main/scala/io/cequence/openaiscala/gemini/service/impl/OpenAIGeminiChatCompletionService.scala)
- Duplicated block (25–26 lines × 2) (openai-examples/src/main/scala/io/cequence/openaiscala/examples/typesafe/DecisionContextLatencyBenchmark.scala)
- Hotspot: google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala)
- Hotspot: openai-core/src/main/scala/io/cequence/openaiscala/service/JsonSchemaShape.scala (openai-core/src/main/scala/io/cequence/openaiscala/service/JsonSchemaShape.scala)
- JsonSchemaShape.toJsonSchema (cyclomatic 16) (openai-core/src/main/scala/io/cequence/openaiscala/service/JsonSchemaShape.scala)
- MethodTooLong: RetryEngine.run (openai-core/src/main/scala/io/cequence/openaiscala/RetryEngine.scala)
- Near-duplicate member pair (81 shared lines) (openai-examples/src/main/scala/io/cequence/openaiscala/examples/typesafe/DecisionContextLatencyBenchmark.scala)
- OpenAIResponsesChatCompletionService.convertMessages (cyclomatic 16) (openai-core/src/main/scala/io/cequence/openaiscala/service/adapter/OpenAIResponsesChatCompletionService.scala)
- Projects may be oversized for their cohesion
- RetryEngine.run (cognitive 38) (openai-core/src/main/scala/io/cequence/openaiscala/RetryEngine.scala)
- RetryEngine.run (cyclomatic 32) (openai-core/src/main/scala/io/cequence/openaiscala/RetryEngine.scala)
- TooManyMethods: ChatCompletionSettingsConversions (openai-core/src/main/scala/io/cequence/openaiscala/service/adapter/ChatCompletionSettingsConversions.scala)
- impl.toVertexAIContents (cognitive 16) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala)
- impl.toVertexAIContents (cyclomatic 16) (google-vertexai-client/src/main/scala/io/cequence/openaiscala/vertexai/service/impl/package.scala)
Changes since last survey
- 28 commits — 27 feature/other, 1 fixes
By area
- (root) — 8 commits
- openai-core/src — 7 commits
- (repo) — 2 commits
- anthropic-client/src — 2 commits
- openai-examples/src — 2 commits
- typesafe-client/src — 2 commits
- claude-agent-client/src — 1 commit
- docs/graders-api.md — 1 commit
- google-gemini-client/src — 1 commit
- google-vertexai-client/src — 1 commit
- openai-client/src — 1 commit
Notable commits
- fix: Merge pull request #132 from dajiaohuang/docs/fix-method-and-provider-keys-20261031
- change: 1.7.0: CHANGELOG dated, version 1.7.0 (Maven Central 2026-11-06)
- change: Anthropic OAuth profiles: a bounded token refresh, no waiting under the lock
- change: Decision models: Sarvam Prism and Bespoke Labs' Nimble presets
- change: Derived JSON schemas: Option as required + nullable, AnyOf, enum order, @JsonSchemaIgnore
- change: Docs: the 1.6.1 CHANGELOG, CLAUDE.md, the providers and streaming pages
- change: Docs: the Groq link (wow.groq.com redirects to groq.com)
- change: Failover policy, one retry engine, failover log levels
- change: GPT-6.1 Terra, Mistral's GLM 5.3 Flash / DeepSeek V4.1 Flash, decision model updates
- change: Gemini: drop refused penalties / n, URL context tool
- change: Groq qwen/qwen3.8-27b leaves models-supporting-json-schema
- change: Guardrails check everything a reply releases (security)
- change: Merge pull request #131 from octo-patch: MiniMax-M3.1-Flash model id, example and docs
- change: MiniMax-M3.1-Flash: conversions per MiniMax's docs, wire specs (follow-up to #131)
- change: MiniMax-M3: split its thinking out of the content, none as thinking disabled
- change: Mistral Large 4: reasoning_effort low / medium / high
- change: OpenAI-shaped streams omit provider-executed tool calls (security)
- change: PathSegment: an id is one URL path segment, a bad one fails the call (security)
- change: Reasoning carried between tool rounds: a provider-neutral ReasoningMessage
- change: Release prep: 1.7.0
- …and 8 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
cequence-io/openai-scala-client was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 13f9d7af51e6edec698af08811a06e473559f5a7 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-5f8314471808.