squishling-apple_fm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f97e80f00f3372ce23f28c676a1ffd338ea30d12cbd75b873838cc01ab9ac2cc
+  data.tar.gz: 9e8caee2e3c3dbdac8cc77e3882d4c62b894d8fd4faa6b49ab4be861aaf2d4dc
+SHA512:
+  metadata.gz: e75902b790a2a7f30644cb4718225bbd344160f31ad1999c014bddcdfbf149e251e264089fdb9c916d16980c43b002ded9ec6cfeeb26f30216dfed6bf15f3c56
+  data.tar.gz: 81292e378a9671f34d37e105601c8080b68b08e80cf0a125aa2653f5a39276145ea29bb7be5144a3c12872f0ce767fe5f1edcaa00753b94d7a7cd892283ae8ec

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-11-01
+
+First release.
+
+### Added
+
+- A Squishling adapter for Apple Intelligence, registered as `:apple_fm`: Squishling's LLM calls run on the on-device
+  model built into macOS 26 and later (Apple Foundation Models), with no API key, no network, and no cost. Meant for
+  developing against Squishling locally; the model is small (4096-token context window) and macOS-only. Options:
+  `timeout:`, `helper:`, `cache_dir:`. Needs Squishling 0.5.0 or later. (#1, #4)
+- A small Swift helper that the gem compiles with your own `swiftc` on first use, caches by the source's digest, and runs
+  once per request over stdin/stdout JSON. Nothing is downloaded or shipped prebuilt. (#1)
+- Strict structured output: Squishling's strict schema is translated into Apple's guided generation, and Squishling still
+  validates every answer against your full schema. (#1)
+- A reply cut off by `max_output_tokens` is reported to Squishling as a cutoff (`finish_reason: :max_tokens`), so
+  `InvalidOutputError#truncated?` says so instead of a generic failure. (#4)
+- Live smoke tests in `examples/` (`quickstart.rb` and `apple_fm_example.rb`) for a Mac with Apple Intelligence. (#4)
+
+### Security
+
+- The helper is started with no shell, so a cache or helper path containing spaces or shell characters (for example a
+  home directory like `/Users/Mary Ann`) is run as given instead of being split or interpreted.
+- The helper cache directories are created with mode 0700.
+- A blank `helper:` or `cache_dir:` is rejected with a `ConfigurationError` instead of building under the filesystem root.

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,90 @@
+# squishling-apple_fm
+
+[Squishling](https://github.com/Coolhand-Labs/squishling) adapter for **Apple Intelligence**: run your Ruby LLM calls
+on the on-device model built into macOS 26 and later (Apple Foundation Models). No API key, no network, no cost, so
+you can try Squishling and develop against it locally, then run production on a hosted model.
+
+```ruby
+# Gemfile
+gem "squishling"
+gem "squishling-apple_fm", group: :development
+```
+
+```ruby
+Squishling.configure do |config|
+  config.adapter = :apple_fm if Rails.env.development?   # or any check that says "on my Mac"
+end
+
+class SentimentClassifier
+  include Squishling
+
+  purpose "Classify the sentiment of the review."
+  output_schema do
+    string :sentiment, enum: %w[positive negative neutral]
+    optional(:quote) { string }
+  end
+end
+
+SentimentClassifier.call(review: "Loved it, would buy again!")
+# => #<data sentiment="positive", quote=nil>, the same typed result a hosted model returns
+```
+
+## Requirements
+
+- macOS 26 or later on Apple Silicon, with **Apple Intelligence turned on** (System Settings).
+- Xcode or its Command Line Tools (`xcode-select --install`). Apple's FoundationModels framework is Swift-only, so the
+  gem bundles a small Swift program and compiles it with your `swiftc` the first time it is needed (a few seconds). The
+  binary is cached under `~/Library/Caches/squishling/apple_fm`, so later calls start in under a second.
+- Ruby 3.3+ and Squishling 0.5 or later.
+
+It adds no other gem, runs no server, and makes no network request.
+
+## Options
+
+```ruby
+config.adapter = { type: :apple_fm, timeout: 60 }
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `timeout` | `120` | Seconds to wait for an answer before the call fails with an `LLMError`. |
+| `helper` | compiled from the bundled source | The path of a prebuilt helper to run instead. |
+| `cache_dir` | `~/Library/Caches/squishling/apple_fm` (or under `$XDG_CACHE_HOME`) | Where compiled helpers are kept. |
+
+The system has one model, so `model:` and `provider:` are ignored. `temperature` and `max_output_tokens` are sent;
+other params raise `Squishling::ConfigurationError`.
+
+## Know the limits
+
+This is a small on-device model, for **developing** the shape of a call, not for judging its quality:
+
+- The **context window is 4096 tokens** for the prompt, schema, and answer together; a call that doesn't fit is an `LLMError`.
+- An **optional nested object** (`optional { object { ... } }`) often comes back `null` even when the input has the
+  value; in testing, an optional scalar was filled in reliably. Make the object required, with `[]` or `""` for "none"
+  in its fields, when it matters.
+- It picks between choices less reliably than a hosted model.
+
+## Documentation
+
+- **[How it works](docs/how-it-works.md)**: the Swift helper and its cache, how schemas are translated for Apple's guided
+  generation, how failures map to Squishling's errors, limits, and troubleshooting.
+- [Squishling's adapters](https://github.com/Coolhand-Labs/squishling/blob/main/docs/adapters.md): the adapter contract
+  and the other adapters.
+- [Changelog](CHANGELOG.md)
+
+## Development
+
+```bash
+bundle install
+bundle exec rake                              # RSpec (offline: the Swift helper is stubbed) + RuboCop
+bin/exhale dry --include-tests                # duplication gate
+bin/exhale complexity                         # complexity gate
+bundle exec ruby examples/quickstart.rb       # live smoke test, on a Mac with Apple Intelligence
+bundle exec ruby examples/apple_fm_example.rb # the full live suite, same requirements
+```
+
+See [AGENTS.md](AGENTS.md) for the design invariants and the release process.
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/SECURITY.md

@@ -0,0 +1,28 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest published version of `squishling-apple_fm` on RubyGems is supported with security fixes.
+Please upgrade to the latest version before reporting an issue.
+
+## Reporting a Vulnerability
+
+Please do **not** open a public GitHub issue for security vulnerabilities.
+
+Instead, report vulnerabilities privately using one of the following:
+
+- [GitHub Security Advisories](https://github.com/Coolhand-Labs/squishling-apple-fm-adapter/security/advisories/new)
+  for this repository (preferred)
+- Email team@coolhandlabs.com
+
+Please include a description of the vulnerability, steps to reproduce, and the impact you believe
+it has. We aim to acknowledge reports within 3 business days and to provide a fix or mitigation
+plan within 30 days, depending on severity.
+
+## What this gem runs
+
+The gem compiles `lib/squishling/apple_fm/helper.swift` with the `swiftc` on your machine and runs the resulting binary
+(cached under `~/Library/Caches/squishling/apple_fm`, or `$XDG_CACHE_HOME`) once per request. It never downloads or ships
+a prebuilt binary. Anyone who can write to that cache directory can already run code as you, so keep it user-private;
+the `helper:` option runs whatever path you give it. Reports about the helper, the cache, or the request/response
+handling are in scope.

data/docs/how-it-works.md

@@ -0,0 +1,84 @@
+# How it works
+
+`squishling-apple_fm` runs Squishling's requests on Apple's on-device model (Apple Intelligence, through the
+FoundationModels framework). Squishling builds the request, this adapter makes one completion, and Squishling does the
+rest: validation, retries and escalation, harnesses, `squawk`, and fallbacks. See
+[Squishling's adapter contract](https://github.com/Coolhand-Labs/squishling/blob/main/docs/adapters.md#writing-your-own).
+
+## The Swift helper
+
+FoundationModels is Swift-only: it has no C or Objective-C interface, so Ruby can't call it directly. The gem ships one
+small Swift program, `lib/squishling/apple_fm/helper.swift`.
+
+- **Built on first use** with the `swiftc` from Xcode or its Command Line Tools, into
+  `~/Library/Caches/squishling/apple_fm/<digest of the source>/helper` (under `$XDG_CACHE_HOME` when that is set, or in
+  `cache_dir:`). A new gem version with a changed source builds a new binary; old ones stay until you delete the
+  directory. The build takes a few seconds, runs under a file lock so concurrent processes build once, and is renamed into
+  place so nobody runs a half-written file. The cache directories are created readable only by you (mode 0700), because
+  the binary's path is predictable; if you point `cache_dir:` at a directory that others can write to, they could put a
+  binary there, so keep it private.
+- **One process per request.** Ruby writes one JSON request to its stdin and reads one JSON line from its stdout, so there
+  is no server, no shared state, and Squishling's concurrent samples each get their own process (about 0.8 seconds per
+  call once built, mostly model time).
+- **Private protocol.** The request is `{ instructions, messages, schema, temperature?, max_tokens? }`; the answer is
+  `{ content, usage?, finish_reason? }` or `{ error: <code> }`. Apple's own error messages never leave the helper, only a code.
+- **Token counts** (`usage`) come from FoundationModels on macOS 26.4 and later; on 26.0 to 26.3 there are none.
+- `helper:` runs a prebuilt binary instead, for example one built in CI or by your own tooling. It is run as given, with
+  no shell, so a path with spaces or other special characters works.
+
+## Schemas
+
+Squishling always sends a strict schema: every key required, `optional` fields as `anyOf: [T, null]`. Apple's guided
+generation reads its own JSON Schema dialect, so the adapter translates it, and the model is constrained to the result:
+
+| Squishling's schema | Sent to the model |
+|---|---|
+| objects | a `title`, `x-order` (the property order), and `additionalProperties: false` |
+| `anyOf: [T, null]` (`optional`) | the same, with a `title` on the union (a real nullable) |
+| `type: ["string", "null"]` (raw schemas) | split into `anyOf` |
+| `$ref` / `$defs` | inlined (a schema that refers to itself raises `ConfigurationError`) |
+| `enum`, `minimum`, `maximum`, `minItems`, `maxItems`, `description` | kept |
+| `pattern`, `minLength`, `maxLength`, `format`, `const`, `default`, … | left out |
+
+What is left out can't guide the model (some of it makes generation fail), but **Squishling validates every answer
+against your full schema anyway**, so a value that breaks a `pattern` is still rejected and retried.
+
+## Failures
+
+| What happened | Raised | Notes |
+|---|---|---|
+| Not macOS, or an Apple Silicon Mac without macOS 26 | `ConfigurationError` | never retried |
+| Apple Intelligence off, or the device ineligible | `ConfigurationError` | the message says to turn it on |
+| `swiftc` missing, the compile fails, or the cache isn't writable | `ConfigurationError` | the message gives the command to run |
+| A schema the model can't generate | `ConfigurationError` | |
+| A param other than `temperature` / `max_output_tokens` | `ConfigurationError` | |
+| A reply cut off by `max_output_tokens` | invalid output (retried) | the framework only reports a decoding failure, so any decoding failure with a limit set is treated as a cutoff; the answer is empty and `finish_reason` is `:max_tokens`, so Squishling says it was a cutoff. Raise the limit or ask for less |
+| Prompt, schema, and answer over 4096 tokens | `LLMError` | depends on the input, so a retry or fallback may help |
+| Apple's guardrails decline, a rate limit, the model still downloading, an unsupported language | `LLMError` | |
+| The helper crashes, answers with garbage, or takes longer than `timeout` | `LLMError` | a timed-out helper is killed |
+
+Messages carry only the kind of failure. The system's own message, the helper's stderr, and the model's output never
+appear in an error or log.
+
+## Limits of the model
+
+It is a small on-device model, so it is for developing the shape of a call:
+
+- **4096-token context window**, shared by the instructions, the conversation (a retry replays the rejected answer), the
+  schema, and the answer.
+- **An optional nested object comes back `null`.** Given a note that says "Heart rate 88", `optional :vitals { object {
+  integer :heart_rate } }` was `null` in 10 of 10 runs, while the same field required returned 88 in 10 of 10, and a
+  flat `optional(:heart_rate) { integer }` returned 88 in 10 of 10. The schema sent is the expected
+  `anyOf: [object, null]`, so whether this is the model's preference for the `null` branch or something in how the
+  union is written is not established; an earlier note that reordering the union or describing the field doesn't help
+  has not been re-checked. Make the object required, with `[]` or `""` for "none" in its fields, if it matters.
+- **It chooses less reliably** than a hosted model between enum values, so a classification can differ from production's.
+
+## Troubleshooting
+
+- `turn on Apple Intelligence in System Settings`: System Settings → Apple Intelligence & Siri. The first run may also
+  download the model (`the on-device model isn't ready yet`); retry in a few minutes.
+- `swiftc wasn't found`: `xcode-select --install`, or install Xcode.
+- `compiling the apple_fm helper failed`: run the `swiftc` command in the message to see Swift's own output. The framework
+  needs Xcode 26 or later.
+- A stale or suspect binary: delete `~/Library/Caches/squishling/apple_fm`; it rebuilds on the next call.

data/lib/squishling/apple_fm/adapter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Squishling
+  module AppleFM
+    # Runs requests on the on-device model built into macOS (Apple Intelligence, through the FoundationModels
+    # framework): free, offline, and private, so a good fit for developing against Squishling without an API key or a
+    # bill. It needs macOS 26 or later on Apple Silicon with Apple Intelligence turned on, and Xcode (or its Command
+    # Line Tools) to compile a small Swift helper on first use. No gem, no server, no network. The model is small
+    # (a 4096-token context window for the prompt, the schema, and the answer), so expect to develop here and run
+    # production on a bigger model. See the README.
+    #
+    #   Squishling.configure do |config|
+    #     config.adapter = :apple_fm
+    #   end
+    class Adapter < Squishling::Adapter::Base
+      # What Response#model reports: the system has one model and doesn't name it.
+      MODEL = "apple-foundation-model"
+      PORTABLE_PARAMS = %i[temperature max_output_tokens].freeze
+      TOKEN_KEYS = %w[input_tokens output_tokens].freeze
+      # The helper's error codes. A setup mistake is never retried; the rest depend on the input or the moment, so
+      # another attempt may work. Only these texts are used: the system's own message is never repeated.
+      SETUP_FAILURES = {
+        "device_not_eligible" => "this Mac can't run Apple Intelligence",
+        "apple_intelligence_not_enabled" => "turn on Apple Intelligence in System Settings",
+        "unsupported_schema" => "the schema uses something the on-device model can't generate",
+        "bad_request" => "the helper couldn't read the request"
+      }.freeze
+      FAILURES = {
+        "context_window" => "the prompt, schema, and answer didn't fit the model's 4096-token context window",
+        "guardrail" => "the model declined the request (Apple's safety guardrails)",
+        "unsupported_language" => "the model doesn't support the language of the request",
+        "rate_limited" => "the system rate-limited the request",
+        "model_not_ready" => "the on-device model isn't ready yet (it may still be downloading)"
+      }.freeze
+      private_constant :PORTABLE_PARAMS, :TOKEN_KEYS, :SETUP_FAILURES, :FAILURES
+
+      # timeout: seconds to wait for an answer before giving up (an LLMError). helper: the path of a prebuilt helper
+      # to run instead of compiling the bundled one. cache_dir: where compiled helpers are kept (default
+      # ~/Library/Caches/squishling/apple_fm, or under $XDG_CACHE_HOME). Raises ConfigurationError for a bad option.
+      def initialize(timeout: 120, helper: nil, cache_dir: nil)
+        super()
+        invalid(:timeout, "a positive number", timeout) unless timeout.is_a?(Numeric) && timeout.positive?
+        @timeout = timeout
+        @helper = Helper.new(path: path(:helper, helper), cache_dir: path(:cache_dir, cache_dir))
+      end
+
+      def complete(request)
+        answer = @helper.call(payload(request), timeout: @timeout)
+        if answer["content"].is_a?(String)
+          return Squishling::Adapter::Response.new(content: answer["content"], model: MODEL,
+            tokens: tokens_of(answer["usage"]), finish_reason: finish_reason_of(answer))
+        end
+
+        raise failure(request, answer["error"].to_s)
+      rescue Helper::Unavailable => e
+        raise configuration_error(request, e.message)
+      rescue Helper::Failed => e
+        raise llm_error(request, e.message)
+      end
+
+      private
+
+      def payload(request)
+        { "instructions" => request.instructions, "messages" => messages(request),
+          "schema" => GenerationSchema.call(request.schema["schema"]) }.merge(generation_options(request))
+      end
+
+      def messages(request)
+        request.messages.map { |message| { "role" => message[:role].to_s, "content" => message[:content] } }
+      end
+
+      # The system has no reasoning mode and takes no provider-specific params.
+      def generation_options(request)
+        params = request.params
+        unsupported = params.keys - PORTABLE_PARAMS
+        unsupported -= [:thinking] unless params[:thinking]
+        unless unsupported.empty?
+          raise configuration_error(request, "the on-device model takes only the temperature and max_output_tokens " \
+                                             "params, not #{unsupported.join(', ')}")
+        end
+
+        { "temperature" => params[:temperature], "max_tokens" => params[:max_output_tokens] }.compact
+      end
+
+      # The helper counts tokens on macOS 26.4 and later; before that it sends none.
+      def tokens_of(usage)
+        return {} unless usage.is_a?(Hash)
+
+        usage.slice(*TOKEN_KEYS).select { |_, count| count.is_a?(Integer) }.transform_keys(&:to_sym)
+      end
+
+      # The helper reports only a reply that max_output_tokens cut off; it has no other reason to give.
+      def finish_reason_of(answer)
+        :max_tokens if answer["finish_reason"] == "max_tokens"
+      end
+
+      def failure(request, code)
+        return configuration_error(request, SETUP_FAILURES[code]) if SETUP_FAILURES.key?(code)
+
+        llm_error(request, FAILURES.fetch(code, "the on-device model failed"))
+      end
+
+      def path(name, value)
+        return nil if value.nil?
+
+        text = value.respond_to?(:to_path) ? value.to_path : value
+        return text if text.is_a?(String) && !text.strip.empty?
+
+        invalid(name, "a path", value)
+      end
+
+      def invalid(name, expected, value)
+        raise ConfigurationError, "adapter :apple_fm #{name} must be #{expected}, got #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/squishling/apple_fm/generation_schema.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Squishling
+  module AppleFM
+    # Rewrites a strict output schema into the JSON Schema dialect Apple's on-device model decodes
+    # (FoundationModels' GenerationSchema), for AppleFM::Adapter. It keeps only the keywords the model can be
+    # guided by and adds the ones Apple's decoder insists on; Squishling's own validation still enforces the rest.
+    module GenerationSchema
+      # Everything else (pattern, minLength, format, const, ...) is dropped: the model fails to generate with some of
+      # them, and none can be guided, so local validation decides.
+      KEPT = %w[type enum description properties required items anyOf minimum maximum minItems maxItems].freeze
+      SCHEMA_MAPS = %w[properties $defs definitions].freeze
+      MAX_REF_DEPTH = 16
+      private_constant :KEPT, :SCHEMA_MAPS, :MAX_REF_DEPTH
+
+      module_function
+
+      # name: the title of the root object. Raises ConfigurationError for a schema that refers to itself.
+      def call(schema, name: "Response")
+        decorate(prune(inline(schema, schema, 0)), name)
+      end
+
+      # $ref to a local definition becomes the definition itself; Apple's decoder has no references.
+      def inline(node, root, depth)
+        case node
+        when Array then node.map { |item| inline(item, root, depth) }
+        when Hash then inline_hash(node, root, depth)
+        else node
+        end
+      end
+
+      def inline_hash(node, root, depth)
+        return inline_ref(node["$ref"], root, depth) if node["$ref"].is_a?(String)
+
+        node.to_h { |key, value| [key, inline_value(key, value, root, depth)] }
+      end
+
+      def inline_ref(ref, root, depth)
+        if depth > MAX_REF_DEPTH
+          raise ConfigurationError,
+            "squishling-apple_fm can't use a schema that refers to itself"
+        end
+
+        inline(definition(root, ref), root, depth + 1)
+      end
+
+      # Property and definition names are data, never keywords or references.
+      def inline_value(key, value, root, depth)
+        return inline(value, root, depth) unless SCHEMA_MAPS.include?(key) && value.is_a?(Hash)
+
+        value.transform_values { |schema| inline(schema, root, depth) }
+      end
+
+      def definition(root, ref)
+        return root if ref == "#"
+
+        found = ref.delete_prefix("#/").split("/").reduce(root) { |node, key| node.is_a?(Hash) ? node[key] : nil }
+        return found if found.is_a?(Hash)
+
+        raise ConfigurationError, "squishling-apple_fm can't resolve the schema reference #{ref.inspect}"
+      end
+
+      # Drops every keyword outside KEPT. Property names are data and stay, so only a schema's keywords are filtered.
+      def prune(node)
+        return node unless node.is_a?(Hash)
+        return prune(split_types(node)) if node["type"].is_a?(Array)
+
+        node.slice(*KEPT).to_h { |key, value| [key, prune_value(key, value)] }
+      end
+
+      # type: ["string", "null"] is anyOf: [{ type: "string" }, { type: "null" }], the form Apple's decoder reads.
+      def split_types(node)
+        shared = node.except("type", "description")
+        shared["enum"] = shared["enum"].compact if shared["enum"].is_a?(Array) && node["type"].include?("null")
+        branches = node["type"].map { |type| type == "null" ? { "type" => "null" } : shared.merge("type" => type) }
+        { "anyOf" => branches }.merge(node.slice("description"))
+      end
+
+      def prune_value(key, value)
+        case key
+        when "properties" then value.transform_values { |schema| prune(schema) }
+        when "items" then prune(value)
+        when "anyOf" then value.map { |schema| prune(schema) }
+        else value
+        end
+      end
+
+      # Apple's decoder wants a title on every object and anyOf node, the property order, and an explicit
+      # additionalProperties. A title on a plain branch would make it a "named type", so branches stay bare.
+      def decorate(node, name)
+        return node unless node.is_a?(Hash)
+
+        if node["anyOf"] then decorate_union(node, name)
+        elsif node["type"] == "object" then decorate_object(node, name)
+        elsif node["type"] == "array" then node.merge("items" => decorate(node["items"], "#{name}Item"))
+        else node
+        end
+      end
+
+      def decorate_union(node, name)
+        node.merge("title" => name, "anyOf" => node["anyOf"].map { |branch| decorate(branch, name) })
+      end
+
+      def decorate_object(node, name)
+        properties = (node["properties"] || {}).to_h { |key, schema| [key, decorate(schema, key)] }
+        node.merge("title" => name, "properties" => properties, "x-order" => properties.keys,
+          "required" => node["required"] || [], "additionalProperties" => false)
+      end
+    end
+  end
+end

data/lib/squishling/apple_fm/helper.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "open3"
+
+module Squishling
+  module AppleFM
+    # The small Swift program AppleFM::Adapter talks to. Apple's FoundationModels framework is Swift-only (no C or
+    # Objective-C interface), so something Swift has to call it: apple_fm/helper.swift reads one JSON request on stdin
+    # and writes one JSON answer on stdout. It is compiled on first use with the swiftc that ships with Xcode or the
+    # Command Line Tools, and the binary is cached by the source's digest, so later calls (and later processes) start
+    # it directly. A call is one process, so there is no shared state between threads.
+    class Helper
+      SOURCE = File.join(__dir__, "helper.swift")
+
+      # The helper can't run here (not macOS, no compiler, it won't compile): a setup mistake.
+      class Unavailable < StandardError
+      end
+
+      # The helper ran but produced no answer (it crashed, or took too long): worth another attempt.
+      class Failed < StandardError
+      end
+
+      # path: a prebuilt helper to use instead of compiling the bundled source. cache_dir: where compiled helpers go.
+      def initialize(path: nil, cache_dir: nil)
+        @path = path
+        @cache_dir = cache_dir || default_cache_dir
+        @build_lock = Mutex.new
+      end
+
+      # Sends request (a Hash) and returns the helper's answer (a Hash). Raises Unavailable or Failed.
+      def call(request, timeout:)
+        command = executable
+        # [command, command] is the program and its argv[0], run as given: a bare String with a space or a shell
+        # metacharacter in it (a home directory like "/Users/Mary Ann") would be split or handed to /bin/sh.
+        Open3.popen2([command, command], err: File::NULL) do |stdin, stdout, wait|
+          send_request(stdin, request)
+          reader = Thread.new { stdout.read }
+          timed_out = reader.join(timeout).nil?
+          kill(wait.pid) if timed_out
+          answer(timed_out ? nil : reader.value, wait.value, timeout)
+        end
+      rescue Errno::ENOENT, Errno::EACCES
+        raise Unavailable, "the apple_fm helper #{command.inspect} can't be run"
+      end
+
+      private
+
+      # The helper may exit on its own between the timeout and the kill.
+      def kill(pid)
+        Process.kill("KILL", pid)
+      rescue Errno::ESRCH
+        nil
+      end
+
+      def send_request(stdin, request)
+        stdin.write(JSON.generate(request))
+      rescue Errno::EPIPE
+        nil # the helper already exited; its status explains why
+      ensure
+        stdin.close
+      end
+
+      def answer(output, status, timeout)
+        raise Failed, "the helper took longer than #{timeout}s" if output.nil?
+
+        parsed = JSON.parse(output.to_s.dup.force_encoding(Encoding::UTF_8))
+        return parsed if parsed.is_a?(Hash)
+
+        raise Failed, "the helper answered with something other than a JSON object"
+      rescue JSON::ParserError
+        raise Failed, "the helper produced no answer (#{describe(status)})"
+      end
+
+      def describe(status)
+        status.signaled? ? "signal #{status.termsig}" : "exit #{status.exitstatus}"
+      end
+
+      # Built once per process, and again if the cache was cleared since.
+      def executable
+        @build_lock.synchronize do
+          @executable = nil unless @executable && File.executable?(@executable)
+          @executable ||= @path || build
+        end
+      end
+
+      def build
+        unless RUBY_PLATFORM.include?("darwin")
+          raise Unavailable, "Apple's on-device model needs macOS 26 or later on Apple Silicon"
+        end
+
+        target = File.join(@cache_dir, Digest::SHA256.file(SOURCE).hexdigest[0, 16], "helper")
+        compile(target) unless File.executable?(target)
+        target
+      end
+
+      # Compiled to a temporary name and renamed into place, under a file lock so that concurrent processes build
+      # once and none runs a half-written binary. The directories it creates are private to the user: the binary's
+      # path is predictable (the source's digest), so nobody else may be able to put a file there.
+      def compile(target)
+        FileUtils.mkdir_p(File.dirname(target), mode: 0o700)
+        File.open("#{target}.lock", File::RDWR | File::CREAT) do |lock|
+          lock.flock(File::LOCK_EX)
+          next if File.executable?(target)
+
+          temporary = "#{target}.#{Process.pid}.tmp"
+          swiftc(temporary)
+          File.rename(temporary, target)
+        end
+      rescue SystemCallError
+        raise Unavailable, "the apple_fm helper can't be built in #{@cache_dir.inspect}; give the adapter a writable " \
+                           "cache_dir:"
+      end
+
+      def swiftc(output)
+        command = ["swiftc", "-O", SOURCE, "-o", output]
+        _, status = Open3.capture2e(*command)
+        return if status.success?
+
+        FileUtils.rm_f(output)
+        raise Unavailable, "compiling the apple_fm helper failed; run `#{command.join(' ')}` to see why " \
+                           "(it needs Xcode 26 or later, or its Command Line Tools)"
+      rescue Errno::ENOENT
+        raise Unavailable, "swiftc wasn't found; install Xcode or run `xcode-select --install`"
+      end
+
+      # $XDG_CACHE_HOME when it is set and not empty (the XDG spec treats empty as unset), else ~/Library/Caches.
+      def default_cache_dir
+        base = ENV.fetch("XDG_CACHE_HOME", "").strip
+        base = File.join(Dir.home, "Library", "Caches") if base.empty?
+        File.join(base, "squishling", "apple_fm")
+      end
+    end
+  end
+end

data/lib/squishling/apple_fm/helper.swift

@@ -0,0 +1,108 @@
+import Foundation
+import FoundationModels
+
+// Reads one JSON request on stdin, writes one JSON line on stdout. Exit status is 0 whenever a line was written.
+// Request:  {"instructions": String?, "messages": [{"role": "user"|"assistant", "content": String}],
+//            "schema": <JSON Schema decodable as GenerationSchema>, "temperature": Double?, "max_tokens": Int?}
+// Success:  {"content": String, "usage": {"input_tokens": Int, "output_tokens": Int}?, "finish_reason": "max_tokens"?}
+// Failure:  {"error": <code>}, never the model's or the system's own message
+
+func emit(_ object: [String: Any]) -> Never {
+  let data = (try? JSONSerialization.data(withJSONObject: object, options: [])) ?? Data("{\"error\":\"other\"}".utf8)
+  FileHandle.standardOutput.write(data)
+  FileHandle.standardOutput.write(Data("\n".utf8))
+  exit(0)
+}
+
+func segments(_ text: String) -> [Transcript.Segment] {
+  [.text(Transcript.TextSegment(content: text))]
+}
+
+func unavailability(_ model: SystemLanguageModel) -> String? {
+  switch model.availability {
+  case .available: return nil
+  case .unavailable(let reason):
+    switch reason {
+    case .deviceNotEligible: return "device_not_eligible"
+    case .appleIntelligenceNotEnabled: return "apple_intelligence_not_enabled"
+    case .modelNotReady: return "model_not_ready"
+    @unknown default: return "unavailable"
+    }
+  }
+}
+
+// Token counts need macOS 26.4; on anything older, or if counting fails, the answer simply carries no usage.
+func usage(_ model: SystemLanguageModel, entries: [Transcript.Entry], schema: GenerationSchema, answer: String) async -> [String: Int] {
+  guard #available(macOS 26.4, *) else { return [:] }
+  var counts: [String: Int] = [:]
+  if let prompt = try? await model.tokenCount(for: entries), let shape = try? await model.tokenCount(for: schema) {
+    counts["input_tokens"] = prompt + shape
+  }
+  if let generated = try? await model.tokenCount(for: answer) { counts["output_tokens"] = generated }
+  return counts
+}
+
+func failure(_ error: Error) -> String {
+  guard let generation = error as? LanguageModelSession.GenerationError else { return "other" }
+  switch generation {
+  case .exceededContextWindowSize: return "context_window"
+  case .guardrailViolation: return "guardrail"
+  case .unsupportedLanguageOrLocale: return "unsupported_language"
+  case .rateLimited: return "rate_limited"
+  case .assetsUnavailable: return "model_not_ready"
+  default: return "generation"
+  }
+}
+
+// With max_tokens set, a reply cut off at the limit is truncated JSON that the framework can't decode, and it reports
+// only a decoding failure, so any decoding failure with a limit set is treated as a cutoff. The partial text isn't
+// kept: the answer is empty and says why, so Squishling can tell a cutoff from a wrong answer.
+func isCutoff(_ error: Error, limit: Int?) -> Bool {
+  guard limit != nil, let generation = error as? LanguageModelSession.GenerationError else { return false }
+  if case .decodingFailure = generation { return true }
+  return false
+}
+
+let input = FileHandle.standardInput.readDataToEndOfFile()
+guard let request = (try? JSONSerialization.jsonObject(with: input)) as? [String: Any],
+      let messages = request["messages"] as? [[String: String]], let last = messages.last,
+      let schemaObject = request["schema"] else { emit(["error": "bad_request"]) }
+
+let model = SystemLanguageModel.default
+if let reason = unavailability(model) { emit(["error": reason]) }
+
+let schema: GenerationSchema
+do {
+  let data = try JSONSerialization.data(withJSONObject: schemaObject)
+  schema = try JSONDecoder().decode(GenerationSchema.self, from: data)
+} catch { emit(["error": "unsupported_schema"]) }
+
+var entries: [Transcript.Entry] = []
+if let instructions = request["instructions"] as? String, !instructions.isEmpty {
+  entries.append(.instructions(Transcript.Instructions(segments: segments(instructions), toolDefinitions: [])))
+}
+for message in messages.dropLast() {
+  let text = message["content"] ?? ""
+  if message["role"] == "assistant" {
+    entries.append(.response(Transcript.Response(assetIDs: [], segments: segments(text))))
+  } else {
+    entries.append(.prompt(Transcript.Prompt(segments: segments(text))))
+  }
+}
+
+var options = GenerationOptions()
+if let temperature = request["temperature"] as? Double { options.temperature = temperature }
+let limit = request["max_tokens"] as? Int
+if let limit { options.maximumResponseTokens = limit }
+
+do {
+  let session = LanguageModelSession(model: model, tools: [], transcript: Transcript(entries: entries))
+  let prompt = last["content"] ?? ""
+  let response = try await session.respond(to: prompt, schema: schema, options: options)
+  let asked = entries + [.prompt(Transcript.Prompt(segments: segments(prompt)))]
+  let counts = await usage(model, entries: asked, schema: schema, answer: response.content.jsonString)
+  emit(["content": response.content.jsonString, "usage": counts])
+} catch {
+  if isCutoff(error, limit: limit) { emit(["content": "", "finish_reason": "max_tokens"]) }
+  emit(["error": failure(error)])
+}

data/lib/squishling/apple_fm/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Squishling
+  module AppleFM
+    VERSION = "0.1.0"
+  end
+end

data/lib/squishling/apple_fm.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "squishling"
+
+# The squishling-apple_fm adapter registers itself with the pluggable-adapters API, so an older Squishling can't use it.
+unless Squishling.respond_to?(:register_adapter)
+  raise LoadError, "squishling-apple_fm needs a Squishling release with pluggable adapters " \
+                   "(Squishling.register_adapter); you have Squishling #{Squishling::VERSION}. Upgrade squishling."
+end
+
+require_relative "apple_fm/version"
+require_relative "apple_fm/generation_schema"
+require_relative "apple_fm/helper"
+require_relative "apple_fm/adapter"
+
+module Squishling
+  # Runs Squishling on the on-device model built into macOS (Apple Intelligence). Requiring this gem registers the
+  # adapter as :apple_fm; see Squishling::AppleFM::Adapter.
+  module AppleFM
+    # Registers the adapter under :apple_fm unless it is already there. Called when the gem loads; call it again
+    # after Squishling.reset_adapters!, which forgets every adapter that isn't built in.
+    def self.register
+      Squishling.register_adapter(:apple_fm, Adapter) unless Squishling.adapters.include?(:apple_fm)
+    end
+  end
+end
+
+Squishling::AppleFM.register

data/squishling-apple_fm.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lib/squishling/apple_fm/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "squishling-apple_fm"
+  spec.version = Squishling::AppleFM::VERSION
+  spec.authors = ["Michael Carroll"]
+  spec.email = ["mc@coolhandlabs.com"]
+
+  spec.summary = "Squishling adapter for Apple's on-device model (Apple Intelligence): free, offline LLM calls in " \
+                 "development."
+  spec.description = "A Squishling adapter that runs Ruby LLM calls on the Apple Foundation Models on-device model " \
+                     "built into macOS 26 and later (Apple Intelligence): no API key, no network, no cost. Meant " \
+                     "for trying Squishling and developing against it locally, then running production on a " \
+                     "hosted model. Strict structured output is translated into Apple's guided generation; the " \
+                     "framework is Swift-only, so a small bundled Swift helper is compiled with the Xcode " \
+                     "toolchain on first use."
+  spec.homepage = "https://github.com/Coolhand-Labs/squishling-apple-fm-adapter"
+  spec.license = "Apache-2.0"
+  spec.required_ruby_version = ">= 3.3"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}/tree/main/docs"
+
+  # Ship only what's tracked in git, minus development-only files.
+  dev_files = %w[AGENTS.md CLAUDE.md]
+  dev_prefixes = %w[bin/ test/ spec/ features/ examples/ assets/
+                    .git .claude .idea .rubocop .simplecov .rspec Gemfile]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      File.expand_path(f) == __FILE__ || dev_files.include?(f) || f.start_with?(*dev_prefixes)
+    end
+  end
+  spec.require_paths = ["lib"]
+
+  # 0.5.0 is the first Squishling release with pluggable adapters (Squishling.register_adapter).
+  spec.add_dependency "squishling", ">= 0.5.0"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: squishling-apple_fm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Carroll
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: squishling
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+description: 'A Squishling adapter that runs Ruby LLM calls on the Apple Foundation
+  Models on-device model built into macOS 26 and later (Apple Intelligence): no API
+  key, no network, no cost. Meant for trying Squishling and developing against it
+  locally, then running production on a hosted model. Strict structured output is
+  translated into Apple''s guided generation; the framework is Swift-only, so a small
+  bundled Swift helper is compiled with the Xcode toolchain on first use.'
+email:
+- mc@coolhandlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- SECURITY.md
+- docs/how-it-works.md
+- lib/squishling/apple_fm.rb
+- lib/squishling/apple_fm/adapter.rb
+- lib/squishling/apple_fm/generation_schema.rb
+- lib/squishling/apple_fm/helper.rb
+- lib/squishling/apple_fm/helper.swift
+- lib/squishling/apple_fm/version.rb
+- squishling-apple_fm.gemspec
+homepage: https://github.com/Coolhand-Labs/squishling-apple-fm-adapter
+licenses:
+- Apache-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Coolhand-Labs/squishling-apple-fm-adapter
+  source_code_uri: https://github.com/Coolhand-Labs/squishling-apple-fm-adapter
+  changelog_uri: https://github.com/Coolhand-Labs/squishling-apple-fm-adapter/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/Coolhand-Labs/squishling-apple-fm-adapter/tree/main/docs
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Squishling adapter for Apple''s on-device model (Apple Intelligence): free,
+  offline LLM calls in development.'
+test_files: []