llm.rb 12.6.0 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1660ea34a112d4c31eb8c9a51000ecd244b0f5629a4f763eceecd734d96f765b
-  data.tar.gz: 8040eefe13ffc48a40181642dad749d6abd7d16950f5d9e379ef006a0bb5af0c
+  metadata.gz: a0304f2a840c94209256729edf114209ffab0bdd309d1a25172818458e4c3f4f
+  data.tar.gz: 46c695d1722ef6e618f27eb9b433f77774bf9140bfd31983589946be3ce53c1e
 SHA512:
-  metadata.gz: cc1821c04eb0f996ca3e5d86d1722565e1fe2bc13351f3771c57de556d7ee9e97d930b3516ec70dea9686fad6443498c40d50584c6065a95242318f054a98d83
-  data.tar.gz: 3cc468ef1332c6f39d6b34a6a11fafe91eaf459ed80d5e79709f8106278fcb6fa1ba4f67b701a38539c3cba4d6967ad88858cccb4bb6b5b12690290036ad2afb
+  metadata.gz: 0a9da53406a6e612f68412005d33b0e85bf6064c9c38ff70e5cd2290f8b381bbba9ae9becd6ca71b15fed399e1d84bdd55972301d0cdb51c10d528d00f5a5d8f
+  data.tar.gz: 882a041334ad21b83397792e3921510c0298b0c623b6c05441117f5655ac1fbe35b560cb015b29bcbd0aad526cc772d9e58596567c72d456d3ee77adc372f397

data/CHANGELOG.md

@@ -15,6 +15,393 @@
 
 ## What's next
 
+_No unreleased changes yet._
+
+## v13.0.0
+
+v13.0.0 relicenses the project under the MIT license, replacing
+the Business Source License that was introduced in v12.0.0. No
+commercial license is needed. Commercial, personal, educational, and
+all other uses are now permitted under the standard MIT terms.
+
+Seven breaking changes. Concurrency strategies have been renamed
+(`:call` → `:sequential`, `:task` → `:async`), `spawn` is now
+`task`, and the `:async` strategy has been rebuilt from the ground
+up. It no longer blocks and now supports interruption. The compactor
+has been refactored into pluggable strategies. Interruption is now
+reliable across all six concurrency backends. The `functions` and
+`functions?` methods have been renamed to `pending_functions` and
+`pending_functions?`.
+
+### Migration from v12.6.0
+
+| Old | New |
+|-----|-----|
+| `fn.spawn(:call)` | `fn.task(:sequential)` |
+| `fn.spawn(:task)` | `fn.task(:async)` |
+| `ctx.wait(:call)` | `ctx.wait(:sequential)` |
+| `agent.concurrency :task` | `agent.concurrency :async` |
+| `LLM::Function::FiberGroup` | `LLM::Function::Fiber::Group` |
+| `LLM::Function::CallGroup` | `LLM::Function::Sequential::Group` |
+| `LLM::Function::TaskGroup` | `LLM::Function::Async::Group` |
+| `Compactor.new(model:, token_threshold:)` | `Compactor::Truncate.new(ctx)` |
+| `on_compaction(ctx, compactor)` | `on_compaction(compactor)` |
+| `ctx.functions` / `ctx.functions?` | `ctx.pending_functions` / `ctx.pending_functions?` |
+| `agent.functions` / `agent.functions?` | `agent.pending_functions` / `agent.pending_functions?` |
+
+### Breaking
+
+* **rename `LLM::Function#spawn` as `LLM::Function#task`** <br>
+  [`LLM::Function#task`](https://r.uby.dev/api-docs/llm.rb/LLM/Function.html#task-instance_method)
+  (previously `spawn`) now consistently returns a
+  [`LLM::Function::Task`](https://r.uby.dev/api-docs/llm.rb/LLM/Function/Task.html)
+  object that can be spawned, waited on, and passed to
+  [`LLM::Function::Group`](https://r.uby.dev/api-docs/llm.rb/LLM/Function/Group.html).
+  The old implementation alternated between spawning immediately or
+  returning a raw thread or fiber.
+
+* **rename concurrency strategies (`:call` → `:sequential`,**
+  **`:task` → `:async`)** <br>
+  The `:call` concurrency strategy is now `:sequential`, and the `:task`
+  strategy is now `:async`.
+  [`LLM::Agent.concurrency`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#concurrency-class_method),
+  [`LLM::Context#wait`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#wait-instance_method),
+  `LLM::Function::Array#task`, and
+  [`LLM::Function#task`](https://r.uby.dev/api-docs/llm.rb/LLM/Function.html#task-instance_method)
+  all accept the new names. The old names raise `ArgumentError`.
+
+* **rename group classes** <br>
+  Group classes have been moved into their strategy's namespace:
+  `FiberGroup` → `Fiber::Group`, `ThreadGroup` → `Thread::Group`,
+  `CallGroup` → `Sequential::Group`, `TaskGroup` → `Async::Group`,
+  `Fork::Group` → `Fork::Group`, `Ractor::Group` → `Ractor::Group`.
+
+* **repurpose `LLM::Function::Task` as a task interface superclass** <br>
+  `LLM::Function::Task` has been repurposed from a general-purpose class
+  that tried to support multiple concurrency strategies into an abstract
+  base class that defines the task interface. Individual strategies
+  (`Sequential::Task`, `Thread::Task`, `Fiber::Task`, `Async::Task`,
+  `Fork::Task`, `Ractor::Task`) now subclass it and implement
+  `spawn`, `alive?`, `interrupt!`, and `wait`.
+
+* **fix `:async` concurrency (now backed by a managed**
+  **`LLM::Function::Async::Reactor` on a background thread)** <br>
+  The `:async` strategy previously used `Async {}` which blocked the
+  caller until all tasks completed and did not support interruption.
+  The fix replaces it with a per-turn
+  `LLM::Function::Async::Reactor` on a background thread. Work is
+  submitted via `submit(&block)` and consumed by the reactor's event
+  loop through a thread-safe `Queue`. `Async::Group` manages the
+  reactor lifecycle and spawns tasks lazily on `wait`.
+  <br><br>
+  Interruption pushes [`LLM::Interrupt`](https://r.uby.dev/api-docs/llm.rb/LLM/Interrupt.html)
+  to the task's result queue instead of using `Fiber#raise`, and
+  results are bridged back to the caller through a second `Queue`.
+  This work drove the broader refactor of strategy naming, the
+  spawn/wait split, and the `Task` superclass. The `:async` strategy
+  needed the same interface the other strategies already had.
+
+* **compactor: refactor to strategy-based interface** <br>
+  [`LLM::Compactor`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor.html)
+  has been refactored from a single class that performed LLM-based
+  summarization into a strategy-based superclass. Each subclass
+  implements a different compaction strategy via `call(**opts)`. The old
+  summarization approach (using `model:`, `token_threshold:`,
+  `message_threshold:`, and `retention_window:` options) has been removed.
+  The built-in
+  [`LLM::Compactor::Truncate`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor/Truncate.html)
+  strategy drops the oldest messages when the conversation exceeds a
+  configured size.
+
+* **rename `LLM::Context#{functions,functions?}` and `LLM::Agent#{functions,functions?}`** <br>
+  [`LLM::Context#functions`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#functions-instance_method)
+  and
+  [`LLM::Context#functions?`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#functions%3F-instance_method)
+  have been renamed to
+  [`LLM::Context#pending_functions`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#pending_functions-instance_method)
+  and
+  [`LLM::Context#pending_functions?`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#pending_functions%3F-instance_method)
+  respectively. The same rename applies to
+  [`LLM::Agent#functions`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#functions-instance_method)
+  (now
+  [`LLM::Agent#pending_functions`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#pending_functions-instance_method)).
+  The `pending_functions` name was already available as an alias in
+  v12.5.0; this change removes the old `functions` name entirely.
+
+### Core
+
+* **extend `LLM.require` with an optional version argument** <br>
+  `LLM.require` now accepts a second `version` parameter that is passed
+  to `Kernel#gem` before loading, enabling version constraints for
+  optional runtime dependencies. For example,
+  `LLM.require "test-cmd.rb", "~> 1.1"` ensures a minimum gem version
+  is available. This is used internally by the `Git`, `Rg`, `Mkdir`,
+  and `Shell` tools to enforce compatibility with the `test-cmd.rb` gem.
+
+### Compactor
+
+* **add `Truncate` strategy for dropping oldest messages** <br>
+  [`LLM::Compactor::Truncate`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor/Truncate.html)
+  is a new built-in compaction strategy that drops the oldest messages
+  when the conversation exceeds a configured size. It preserves tool
+  call/return pairs so the algorithm never breaks in the middle of a
+  sequence. Configured with `keep:` (default 64), it emits the standard
+  `on_compaction` and `on_compaction_finish`
+  [`LLM::Stream`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html)
+  lifecycle callbacks. No LLM call is made; the strategy is purely
+  lossy but fast and requires no network.
+
+* **raise when given an unparseable `keep:` value** <br>
+  `LLM::Compactor::Truncate` now raises `ArgumentError` when the `keep:`
+  parameter cannot be parsed as an integer or percentage string, instead
+  of failing with an obscure error later during execution.
+
+* **accept percentage string for the `keep:` parameter** <br>
+  `LLM::Compactor::Truncate#call` now accepts a percentage string such
+  as `"80%"` for the `keep:` parameter, which keeps approximately 80%
+  of the most recent messages. Integer values continue to work as
+  before. This makes it easy to trim proportionally rather than to an
+  absolute number of messages.
+
+* **add `Null` strategy for no-op compaction** <br>
+  [`LLM::Compactor::Null`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor/Null.html)
+  is a new built-in compaction strategy that does nothing. It is used as
+  the default compactor when no strategy is configured on a context,
+  ensuring the compactor interface is always present without requiring a
+  separate nil check.
+
+* **accept both `LLM::Agent` and `LLM::Context`** <br>
+  [`LLM::Compactor#initialize`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor.html#initialize-instance_method)
+  now accepts both `LLM::Agent` and `LLM::Context` instances. When given
+  an agent, the internal context is unwrapped automatically, making the
+  compactor API more flexible when working with agents.
+
+#### Context integration
+
+* **accept `compactor` and `compactor_options` parameters** <br>
+  [`LLM::Context`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
+  now accepts `compactor:` (a compactor class defaulting to
+  [`LLM::Compactor::Null`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor/Null.html))
+  and `compactor_options:` (a hash of options forwarded to the
+  compactor's `call` method) parameters. The compactor is automatically
+  invoked at the beginning of each `talk` turn. The previous `compactor=`
+  setter has been removed in favour of constructor-driven configuration.
+
+* **`on_compaction` and `on_compaction_finish` receive a single argument** <br>
+  [`LLM::Stream#on_compaction`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_compaction-instance_method)
+  and
+  [`LLM::Stream#on_compaction_finish`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_compaction_finish-instance_method)
+  now accept a single argument (the compactor instance) instead of two
+  arguments (context and compactor). The context is still available via
+  `LLM::Compactor#ctx`, so access to the context is not lost. This
+  simplifies the callback interface for compaction lifecycle observers.
+
+### Tools
+
+* **add `LLM::Tool::Utils` module for shared command execution logic** <br>
+  A new
+  [`LLM::Tool::Utils`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Utils.html)
+  module provides shared `wait(command:, timeout:)` and `now` helper
+  methods for tools that execute commands. Tools that include `Utils` can
+  wait on a running command and automatically kill it when it exceeds the
+  configured timeout, using `Process.clock_gettime` with `CLOCK_MONOTONIC`
+  for precise timing. The module is used by both the `Shell` and `Rg`
+  tools internally.
+
+* **shell: add `timeout` parameter for command execution deadlines** <br>
+  The
+  [`LLM::Tool::Shell`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Shell.html)
+  tool now accepts a `timeout` parameter (default 60s) that automatically
+  kills commands exceeding the specified time limit, preventing hung
+  processes from blocking the agent indefinitely.
+
+* **rg: add `timeout` parameter for search execution deadlines** <br>
+  The
+  [`LLM::Tool::Rg`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Rg.html)
+  tool now accepts a `timeout` parameter (default 5s) that automatically
+  kills search commands exceeding the specified time limit, preventing
+  long-running searches from blocking the agent indefinitely.
+
+* **git: add `timeout` parameter for command execution deadlines** <br>
+  The
+  [`LLM::Tool::Git`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Git.html)
+  tool now accepts a `timeout` parameter (default 5s) that automatically
+  kills git commands exceeding the specified time limit, preventing hung
+  processes from blocking the agent indefinitely.
+
+### Schema
+
+* **properties are now ordered and support indifferent access** <br>
+  [`LLM::Schema::Leaf`](https://r.uby.dev/api-docs/llm.rb/LLM/Schema/Leaf.html)
+  tracks property definition order in a new `index` attribute, matching
+  the convention already used by
+  [`LLM::Command::Parameter`](https://r.uby.dev/api-docs/llm.rb/LLM/Command/Parameter.html).
+  Internally, `@properties` is stored as an
+  [`LLM::Object`](https://r.uby.dev/api-docs/llm.rb/LLM/Object.html)
+  instead of a plain `Hash`, so lookups with both string and symbol keys
+  work.
+
+### Buffer
+
+* **more array-like message management** <br>
+  [`LLM::Buffer`](https://r.uby.dev/api-docs/llm.rb/LLM/Buffer.html)
+  now exposes `first`, `reject!`, `select!`, `shift`, `clear`, `drop`,
+  `take`, and `reverse`, making it easier to query and mutate
+  `LLM::Context#messages` like an ordinary Array. `reject!` is aliased
+  as `delete_if` for familiarity.
+
+* **`last(nil)` no longer returns the last message** <br>
+  `LLM::Buffer#last` now uses an internal `UNDEFINED` sentinel to
+  distinguish between no argument (`last` returns the last message)
+  and `nil` (`last(nil)` is treated as an argument). Previously `nil`
+  was indistinguishable from no argument.
+
+### Function
+
+* **consolidate `call` and `call!` into one method** <br>
+  The private `call!` method has been merged into the public
+  [`LLM::Function#call`](https://r.uby.dev/api-docs/llm.rb/LLM/Function.html#call-instance_method).
+  The separate `call!` method existed for tracer-scoping logic now
+  handled directly inside `call`. All internal call sites now use
+  `function.call` instead of `function.call!`.
+
+* **add `LLM::Function::Group` as an abstract base class** <br>
+  A new abstract base class
+  ([`LLM::Function::Group`](https://r.uby.dev/api-docs/llm.rb/LLM/Function/Group.html))
+  defines the interface that all concurrency strategy groups must
+  implement: `alive?`, `interrupt!`, and `wait`. Each strategy group
+  (`Sequential::Group`, `Thread::Group`, `Fiber::Group`,
+  `Async::Group`, `Fork::Group`, `Ractor::Group`) now subclasses
+  this base.
+
+* **split `spawn` and `wait` across all strategies** <br>
+  `spawn` now starts execution without blocking, and `wait` collects
+  the result. `on_tool_start` moved into each task's `spawn` so the
+  tracer span covers execution rather than construction. Each task and
+  group now exposes a public `spawn` method alongside the existing
+  `wait`/`value` methods.
+
+* **spawn tasks lazily in `Group#wait`** <br>
+  All concurrency strategy groups (Fiber::Group, Fork::Group,
+  Ractor::Group, Thread::Group) now automatically spawn their tasks
+  when `wait` is called if they haven't been spawned yet, matching
+  the existing `Async::Group` behavior. This makes the spawn/wait
+  contract consistent across all six concurrency backends.
+
+### Agent
+
+* **add `name` class DSL and instance method** <br>
+  [`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html) now
+  has a `name` class DSL (`name "admin"`) and a corresponding `#name`
+  instance method. The name is resolved through the same lazy-resolution
+  path as other agent attributes. It can be set via
+  `LLM::Agent.set(name: ...)`, `LLM::Agent.new(name: ...)`, or the class
+  DSL. When no name is given, a default is derived from the class name
+  (e.g., `SystemAdmin` becomes `system-admin`). The REPL uses the name
+  as the prompt label and transcript prefix, making it easier to
+  distinguish multiple sessions.
+
+### REPL
+
+* **agent identity in the prompt** <br>
+  [`LLM::Agent#repl`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#repl-instance_method)
+  and
+  [`LLM::Repl.new`](https://r.uby.dev/api-docs/llm.rb/LLM/Repl.html#initialize-instance_method)
+  accept a `name:` parameter (defaulting to `LLM::Agent#name`) that sets
+  the input prompt to `provider(name)> ` and labels transcript messages
+  with the agent's name instead of a hardcoded `agent:`. Useful when
+  running multiple sessions.
+
+* **`/compact` command** <br>
+  New built-in `/compact` command frees context window space by dropping
+  the oldest messages via
+  [`LLM::Compactor::Truncate`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor/Truncate.html).
+  Supports both integer (`/compact 32`) and percentage (`/compact 75%`)
+  arguments. Defaults to keeping the last 128 messages.
+
+* **tab-completion for `/` commands** <br>
+  Pressing Tab on an input line starting with `/` autocompletes the
+  command name. Repeated Tab presses cycle through matching commands.
+  Powered by
+  [`LLM::Command.complete(str)`](https://r.uby.dev/api-docs/llm.rb/LLM/Command.html#complete-class_method)
+  which is available outside the REPL too.
+
+* **command system enhancements** <br>
+  Commands can set parameter defaults in their `call` method signature
+  (e.g., `def call(n: 128)`). Aliases like `/quit` now inherit their
+  parent's description and parameters. Commands also have access to
+  the active `agent` and `repl` via public readers.
+
+* **tool argument sorting** <br>
+  Tool parameters in the status bar are now displayed in definition
+  order (using the new `index` attribute), regardless of the order
+  the model returns them.
+
+* **expanded markdown rendering** <br>
+  The curses-based markdown renderer now handles lists (`<ul>`, `<ol>`),
+  blockquotes, horizontal rules, hyperlinks (underline), images
+  (`[image: alt text]`), and tables (aligned columns).
+
+* **input improvements** <br>
+  Ctrl+P and Ctrl+N walk through conversation history (user messages
+  only, managed by
+  [`LLM::Repl::Walker`](https://r.uby.dev/api-docs/llm.rb/LLM/Repl/Walker.html)).
+  Page Up/Down scroll the transcript by a page. ENTER and BACKSPACE are
+  now mapped to raw character codes from `Curses.getch` instead of
+  `Curses::Key` constants.
+
+### Object
+
+* **preserve the original key name in `KeyError` messages** <br>
+  `LLM::Object#fetch` now preserves the original key name when a key
+  is not found, instead of raising `KeyError` with `key not found: nil`.
+  The previous behavior occurred when the given key was not found in
+  the stored hash, causing internal lookup to return `nil` and lose
+  the original key reference.
+
+### Registry
+
+* **refresh model metadata across providers** <br>
+  Update `data/*.json` files with current provider model listings and
+  pricing. Mark several DeepInfra models as deprecated (`meta-llama/
+  Meta-Llama-3.1-8B-Instruct`, `Qwen/Qwen1.5-110B-Chat`, and
+  `mistralai/Mixtral-8x7B-Instruct-v0.1`). Correct xAI cache-read
+  pricing from $0.50 to $0.30 per million input tokens.
+
+### Fix
+
+* **agent: fix default name resolution when name is not explicitly set** <br>
+  Fix a bug where `LLM::Agent` derived its default name from
+  `self.class` instead of `self`, causing the name to be `"class"`
+  instead of a parameterized version of the actual class name
+  (e.g., `"system-admin"` for `SystemAdmin`). The fix uses `self`
+  directly, which correctly resolves the class name at the instance
+  level.
+
+* **function: make Fork::Task and Ractor::Task inherit LLM::Function::Task** <br>
+  `LLM::Function::Fork::Task` and `LLM::Function::Ractor::Task` now
+  explicitly subclass `LLM::Function::Task` and accept an options hash
+  as their second argument, matching the constructor signature used
+  by the other four task classes. The interface was already compatible
+  but the inheritance was missing by mistake. It is now consistent across
+  all six concurrency backends.
+
+* **google: fix `stream` parameter leakage that broke the provider** <br>
+  Fix a bug in the Google provider where `stream: stream.enabled?` was
+  being merged into request parameters, causing API-level errors. The
+  Google provider does not use a `stream` parameter. Streaming is
+  controlled via the URL path (`streamGenerateContent` vs
+  `generateContent`). The fix removes the leaked parameter and correctly
+  routes streaming requests through the appropriate path.
+
+* **fork: fix deadlock on xchan.rb channel** <br>
+  Fix a deadlock in the `:fork` concurrency strategy where both the
+  writer and reader could get stuck on the xchan channel, preventing the
+  reader from draining the channel. The deadlock surfaced as an errno
+  failure, especially with large tool returns. The fix requires xchan.rb
+  v0.22.0 and uses the `SOCK_STREAM` socket type for communicating a
+  tool's return value.
+
 ## v12.6.0
 
 Changes since `v12.5.1`.

data/LICENSE

@@ -1,93 +1,21 @@
-Business Source License 1.1
-
-License text copyright (c) 2024 MariaDB plc, All Rights Reserved.
-"Business Source License" is a trademark of MariaDB plc.
-
-Parameters
-
-Licensor: Robert Gleeson
-
-Licensed Work: llm.rb
-
-Additional Use Grant:
-- Free for personal use
-- Free for students and their teachers
-- Free for evaluation, development, and testing
-- Free for non-profits and charities
-- Free for companies with less than or equal to 50 employees
-
-Change Date:
-Four years after the first public release of each specific version of the
-Licensed Work.
-
-Change License:
-BSD Zero Clause License (0BSD)
-
-Terms
-
-The Licensor hereby grants you the right to copy, modify, create derivative
-works, redistribute, and make non-production use of the Licensed Work. The
-Licensor may make an Additional Use Grant, above, permitting limited
-production use.
-
-Effective on the Change Date, or the fourth anniversary of the first publicly
-available distribution of a specific version of the Licensed Work under this
-License, whichever comes first, the Licensor hereby grants you rights under
-the terms of the Change License, and the rights granted in the paragraph
-above terminate.
-
-If your use of the Licensed Work does not comply with the requirements
-currently in effect as described in this License, you must purchase a
-commercial license from the Licensor, its affiliated entities, or authorized
-resellers, or you must refrain from using the Licensed Work.
-
-All copies of the original and modified Licensed Work, and derivative works
-of the Licensed Work, are subject to this License. This License applies
-separately for each version of the Licensed Work and the Change Date may vary
-for each version of the Licensed Work released by Licensor.
-
-You must conspicuously display this License on each original or modified copy
-of the Licensed Work. If you receive the Licensed Work in original or
-modified form from a third party, the terms and conditions set forth in this
-License apply to your use of that work.
-
-Any use of the Licensed Work in violation of this License will automatically
-terminate your rights under this License for the current and all other
-versions of the Licensed Work.
-
-This License does not grant you any right in any trademark or logo of
-Licensor or its affiliates (provided that you may use a trademark or logo of
-Licensor as expressly required by this License).
-
-TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
-AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
-EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
-TITLE.
-
-MariaDB hereby grants you permission to use this License's text to license
-your works, and to refer to it using the trademark "Business Source
-License", as long as you comply with the Covenants of Licensor below.
-
-Covenants of Licensor
-
-In consideration of the right to use this License's text and the "Business
-Source License" name and trademark, Licensor covenants to MariaDB, and to all
-other recipients of the licensed work to be provided by Licensor:
-
-To specify as the Change License the GPL Version 2.0 or any later version, or
-a license that is compatible with GPL Version 2.0 or a later version, where
-"compatible" means that software provided under the Change License can be
-included in a program with software provided under GPL Version 2.0 or a later
-version. Licensor may specify additional Change Licenses without limitation.
-
-To either: (a) specify an additional grant of rights to use that does not
-impose any additional restriction on the right granted in this License, as
-the Additional Use Grant; or (b) insert the text "None" to specify a Change
-Date. Not to modify this License in any other way.
-
-Notice
-
-The Business Source License (this document, or the "License") is not an Open
-Source license. However, the Licensed Work will eventually be made available
-under an Open Source License, as stated in this License.
+MIT License
+
+Copyright (c) 2026 Robert Gleeson
+
+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.