ios: preserve chat scroll position on resume

adds gemini support
ci: restore Ruby PATH export for fastlane step
2026-07-12 13:57:45 -07:00 · 2026-07-11 14:16:21 -07:00 · 2026-07-11 13:04:47 -07:00 · 2026-07-11 13:01:42 -07:00 · 2026-07-11 12:01:27 -07:00 · 2026-07-11 11:55:04 -07:00
41 changed files with 1000 additions and 795 deletions
@@ -1,230 +0,0 @@
 name: TestFlight Release
 on:
  push:
    tags:
      - "release/v*.*.*"
 permissions:
  contents: write
 jobs:
  testflight:
    runs-on: xcode
    env:
      SIGNING_KEYCHAIN: sybil_signing_temp
    defaults:
      run:
        shell: bash
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Validate release tag
        run: |
          set -euo pipefail
          tag_name="${GITHUB_REF#refs/tags/}"
          if [[ ! "$tag_name" =~ ^release/v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
            echo "Release tag must match release/vN.N.N; got ${tag_name}" >&2
            exit 1
          fi
          release_version="${tag_name#release/v}"
          {
            echo "TAG_NAME=${tag_name}"
            echo "RELEASE_VERSION=${release_version}"
          } >> "${GITHUB_ENV}"
      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: "3.3"
      - name: Install Ruby gems
        working-directory: ios
        run: bundle install
      - name: Install release tools
        run: |
          set -euo pipefail
          missing_tools=()
          for tool in xcodegen jq; do
            if ! command -v "${tool}" >/dev/null 2>&1; then
              missing_tools+=("${tool}")
            fi
          done
          if [[ "${#missing_tools[@]}" -eq 0 ]]; then
            exit 0
          fi
          if ! command -v brew >/dev/null 2>&1; then
            echo "Missing required tools: ${missing_tools[*]}; Homebrew is not available to install them" >&2
            exit 1
          fi
          brew install "${missing_tools[@]}"
      - name: Install signing secrets
        env:
          APPSTORE_CERTIFICATES_FILE_BASE64: ${{ secrets.APPSTORE_CERTIFICATES_FILE_BASE64 }}
          APPSTORE_CERTIFICATES_PASSWORD: ${{ secrets.APPSTORE_CERTIFICATES_PASSWORD }}
          APPSTORE_PROVISIONING_PROFILE_BASE64: ${{ secrets.APPSTORE_PROVISIONING_PROFILE_BASE64 }}
        run: |
          set -euo pipefail
          : "${APPSTORE_CERTIFICATES_FILE_BASE64:?APPSTORE_CERTIFICATES_FILE_BASE64 secret is required}"
          : "${APPSTORE_CERTIFICATES_PASSWORD:?APPSTORE_CERTIFICATES_PASSWORD secret is required}"
          : "${APPSTORE_PROVISIONING_PROFILE_BASE64:?APPSTORE_PROVISIONING_PROFILE_BASE64 secret is required}"
          keychain_password="$(uuidgen)"
          keychain_path="${HOME}/Library/Keychains/${SIGNING_KEYCHAIN}.keychain-db"
          previous_default_keychain="$(security default-keychain -d user | sed 's/[ "]//g' || true)"
          mkdir -p "${HOME}/Library/Keychains" "${HOME}/Library/MobileDevice/Provisioning Profiles" ios/build/secrets
          printf '%s' "${APPSTORE_CERTIFICATES_FILE_BASE64}" | base64 --decode > ios/build/secrets/appstore-signing.p12
          printf '%s' "${APPSTORE_PROVISIONING_PROFILE_BASE64}" | base64 --decode > "${HOME}/Library/MobileDevice/Provisioning Profiles/Sybil_AppStore_CI.mobileprovision"
          curl -fsSL https://www.apple.com/certificateauthority/AppleWWDRCAG3.cer -o ios/build/secrets/AppleWWDRCAG3.cer
          security create-keychain -p "${keychain_password}" "${keychain_path}"
          security set-keychain-settings -lut 21600 "${keychain_path}"
          security unlock-keychain -p "${keychain_password}" "${keychain_path}"
          security list-keychains -d user -s "${keychain_path}" $(security list-keychains -d user | sed 's/[ "]//g')
          security default-keychain -d user -s "${keychain_path}"
          security import ios/build/secrets/AppleWWDRCAG3.cer \
            -k "${keychain_path}" \
            -T /usr/bin/codesign \
            -T /usr/bin/security \
            -T /usr/bin/xcodebuild
          security import ios/build/secrets/appstore-signing.p12 \
            -k "${keychain_path}" \
            -P "${APPSTORE_CERTIFICATES_PASSWORD}" \
            -T /usr/bin/codesign \
            -T /usr/bin/security \
            -T /usr/bin/xcodebuild
          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "${keychain_password}" "${keychain_path}"
          security find-identity -v -p codesigning "${keychain_path}"
          {
            echo "SYBIL_SIGNING_KEYCHAIN_PATH=${keychain_path}"
            echo "SYBIL_SIGNING_KEYCHAIN_PASSWORD=${keychain_password}"
            echo "SYBIL_PREVIOUS_DEFAULT_KEYCHAIN=${previous_default_keychain}"
          } >> "${GITHUB_ENV}"
      - name: Build and upload to TestFlight
        working-directory: ios
        env:
          APP_STORE_CONNECT_API_KEY_ID: ${{ secrets.APP_STORE_CONNECT_API_KEY_ID }}
          APP_STORE_CONNECT_API_ISSUER_ID: ${{ secrets.APP_STORE_CONNECT_API_ISSUER_ID }}
          APP_STORE_CONNECT_API_KEY_CONTENT: ${{ secrets.APP_STORE_CONNECT_API_KEY_CONTENT }}
          APP_STORE_CONNECT_API_KEY_CONTENT_BASE64: "true"
          FASTLANE_DONT_STORE_PASSWORD: "1"
          FASTLANE_HIDE_CHANGELOG: "1"
          FASTLANE_SKIP_UPDATE_CHECK: "1"
          SYBIL_PROVISIONING_PROFILE_SPECIFIER: Sybil AppStore CI
        run: |
          set -euo pipefail
          security unlock-keychain -p "${SYBIL_SIGNING_KEYCHAIN_PASSWORD}" "${SYBIL_SIGNING_KEYCHAIN_PATH}"
          security list-keychains -d user -s "${SYBIL_SIGNING_KEYCHAIN_PATH}" $(security list-keychains -d user | sed 's/[ "]//g')
          security default-keychain -d user -s "${SYBIL_SIGNING_KEYCHAIN_PATH}"
          security find-identity -v -p codesigning "${SYBIL_SIGNING_KEYCHAIN_PATH}"
          SYBIL_VERSION_TAG="${TAG_NAME}" bundle exec fastlane ios beta
      - name: Locate IPA
        run: |
          set -euo pipefail
          ipa_path="$(find ios/build/fastlane -maxdepth 1 -type f -name '*.ipa' -print | sort | tail -n 1)"
          if [[ -z "${ipa_path}" ]]; then
            echo "No IPA found under ios/build/fastlane" >&2
            exit 1
          fi
          {
            echo "IPA_PATH=${ipa_path}"
            echo "IPA_NAME=$(basename "${ipa_path}")"
          } >> "${GITHUB_ENV}"
      - name: Publish Gitea release asset
        env:
          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
          RELEASE_API_URL: ${{ github.api_url }}
          RELEASE_REPOSITORY: ${{ github.repository }}
          RELEASE_SHA: ${{ github.sha }}
        run: |
          set -euo pipefail
          : "${GITEA_TOKEN:?GITEA_TOKEN is required}"
          api_url="${RELEASE_API_URL:-https://code.buzzert.dev/api/v1}"
          repository="${RELEASE_REPOSITORY:-buzzert/Sybil-2}"
          sha="${RELEASE_SHA:-${GITHUB_SHA:-}}"
          release_name="Sybil v${RELEASE_VERSION}"
          release_body="Automated TestFlight release for ${TAG_NAME}."
          release_payload="$(jq -nc \
            --arg tag "${TAG_NAME}" \
            --arg name "${release_name}" \
            --arg body "${release_body}" \
            --arg target "${sha}" \
            '{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false} +
            (if $target == "" then {} else {target_commitish: $target} end)')"
          response_file="$(mktemp)"
          status="$(curl -sS -o "${response_file}" -w "%{http_code}" \
            -X POST "${api_url}/repos/${repository}/releases" \
            -H "Authorization: token ${GITEA_TOKEN}" \
            -H "Content-Type: application/json" \
            --data "${release_payload}")"
          if [[ "${status}" == "201" ]]; then
            release_id="$(jq -r '.id' "${response_file}")"
          elif [[ "${status}" == "409" ]]; then
            release_id="$(curl -fsS \
              -H "Authorization: token ${GITEA_TOKEN}" \
              "${api_url}/repos/${repository}/releases?limit=100" |
              jq -r --arg tag "${TAG_NAME}" '.[] | select(.tag_name == $tag) | .id' |
              head -n 1)"
          else
            cat "${response_file}" >&2
            exit 1
          fi
          if [[ -z "${release_id}" || "${release_id}" == "null" ]]; then
            echo "Could not resolve Gitea release id for ${TAG_NAME}" >&2
            exit 1
          fi
          existing_asset_id="$(curl -fsS \
            -H "Authorization: token ${GITEA_TOKEN}" \
            "${api_url}/repos/${repository}/releases/${release_id}/assets" |
            jq -r --arg name "${IPA_NAME}" '.[] | select(.name == $name) | .id' |
            head -n 1)"
          if [[ -n "${existing_asset_id}" && "${existing_asset_id}" != "null" ]]; then
            curl -fsS -X DELETE \
              -H "Authorization: token ${GITEA_TOKEN}" \
              "${api_url}/repos/${repository}/releases/${release_id}/assets/${existing_asset_id}"
          fi
          asset_name="$(jq -rn --arg value "${IPA_NAME}" '$value | @uri')"
          curl -fsS -X POST \
            -H "Authorization: token ${GITEA_TOKEN}" \
            -F "attachment=@${IPA_PATH}" \
            "${api_url}/repos/${repository}/releases/${release_id}/assets?name=${asset_name}" >/dev/null
          echo "Published ${IPA_NAME} to ${release_name}"
      - name: Clean up temporary keychain
        if: always()
        run: |
          if [[ -n "${SYBIL_PREVIOUS_DEFAULT_KEYCHAIN:-}" ]]; then
            security default-keychain -d user -s "${SYBIL_PREVIOUS_DEFAULT_KEYCHAIN}" || true
          fi
          security delete-keychain "${HOME}/Library/Keychains/${SIGNING_KEYCHAIN}.keychain-db" || true
@@ -0,0 +1,44 @@
 name: TestFlight
 on:
  workflow_dispatch:
  push:
    tags:
      - "release/ios/v*"
 jobs:
  testflight:
    runs-on: macos-arm64
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: "3.1.7"
          bundler-cache: true
          working-directory: ios
      - name: Install XcodeGen
        run: command -v xcodegen >/dev/null 2>&1 || brew install xcodegen
      - name: Upload to TestFlight
        working-directory: ios
        env:
          APP_STORE_CONNECT_KEY_ID: ${{ secrets.APP_STORE_CONNECT_KEY_ID }}
          APP_STORE_CONNECT_ISSUER_ID: ${{ secrets.APP_STORE_CONNECT_ISSUER_ID }}
          APP_STORE_CONNECT_KEY_CONTENT: ${{ secrets.APP_STORE_CONNECT_KEY_CONTENT }}
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
          MATCH_GIT_URL: ${{ secrets.MATCH_GIT_URL }}
          MATCH_GIT_BASIC_AUTHORIZATION: ${{ secrets.MATCH_GIT_BASIC_AUTHORIZATION }}
          SYBIL_BUILD_NUMBER: ${{ github.run_number }}
          FASTLANE_SKIP_UPDATE_CHECK: "1"
          FASTLANE_XCODEBUILD_SETTINGS_TIMEOUT: "120"
        # act_runner does not propagate setup-ruby's PATH changes into later
        # steps, so put the selected Ruby back on PATH or `bundle` resolves to
        # the toolcache default and misses the gems installed above.
        run: |
          export PATH="/Users/runner/hostedtoolcache/Ruby/3.1.7/arm64/bin:${PATH}"
          bundle exec fastlane ios beta
@@ -1,2 +1,3 @@
 .env
-
+ios/fastlane/README.md
 ios/fastlane/report.xml
@@ -12,6 +12,7 @@ services:
      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
      XAI_API_KEY: ${XAI_API_KEY:-}
      GEMINI_API_KEY: ${GEMINI_API_KEY:-}
      HERMES_AGENT_API_BASE_URL: ${HERMES_AGENT_API_BASE_URL:-http://127.0.0.1:8642/v1}
      HERMES_AGENT_API_KEY: ${HERMES_AGENT_API_KEY:-}
      HERMES_AGENT_MODEL: ${HERMES_AGENT_MODEL:-}
@@ -34,11 +34,13 @@ Chat upload limits:
    "openai": { "models": ["gpt-4.1-mini"], "loadedAt": "2026-02-14T00:00:00.000Z", "error": null },
    "anthropic": { "models": ["claude-3-5-sonnet-latest"], "loadedAt": null, "error": null },
    "xai": { "models": ["grok-3-mini"], "loadedAt": null, "error": null },
    "gemini": { "models": ["gemini-3.5-flash"], "loadedAt": null, "error": null },
    "hermes-agent": { "models": ["hermes-agent"], "loadedAt": null, "error": null }
  }
 }
 ```
 - OpenAI model lists are filtered to models that are expected to work with the backend's Responses API implementation.
 - Gemini model lists are loaded from Google's native Models API and filtered to Gemini `generateContent` model ids.
 - `hermes-agent` is included only when `HERMES_AGENT_API_KEY` is configured. Set it to Hermes `API_SERVER_KEY`, or any non-empty value if that local server does not require auth. `HERMES_AGENT_API_BASE_URL` defaults to `http://127.0.0.1:8642/v1`; set `HERMES_AGENT_MODEL` only when you need an additional fallback/override model id.
 - The backend loads provider model lists at startup and refreshes them about once every 24 hours. If a later provider refresh fails, the response keeps the last loaded model list for that provider and sets `error` to the latest failure message.
@@ -56,7 +58,7 @@ Chat upload limits:
 ```
 Behavior notes:
- Lists Sybil-managed chat tools that can be enabled for `openai`, `anthropic`, and `xai` chat completions.
+- Lists Sybil-managed chat tools that can be enabled for `openai`, `anthropic`, `xai`, and `gemini` chat completions.
 - Optional tools such as `codex_exec` and `shell_exec` appear only when enabled by server environment configuration.
 ## Active Runs
@@ -128,7 +130,7 @@ Behavior notes:
 ```json
 {
  "title": "optional title",
-  "provider": "optional openai|anthropic|xai|hermes-agent",
+  "provider": "optional openai|anthropic|xai|gemini|hermes-agent",
  "model": "optional model id",
  "additionalSystemPrompt": "optional stored system prompt",
  "enabledTools": ["web_search", "fetch_url"],
@@ -234,7 +236,7 @@ Notes:
 ```json
 {
  "chatId": "optional-chat-id",
-  "provider": "openai|anthropic|xai|hermes-agent",
+  "provider": "openai|anthropic|xai|gemini|hermes-agent",
  "model": "string",
  "messages": [
    {
@@ -285,6 +287,7 @@ Behavior notes:
 - For `chatId` calls, server stores only *new* non-assistant messages from provided history to avoid duplicates.
 - `additionalSystemPrompt`, when present directly or loaded from stored chat settings, is prepended to the provider request as a `system` message and is not inserted into the persisted chat transcript by this endpoint.
 - `enabledTools` limits Sybil-managed tools for this request. When omitted for a saved chat, the stored chat setting is used; otherwise all available tools are enabled by default. An empty array disables Sybil-managed tools.
 - `maxTokens` is optional. For `anthropic`, when omitted the backend requests the selected model's maximum output token limit from Anthropic's Models API and uses that as `max_tokens`; if the model limit cannot be loaded, the fallback is 128000. For other providers, omitted `maxTokens` is not sent as an explicit cap.
 - Server persists final assistant output and call metadata (`LlmCall`) in DB.
 - Server updates chat-level model metadata on each call: `lastUsedProvider`/`lastUsedModel`; first successful/failed call also initializes `initiatedProvider`/`initiatedModel` if unset.
 - Attachments are optional and currently apply to `user` messages. Persisted chat history stores them under `message.metadata.attachments`.
@@ -293,12 +296,14 @@ Behavior notes:
 - For `openai`, backend calls OpenAI's Responses API and enables internal tool use with an internal system instruction.
 - For `anthropic`, backend calls Anthropic's Messages API and enables internal tool use with Anthropic `tool_use`/`tool_result` content blocks.
 - For `xai`, backend calls xAI's OpenAI-compatible Chat Completions API and enables internal tool use with the same internal system instruction.
 - For `gemini`, backend calls Google's native Gemini `generateContent` API and enables internal tool use with Gemini function calling.
 - For `hermes-agent`, backend calls the configured Hermes Agent OpenAI-compatible Chat Completions API without adding Sybil-managed tool definitions; Hermes Agent handles its own tools server-side.
 - For `openai`, image attachments are sent as Responses `input_image` items and text attachments are sent as `input_text` items.
 - For `gemini`, image attachments are sent as native Gemini `inlineData` parts and text attachments are sent as text parts.
 - For `xai` and `hermes-agent`, image attachments are sent as Chat Completions content parts alongside text.
 - For `openai`, Responses calls that can enter the server-managed tool loop use `store: true` so reasoning and function-call items can be passed between tool rounds.
 - For `anthropic`, image attachments are sent as Messages API `image` blocks using base64 source data; text attachments are added as `text` blocks.
- Available Sybil-managed tool calls for `openai`, `anthropic`, and `xai`: `web_search` and `fetch_url`. When `CHAT_CODEX_TOOL_ENABLED=true`, `codex_exec` is also available. When `CHAT_SHELL_TOOL_ENABLED=true`, `shell_exec` is also available.
+- Available Sybil-managed tool calls for `openai`, `anthropic`, `xai`, and `gemini`: `web_search` and `fetch_url`. When `CHAT_CODEX_TOOL_ENABLED=true`, `codex_exec` is also available. When `CHAT_SHELL_TOOL_ENABLED=true`, `shell_exec` is also available.
 - `web_search` returns ranked results with per-result summaries/snippets. Its backend engine is selected by `CHAT_WEB_SEARCH_ENGINE` (`exa` default, or `searxng` with `SEARXNG_BASE_URL` set). SearXNG mode requires the instance to allow `format=json`.
 - `fetch_url` fetches a URL with browser-like navigation headers and returns plaintext page content (HTML converted to text server-side).
 - `codex_exec` delegates coding, shell, repository inspection, and other complex software tasks to a persistent remote Codex CLI workspace over SSH. The server runs `codex exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check <non-interactive wrapped prompt>` on the configured devbox inside `CHAT_CODEX_REMOTE_WORKDIR`, with SSH stdin closed.
@@ -416,9 +421,9 @@ Behavior notes:
  "updatedAt": "...",
  "starred": false,
  "starredAt": null,
-  "initiatedProvider": "openai|anthropic|xai|hermes-agent|null",
+  "initiatedProvider": "openai|anthropic|xai|gemini|hermes-agent|null",
  "initiatedModel": "string|null",
-  "lastUsedProvider": "openai|anthropic|xai|hermes-agent|null",
+  "lastUsedProvider": "openai|anthropic|xai|gemini|hermes-agent|null",
  "lastUsedModel": "string|null",
  "additionalSystemPrompt": null,
  "enabledTools": ["web_search", "fetch_url"]
@@ -468,9 +473,9 @@ Behavior notes:
  "updatedAt": "...",
  "starred": false,
  "starredAt": null,
-  "initiatedProvider": "openai|anthropic|xai|hermes-agent|null",
+  "initiatedProvider": "openai|anthropic|xai|gemini|hermes-agent|null",
  "initiatedModel": "string|null",
-  "lastUsedProvider": "openai|anthropic|xai|hermes-agent|null",
+  "lastUsedProvider": "openai|anthropic|xai|gemini|hermes-agent|null",
  "lastUsedModel": "string|null",
  "additionalSystemPrompt": null,
  "enabledTools": ["web_search", "fetch_url"],
@@ -21,7 +21,7 @@ Authentication:
 {
  "chatId": "optional-chat-id",
  "persist": true,
-  "provider": "openai|anthropic|xai|hermes-agent",
+  "provider": "openai|anthropic|xai|gemini|hermes-agent",
  "model": "string",
  "messages": [
    {
@@ -64,6 +64,7 @@ Notes:
 - For persisted streams, backend stores only new non-assistant input history rows to avoid duplicates.
 - `additionalSystemPrompt`, when present directly or loaded from stored chat settings, is prepended to the provider request as a `system` message and is not inserted into the persisted chat transcript by this endpoint.
 - `enabledTools` limits Sybil-managed tools for this request. When omitted for a saved chat, the stored chat setting is used; otherwise all available tools are enabled by default. An empty array disables Sybil-managed tools.
 - `maxTokens` is optional. For `anthropic`, when omitted the backend requests the selected model's maximum output token limit from Anthropic's Models API and uses that as `max_tokens`; if the model limit cannot be loaded, the fallback is 128000. For other providers, omitted `maxTokens` is not sent as an explicit cap.
 - Attachments are optional and are persisted under `message.metadata.attachments` on stored user messages when `persist` is `true`.
 Persisted chat streams with a `chatId` are backend-owned active runs:
@@ -173,9 +174,11 @@ Terminal tool-call event:
 - `openai`: backend uses OpenAI's Responses API and may execute internal function tool calls (`web_search`, `fetch_url`, optional `codex_exec`, and optional `shell_exec`) before producing final text.
 - `anthropic`: backend uses Anthropic's Messages API and may execute the same internal tools with `tool_use`/`tool_result` content blocks before producing final text.
 - `xai`: backend uses xAI's OpenAI-compatible Chat Completions API and may execute the same internal tool calls before producing final text.
 - `gemini`: backend uses Google's native Gemini `streamGenerateContent` API and may execute the same internal tool calls before producing final text.
 - `fetch_url` sends browser-like navigation headers for outbound URL requests to reduce false 403s from sites that reject generic server clients.
 - `hermes-agent`: backend uses the configured Hermes Agent OpenAI-compatible Chat Completions API. Sybil does not add its own tool definitions for this provider; Hermes Agent handles its own tools server-side. Custom Hermes stream events are normalized away unless they produce text deltas in this SSE contract.
 - `openai`: image attachments are sent as Responses `input_image` items; text attachments are sent as `input_text` items.
 - `gemini`: image attachments are sent as native Gemini `inlineData` parts; text attachments are inlined as text parts.
 - `xai` and `hermes-agent`: image attachments are sent as Chat Completions content parts; text attachments are inlined as text parts.
 - `openai`: Responses calls that can enter the server-managed tool loop use `store: true` so reasoning and function-call items can be passed between tool rounds.
 - `anthropic`: streamed via event stream; emits `delta` from `content_block_delta` with `text_delta`, and emits normalized `tool_call` SSE events when Anthropic `tool_use` blocks are executed. Image attachments are sent as base64 `image` blocks and text attachments are appended as `text` blocks.
@@ -184,7 +187,7 @@ Terminal tool-call event:
 - `shell_exec` is available only when `CHAT_SHELL_TOOL_ENABLED=true`. It uses the same devbox SSH configuration, starts in `CHAT_CODEX_REMOTE_WORKDIR`, and runs non-interactive shell commands there with SSH stdin closed, not inside the Sybil server container.
 - `CHAT_MAX_TOOL_ROUNDS` controls how many model/tool result cycles may occur before the backend returns a tool-call limit message; default is 100.
-Tool-enabled streaming notes (`openai`/`anthropic`/`xai`):
+Tool-enabled streaming notes (`openai`/`anthropic`/`xai`/`gemini`):
 - Stream still emits standard `meta`, `delta`, `done|error` events.
 - Stream may emit `tool_call` events while tool calls are executed.
 - `delta` events carry assistant text and are emitted incrementally for normal text rounds. The backend may buffer model-native text briefly while determining whether a provider round contains tool calls.
@@ -5,8 +5,10 @@ FASTLANE_HIDE_CHANGELOG=1
 SYBIL_APP_STORE_APPLE_ID=6759442828
 SYBIL_PROVIDER_PUBLIC_ID=c043d167-ad88-4036-84ea-76c223f1b1b2
 SYBIL_PROVISIONING_PROFILE_SPECIFIER=Sybil AppStore CI
 SYBIL_PROVISIONING_PROFILE_UUID=
 SYBIL_CODE_SIGN_IDENTITY=Apple Distribution: James Magahern (DQQH5H6GBD)
-SYBIL_XCODE_CODE_SIGN_IDENTITY=Apple Distribution
+SYBIL_XCODE_CODE_SIGN_IDENTITY=6B74B268C4761720FB2051D01D8BB3E47B55D9F5
 SYBIL_EXPORT_SIGNING_CERTIFICATE=Apple Distribution
 SYBIL_SIGNING_CERTIFICATE_ID=
 SYBIL_SIGNING_KEYCHAIN=
@@ -21,6 +21,12 @@ Instructions for work under `/Users/buzzert/src/sybil-2/ios`.
 - To choose a screenshot path, run `just screenshot path=build/name.png`.
 - The underlying screenshot command is `xcrun simctl io booted screenshot <path>` and requires a booted simulator.
 ## Release Workflow
 - iOS release tags use the annotated tag namespace `release/ios/vX.Y.Z`; increment from the latest existing `release/ios/v*` tag.
 - Tag message convention is `ios: X.Y.Z`, for example `git tag -a release/ios/v1.13.5 -m "ios: 1.13.5"`.
 - Push the release commit and tag together with `git push origin <branch> release/ios/vX.Y.Z`.
 - Fastlane derives the marketing version from the release tag and stamps `ios/Apps/Sybil/project.yml` during CI, so do not manually bump `MARKETING_VERSION` for normal tagged releases unless explicitly requested.
 ## App Structure
 - App target entry: `/Users/buzzert/src/sybil-2/ios/Apps/Sybil/Sources/SybilApp.swift`
 - Shared iOS app code lives in Swift package:
@@ -51,4 +57,5 @@ Instructions for work under `/Users/buzzert/src/sybil-2/ios`.
  - OpenAI: `gpt-4.1-mini`
  - Anthropic: `claude-3-5-sonnet-latest`
  - xAI: `grok-3-mini`
  - Gemini: `gemini-3.5-flash`
  - Hermes Agent: `hermes-agent`
@@ -24,7 +24,7 @@ targets:
        GENERATE_INFOPLIST_FILE: YES
        INFOPLIST_FILE: Apps/Sybil/Info.plist
        ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
-        MARKETING_VERSION: "1.10"
+        MARKETING_VERSION: "1.13.2"
        CURRENT_PROJECT_VERSION: 11
        INFOPLIST_KEY_CFBundleDisplayName: Sybil
        INFOPLIST_KEY_ITSAppUsesNonExemptEncryption: NO
@@ -32,6 +32,12 @@ targets:
        INFOPLIST_KEY_UILaunchScreen_Generation: YES
        INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone: UIInterfaceOrientationPortrait
        INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad: UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight
      configs:
        Release:
          CODE_SIGN_STYLE: Manual
          CODE_SIGN_IDENTITY: Apple Distribution
          "CODE_SIGN_IDENTITY[sdk=iphoneos*]": Apple Distribution
          PROVISIONING_PROFILE_SPECIFIER: Sybil AppStore CI
 schemes:
  Sybil:
@@ -1,3 +1,3 @@
 source "https://rubygems.org"
-gem "fastlane", "~> 2.227"
+gem "fastlane"
@@ -225,7 +225,7 @@ PLATFORMS
  ruby
 DEPENDENCIES
-  fastlane (~> 2.227)
+  fastlane
 BUNDLED WITH
   2.5.23
@@ -58,7 +58,8 @@ struct SybilChatTranscriptView: View {
                        .frame(height: 18 + bottomContentInset)
                        .id(bottomAnchorID)
                }
-                .frame(maxWidth: .infinity, alignment: .leading)
+                .frame(maxWidth: SybilLayout.webContentMaxWidth, alignment: .leading)
                .frame(maxWidth: .infinity, alignment: .center)
                .padding(.horizontal, 14)
                .padding(.top, 18 + topContentInset)
            }
@@ -66,7 +67,6 @@ struct SybilChatTranscriptView: View {
            .scrollDismissesKeyboard(.interactively)
            .onAppear {
                syncKnownToolCallMessageIDs()
                scrollToBottom(with: proxy, animated: false)
            }
            .onChange(of: toolCallMessageIDSignature) { _, _ in
                syncKnownToolCallMessageIDs()
@@ -4,6 +4,7 @@ public enum Provider: String, Codable, CaseIterable, Hashable, Sendable {
    case openai
    case anthropic
    case xai
    case gemini
    case hermesAgent = "hermes-agent"
    public var displayName: String {
@@ -11,6 +12,7 @@ public enum Provider: String, Codable, CaseIterable, Hashable, Sendable {
        case .openai: return "OpenAI"
        case .anthropic: return "Anthropic"
        case .xai: return "xAI"
        case .gemini: return "Gemini"
        case .hermesAgent: return "Hermes Agent"
        }
    }
@@ -98,7 +98,8 @@ struct SybilSearchResultsView: View {
                        .foregroundStyle(SybilTheme.danger)
                }
            }
-            .frame(maxWidth: .infinity, alignment: .leading)
+            .frame(maxWidth: SybilLayout.webContentMaxWidth, alignment: .leading)
            .frame(maxWidth: .infinity, alignment: .center)
            .padding(.horizontal, 14)
            .padding(.top, 20 + topContentInset)
            .padding(.bottom, 20 + bottomContentInset)
@@ -11,11 +11,13 @@ final class SybilSettingsStore {
        static let preferredOpenAIModel = "sybil.ios.preferredOpenAIModel"
        static let preferredAnthropicModel = "sybil.ios.preferredAnthropicModel"
        static let preferredXAIModel = "sybil.ios.preferredXAIModel"
        static let preferredGeminiModel = "sybil.ios.preferredGeminiModel"
        static let preferredHermesAgentModel = "sybil.ios.preferredHermesAgentModel"
        static let quickQuestionPreferredProvider = "sybil.ios.quickQuestionPreferredProvider"
        static let quickQuestionPreferredOpenAIModel = "sybil.ios.quickQuestionPreferredOpenAIModel"
        static let quickQuestionPreferredAnthropicModel = "sybil.ios.quickQuestionPreferredAnthropicModel"
        static let quickQuestionPreferredXAIModel = "sybil.ios.quickQuestionPreferredXAIModel"
        static let quickQuestionPreferredGeminiModel = "sybil.ios.quickQuestionPreferredGeminiModel"
        static let quickQuestionPreferredHermesAgentModel = "sybil.ios.quickQuestionPreferredHermesAgentModel"
    }
@@ -44,6 +46,7 @@ final class SybilSettingsStore {
            .openai: defaults.string(forKey: Keys.preferredOpenAIModel) ?? "gpt-4.1-mini",
            .anthropic: defaults.string(forKey: Keys.preferredAnthropicModel) ?? "claude-3-5-sonnet-latest",
            .xai: defaults.string(forKey: Keys.preferredXAIModel) ?? "grok-3-mini",
            .gemini: defaults.string(forKey: Keys.preferredGeminiModel) ?? "gemini-3.5-flash",
            .hermesAgent: defaults.string(forKey: Keys.preferredHermesAgentModel) ?? "hermes-agent"
        ]
        self.preferredModelByProvider = preferredModels
@@ -54,6 +57,7 @@ final class SybilSettingsStore {
            .openai: defaults.string(forKey: Keys.quickQuestionPreferredOpenAIModel) ?? preferredModels[.openai] ?? "gpt-4.1-mini",
            .anthropic: defaults.string(forKey: Keys.quickQuestionPreferredAnthropicModel) ?? preferredModels[.anthropic] ?? "claude-3-5-sonnet-latest",
            .xai: defaults.string(forKey: Keys.quickQuestionPreferredXAIModel) ?? preferredModels[.xai] ?? "grok-3-mini",
            .gemini: defaults.string(forKey: Keys.quickQuestionPreferredGeminiModel) ?? preferredModels[.gemini] ?? "gemini-3.5-flash",
            .hermesAgent: defaults.string(forKey: Keys.quickQuestionPreferredHermesAgentModel) ?? preferredModels[.hermesAgent] ?? "hermes-agent"
        ]
    }
@@ -72,12 +76,14 @@ final class SybilSettingsStore {
        defaults.set(preferredModelByProvider[.openai], forKey: Keys.preferredOpenAIModel)
        defaults.set(preferredModelByProvider[.anthropic], forKey: Keys.preferredAnthropicModel)
        defaults.set(preferredModelByProvider[.xai], forKey: Keys.preferredXAIModel)
        defaults.set(preferredModelByProvider[.gemini], forKey: Keys.preferredGeminiModel)
        defaults.set(preferredModelByProvider[.hermesAgent], forKey: Keys.preferredHermesAgentModel)
        defaults.set(quickQuestionPreferredProvider.rawValue, forKey: Keys.quickQuestionPreferredProvider)
        defaults.set(quickQuestionPreferredModelByProvider[.openai], forKey: Keys.quickQuestionPreferredOpenAIModel)
        defaults.set(quickQuestionPreferredModelByProvider[.anthropic], forKey: Keys.quickQuestionPreferredAnthropicModel)
        defaults.set(quickQuestionPreferredModelByProvider[.xai], forKey: Keys.quickQuestionPreferredXAIModel)
        defaults.set(quickQuestionPreferredModelByProvider[.gemini], forKey: Keys.quickQuestionPreferredGeminiModel)
        defaults.set(quickQuestionPreferredModelByProvider[.hermesAgent], forKey: Keys.quickQuestionPreferredHermesAgentModel)
    }
@@ -64,6 +64,10 @@ extension Font {
    }
 }
 enum SybilLayout {
    static let webContentMaxWidth: CGFloat = 896
 }
 enum SybilTheme {
    static let background = Color(red: 0.02, green: 0.02, blue: 0.05)
    static let surface = Color(red: 0.05, green: 0.04, blue: 0.10)
@@ -160,6 +160,7 @@ final class SybilViewModel {
        .openai: ["gpt-4.1-mini"],
        .anthropic: ["claude-3-5-sonnet-latest"],
        .xai: ["grok-3-mini"],
        .gemini: ["gemini-3.5-flash", "gemini-flash-latest"],
        .hermesAgent: ["hermes-agent"]
    ]
@@ -1751,13 +1752,16 @@ final class SybilViewModel {
                switch target {
                case let .chat(chatID):
                    SybilLog.debug(SybilLog.app, "Refreshing chat \(chatID)")
                    let isSelectingDifferentChat = selectedChat?.id != chatID
                    let chat = try await client.getChat(chatID: chatID)
                    guard selectedItem == target, draftKind == nil else {
                        return
                    }
                    selectedChat = chat
                    selectedSearch = nil
                    if isSelectingDifferentChat {
                        requestChatBottomPin()
                    }
                    if let provider = chat.lastUsedProvider,
                       let model = chat.lastUsedModel,
@@ -544,12 +544,14 @@ private func makeToolCallMessage(id: String, date: Date, summary: String = "Ran
@MainActor
@Test func foregroundChatRefreshReloadsSelectedTranscript() async throws {
    let date = Date(timeIntervalSince1970: 1_700_000_100)
    let staleDetail = makeChatDetail(id: "chat-2", date: date, body: "stale transcript")
    let detail = makeChatDetail(id: "chat-2", date: date, body: "refreshed transcript")
    let client = MockSybilClient(chatDetails: ["chat-2": detail])
    let viewModel = SybilViewModel(settings: testSettings(named: #function)) { _ in client }
    viewModel.isAuthenticated = true
    viewModel.isCheckingSession = false
    viewModel.selectedItem = .chat("chat-2")
    viewModel.selectedChat = staleDetail
    await viewModel.refreshVisibleContent(refreshCollections: false, refreshSelection: true)
@@ -559,7 +561,7 @@ private func makeToolCallMessage(id: String, date: Date, summary: String = "Ran
    #expect(snapshot.listSearches == 0)
    #expect(snapshot.getChat == 1)
    #expect(viewModel.selectedChat?.messages.first?.content == "refreshed transcript")
-    #expect(viewModel.chatBottomPinRequestID == 1)
+    #expect(viewModel.chatBottomPinRequestID == 0)
 }
@MainActor
@@ -675,6 +677,7 @@ private func makeToolCallMessage(id: String, date: Date, summary: String = "Ran
    #expect(viewModel.displayedMessages.first?.content == "fresh transcript")
    #expect(!viewModel.isLoadingSelection)
    #expect(viewModel.chatBottomPinRequestID == 1)
 }
@MainActor
@@ -1,9 +0,0 @@
 require "dotenv"
 Dotenv.load(File.expand_path("../.env", __dir__))
 app_identifier(ENV.fetch("FASTLANE_APP_IDENTIFIER", "net.buzzert.sybil2"))
 team_id(ENV.fetch("FASTLANE_TEAM_ID", "DQQH5H6GBD"))
 apple_id(ENV["FASTLANE_USER"]) if ENV["FASTLANE_USER"].to_s.strip.length.positive?
 itc_team_id(ENV["FASTLANE_ITC_TEAM_ID"]) if ENV["FASTLANE_ITC_TEAM_ID"].to_s.strip.length.positive?
@@ -1,65 +0,0 @@
 # TestFlight Release CI
 Gitea Actions publishes iOS releases from tags that match:
 ```sh
 release/vN.N.N
 ```
 For example:
 ```sh
 git tag release/v1.10.0
 git push origin release/v1.10.0
 ```
 The release job runs on the `xcode` runner label, imports the signing p12 into
 a temporary per-user keychain, makes that keychain the user default for the
 duration of the job, installs the App Store provisioning profile, builds and
 uploads the app with fastlane, then creates or updates the matching Gitea
 release with the generated IPA as an asset. The job restores the previous user
 default keychain and deletes the temporary signing keychain in an `always()`
 cleanup step.
 Required repository secrets:
 ```text
 APP_STORE_CONNECT_API_KEY_ID
 APP_STORE_CONNECT_API_ISSUER_ID
 APP_STORE_CONNECT_API_KEY_CONTENT
 APPSTORE_CERTIFICATES_FILE_BASE64
 APPSTORE_CERTIFICATES_PASSWORD
 APPSTORE_PROVISIONING_PROFILE_BASE64
 ```
 Generate or refresh the signing assets locally with:
 ```sh
 cd ios
 fastlane ios create_ci_signing
 ```
 The generated `build/signing/ci-secrets.env` file is ignored by Git. Copy its
 certificate and provisioning profile values into the repository secrets listed
 above. The workflow uses the `Sybil AppStore CI` provisioning profile name by
 default.
 Fastlane keeps two signing names separate. `SYBIL_CODE_SIGN_IDENTITY` is the
 exact certificate common name used when exporting a local p12 for secrets, while
 `SYBIL_XCODE_CODE_SIGN_IDENTITY` defaults to the generic `Apple Distribution`
 selector that Xcode uses during archive/export.
 If the Apple team has reached the Distribution certificate limit, set
 `SYBIL_SIGNING_CERTIFICATE_ID` to the portal id for a certificate whose private
 key exists in the local login keychain before running `create_ci_signing`. The
 lane will export the local identity and create the provisioning profile against
 that existing certificate instead of creating another Distribution certificate.
 If `create_ci_signing` fails with an expired or missing agreement error, the
 Apple Developer Program account holder must accept the current agreements in
 App Store Connect before new certificates or provisioning profiles can be
 created through the API.
 The workflow uses Gitea's built-in `GITEA_TOKEN` for release creation and asset
 upload, with `contents: write` permissions. In Gitea this covers release asset
 publication.
@@ -1,455 +1,164 @@
 require "dotenv"
 require "base64"
 require "fileutils"
 require "json"
 require "net/http"
 require "open3"
 require "openssl"
 require "securerandom"
 require "shellwords"
 require "uri"
 require "yaml"
 Dotenv.load(File.expand_path("../.env", __dir__))
 default_platform(:ios)
-APP_IDENTIFIER = ENV.fetch("FASTLANE_APP_IDENTIFIER", "net.buzzert.sybil2")
+APP_IDENTIFIER = "net.buzzert.sybil2"
-TEAM_ID = ENV.fetch("FASTLANE_TEAM_ID", "DQQH5H6GBD")
+SCHEME = "Sybil"
-APP_STORE_APPLE_ID = ENV.fetch("SYBIL_APP_STORE_APPLE_ID", "6759442828")
+TEAM_ID = "DQQH5H6GBD"
-PROVIDER_PUBLIC_ID = ENV.fetch("SYBIL_PROVIDER_PUBLIC_ID", "c043d167-ad88-4036-84ea-76c223f1b1b2")
+PROFILE_NAME = "Sybil AppStore CI"
-PROFILE_SPECIFIER = ENV["SYBIL_PROVISIONING_PROFILE_SPECIFIER"].to_s.strip.empty? ? "Sybil AppStore CI" : ENV["SYBIL_PROVISIONING_PROFILE_SPECIFIER"]
+CI_KEYCHAIN_NAME = "sybil_ci_keychain"
-SIGNING_CERTIFICATE_NAME = ENV["SYBIL_CODE_SIGN_IDENTITY"].to_s.strip.empty? ? "Apple Distribution: James Magahern (DQQH5H6GBD)" : ENV["SYBIL_CODE_SIGN_IDENTITY"]
+CI_KEYCHAIN_PASSWORD = "sybil-ci-keychain-password"
-XCODE_CODE_SIGN_IDENTITY = ENV["SYBIL_XCODE_CODE_SIGN_IDENTITY"].to_s.strip.empty? ? "Apple Distribution" : ENV["SYBIL_XCODE_CODE_SIGN_IDENTITY"]
+CI_KEYCHAIN_DB_PATH = File.expand_path("~/Library/Keychains/#{CI_KEYCHAIN_NAME}-db")
 IOS_ROOT = File.expand_path("..", __dir__)
 PROJECT_FILE = File.join(IOS_ROOT, "Sybil.xcodeproj")
 PROJECT_SPEC = File.join(IOS_ROOT, "project.yml")
-APP_SPEC = File.join(IOS_ROOT, "Apps/Sybil/project.yml")
+APP_PROJECT_SPEC = File.join(IOS_ROOT, "Apps/Sybil/project.yml")
 SIGNING_OUTPUT_DIR = File.join(IOS_ROOT, "build/signing")
 SCHEME = "Sybil"
 TARGET = "SybilApp"
 def present?(value)
  !value.to_s.strip.empty?
 end
-def capture(command)
+def ci?
-  stdout, stderr, status = Open3.capture3(command)
+  present?(ENV["CI"])
  return stdout.strip if status.success?
  UI.user_error!("Command failed: #{command}\n#{stderr.strip}")
 end
 def run_silent(*command, error_message:)
  _stdout, stderr, status = Open3.capture3(*command)
  return if status.success?
  UI.user_error!("#{error_message}\n#{stderr.strip}")
 end
 def user_keychains
  capture("security list-keychains -d user").lines.map { |line| line.strip.delete('"') }.reject(&:empty?)
 end
 def app_project_settings
  YAML.safe_load(File.read(APP_SPEC)).fetch("targets").fetch(TARGET).fetch("settings").fetch("base")
 end
 def local_marketing_version
  app_project_settings.fetch("MARKETING_VERSION").to_s
 end
 def local_build_number
  app_project_settings.fetch("CURRENT_PROJECT_VERSION").to_i
 end
 def normalize_version_tag(tag)
  version = tag.to_s.strip.sub(%r{\Arelease/}, "").sub(/\Av/, "")
  unless version.match?(/\A\d+\.\d+\.\d+\z/)
    UI.user_error!("Release tag #{tag.inspect} must look like release/v1.10.0")
  end
  version
 end
 def release_version
  tag = ENV["SYBIL_VERSION_TAG"]
-  tag = capture("git describe --tags --abbrev=0") unless present?(tag)
+  tag = ENV["GITHUB_REF_NAME"] if !present?(tag)
-  normalize_version_tag(tag)
+  tag = ENV["GITHUB_REF"].to_s.sub(%r{\Arefs/tags/}, "") if !present?(tag)
-end
+  tag = sh("git describe --tags --abbrev=0").strip if !present?(tag)
  match = tag.to_s.match(%r{\Arelease/ios/v(\d+\.\d+\.\d+)\z})
-def xcode_build_setting(key, value)
+  unless match
-  "#{key.to_s.shellescape}=#{value.to_s.shellescape}"
+    UI.user_error!("Release tag must look like release/ios/v1.2.3; got #{tag.inspect}")
 end
 def env_line(key, value)
  "#{key}=#{value.to_s.shellescape}"
 end
 def base64url(value)
  Base64.urlsafe_encode64(value).delete("=")
 end
 def integer_to_fixed_bytes(integer, length)
  hex = integer.to_s(16)
  hex = "0#{hex}" if hex.length.odd?
  [hex].pack("H*").rjust(length, "\0")[-length, length]
 end
 def app_store_connect_private_key
  key_path = ENV["APP_STORE_CONNECT_API_KEY_PATH"]
  key_content = ENV["APP_STORE_CONNECT_API_KEY_CONTENT"]
  pem = if present?(key_path)
          File.read(key_path)
        elsif present?(key_content)
          ENV["APP_STORE_CONNECT_API_KEY_CONTENT_BASE64"].to_s == "true" ? Base64.decode64(key_content) : key_content
        end
  UI.user_error!("App Store Connect API key content is required") unless present?(pem)
  OpenSSL::PKey::EC.new(pem)
 end
 def app_store_connect_jwt
  key_id = ENV["APP_STORE_CONNECT_API_KEY_ID"]
  issuer_id = ENV["APP_STORE_CONNECT_API_ISSUER_ID"]
  issuer_id = ENV["APP_STORE_CONNECT_API_KEY_ISSUER_ID"] unless present?(issuer_id)
  UI.user_error!("App Store Connect API key id and issuer id are required") unless present?(key_id) && present?(issuer_id)
  header = { alg: "ES256", kid: key_id, typ: "JWT" }
  payload = { iss: issuer_id, iat: Time.now.to_i, exp: Time.now.to_i + 600, aud: "appstoreconnect-v1" }
  unsigned = [base64url(header.to_json), base64url(payload.to_json)].join(".")
  asn1_signature = app_store_connect_private_key.dsa_sign_asn1(OpenSSL::Digest::SHA256.digest(unsigned))
  signature_sequence = OpenSSL::ASN1.decode(asn1_signature)
  raw_signature = signature_sequence.value.map { |part| integer_to_fixed_bytes(part.value, 32) }.join
  [unsigned, base64url(raw_signature)].join(".")
 end
 def app_store_connect_request(method, path, payload = nil)
  uri = URI("https://api.appstoreconnect.apple.com#{path}")
  request_class = Net::HTTP.const_get(method.to_s.capitalize)
  request = request_class.new(uri)
  request["Authorization"] = "Bearer #{app_store_connect_jwt}"
  if payload
    request["Content-Type"] = "application/json"
    request.body = payload.to_json
  end
-  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+  match[1]
  return {} if response.is_a?(Net::HTTPSuccess) && response.body.to_s.empty?
  return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
  UI.user_error!("App Store Connect API request failed: #{method.to_s.upcase} #{path}\n#{response.body}")
 end
-def bundle_id_resource_id
+# App Store Connect requires CFBundleVersion to be unique and strictly
-  response = app_store_connect_request(
+# increasing app-wide (not just per marketing version), so we derive it from
-    :get,
+# the monotonic CI run number rather than querying TestFlight (that query can
-    "/v1/bundleIds?filter[identifier]=#{URI.encode_www_form_component(APP_IDENTIFIER)}&limit=1"
+# lag behind builds still processing and hand back a colliding value).
-  )
+def build_number
-  id = response.fetch("data", []).first&.fetch("id", nil)
+  value = present?(ENV["SYBIL_BUILD_NUMBER"]) ? ENV["SYBIL_BUILD_NUMBER"] : ENV["GITHUB_RUN_NUMBER"]
-  UI.user_error!("Could not find App Store Connect bundle id resource for #{APP_IDENTIFIER}") unless present?(id)
+
-  id
+  unless value.to_s.match?(/\A\d+\z/)
    UI.user_error!("Build number must come from SYBIL_BUILD_NUMBER/GITHUB_RUN_NUMBER; got #{value.inspect}")
  end
  value.to_i
 end
-def recreate_app_store_profile(certificate_id)
+def stamp_marketing_version(version)
-  existing = app_store_connect_request(
+  contents = File.read(APP_PROJECT_SPEC)
-    :get,
+  updated = contents.sub(/^(\s*MARKETING_VERSION:\s*).*/, "\\1\"#{version}\"")
-    "/v1/profiles?filter[name]=#{URI.encode_www_form_component(PROFILE_SPECIFIER)}&limit=200"
+
-  )
+  if updated == contents
-  existing.fetch("data", []).each do |profile|
+    UI.user_error!("Could not find MARKETING_VERSION in #{APP_PROJECT_SPEC}")
    app_store_connect_request(:delete, "/v1/profiles/#{profile.fetch("id")}")
  end
-  payload = {
+  File.write(APP_PROJECT_SPEC, updated)
    data: {
      type: "profiles",
      attributes: {
        name: PROFILE_SPECIFIER,
        profileType: "IOS_APP_STORE"
      },
      relationships: {
        bundleId: {
          data: { type: "bundleIds", id: bundle_id_resource_id }
        },
        certificates: {
          data: [{ type: "certificates", id: certificate_id }]
        }
      }
    }
  }
  response = app_store_connect_request(:post, "/v1/profiles", payload)
  profile_content = response.dig("data", "attributes", "profileContent")
  UI.user_error!("App Store Connect profile response did not include profileContent") unless present?(profile_content)
  profile_path = File.join(SIGNING_OUTPUT_DIR, "Sybil_AppStore_CI.mobileprovision")
  File.binwrite(profile_path, Base64.decode64(profile_content))
  install_dir = File.expand_path("~/Library/MobileDevice/Provisioning Profiles")
  FileUtils.mkdir_p(install_dir)
  FileUtils.cp(profile_path, File.join(install_dir, "Sybil_AppStore_CI.mobileprovision"))
  profile_path
 end
 def signing_identity_p12(p12_path, p12_password)
  work_dir = File.join(SIGNING_OUTPUT_DIR, "single-identity")
  FileUtils.rm_rf(work_dir)
  FileUtils.mkdir_p(work_dir)
  all_pem = File.join(work_dir, "all.pem")
  stdout, stderr, status = Open3.capture3(
    "openssl", "pkcs12",
    "-in", p12_path,
    "-nodes",
    "-passin", "pass:#{p12_password}",
    "-out", all_pem
  )
  UI.user_error!("Could not inspect exported p12\n#{stderr}\n#{stdout}") unless status.success?
  records = File.read(all_pem).split(/(?=Bag Attributes\n)/)
  cert_record = records.find do |record|
    record.include?("friendlyName: #{SIGNING_CERTIFICATE_NAME}") && record.include?("-----BEGIN CERTIFICATE-----")
  end
  UI.user_error!("Could not find #{SIGNING_CERTIFICATE_NAME} certificate in exported p12") unless cert_record
  local_key_id = cert_record[/localKeyID: (.+)/, 1].to_s.strip
  UI.user_error!("Could not resolve localKeyID for #{SIGNING_CERTIFICATE_NAME}") unless present?(local_key_id)
  key_record = records.find do |record|
    record.include?("localKeyID: #{local_key_id}") && record.include?("-----BEGIN PRIVATE KEY-----")
  end
  UI.user_error!("Could not find private key for #{SIGNING_CERTIFICATE_NAME}") unless key_record
  cert_path = File.join(work_dir, "identity.cer.pem")
  key_path = File.join(work_dir, "identity.key.pem")
  File.write(cert_path, cert_record[/-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----/m])
  File.write(key_path, key_record[/-----BEGIN PRIVATE KEY-----.*?-----END PRIVATE KEY-----/m])
  root_cer = File.join(work_dir, "AppleIncRootCertificate.cer")
  wwdr_cer = File.join(work_dir, "AppleWWDRCAG3.cer")
  root_pem = File.join(work_dir, "AppleIncRootCertificate.pem")
  wwdr_pem = File.join(work_dir, "AppleWWDRCAG3.pem")
  chain_pem = File.join(work_dir, "chain.pem")
  run_silent("curl", "-fsSL", "https://www.apple.com/appleca/AppleIncRootCertificate.cer", "-o", root_cer, error_message: "Could not download Apple root certificate")
  run_silent("curl", "-fsSL", "https://www.apple.com/certificateauthority/AppleWWDRCAG3.cer", "-o", wwdr_cer, error_message: "Could not download Apple WWDR G3 certificate")
  run_silent("openssl", "x509", "-inform", "DER", "-in", root_cer, "-out", root_pem, error_message: "Could not convert Apple root certificate")
  run_silent("openssl", "x509", "-inform", "DER", "-in", wwdr_cer, "-out", wwdr_pem, error_message: "Could not convert Apple WWDR G3 certificate")
  File.write(chain_pem, File.read(wwdr_pem) + File.read(root_pem))
  single_p12_path = File.join(work_dir, "appstore-signing.p12")
  run_silent(
    "openssl", "pkcs12", "-export",
    "-inkey", key_path,
    "-in", cert_path,
    "-certfile", chain_pem,
    "-name", SIGNING_CERTIFICATE_NAME,
    "-out", single_p12_path,
    "-passout", "pass:#{p12_password}",
    error_message: "Could not create single-identity p12"
  )
  FileUtils.cp(single_p12_path, p12_path)
 ensure
  FileUtils.rm_rf(work_dir) if present?(work_dir)
 end
 def app_store_connect_key_options
  key_id = ENV["APP_STORE_CONNECT_API_KEY_ID"]
  issuer_id = ENV["APP_STORE_CONNECT_API_ISSUER_ID"]
  issuer_id = ENV["APP_STORE_CONNECT_API_KEY_ISSUER_ID"] unless present?(issuer_id)
  return nil unless present?(key_id) && present?(issuer_id)
  key_path = ENV["APP_STORE_CONNECT_API_KEY_PATH"]
  key_content = ENV["APP_STORE_CONNECT_API_KEY_CONTENT"]
  if present?(key_path)
    {
      key_id: key_id,
      issuer_id: issuer_id,
      key_filepath: key_path
    }
  elsif present?(key_content)
    {
      key_id: key_id,
      issuer_id: issuer_id,
      key_content: key_content,
      is_key_content_base64: ENV["APP_STORE_CONNECT_API_KEY_CONTENT_BASE64"].to_s == "true"
    }
  end
 end
 platform :ios do
-  private_lane :load_app_store_connect_api_key do
+  private_lane :app_store_api_key do
-    options = app_store_connect_key_options
+    app_store_connect_api_key(
-    UI.user_error!("App Store Connect API key is required") unless options
+      key_id: ENV.fetch("APP_STORE_CONNECT_KEY_ID"),
-
+      issuer_id: ENV.fetch("APP_STORE_CONNECT_ISSUER_ID"),
-    app_store_connect_api_key(options)
+      key_content: ENV.fetch("APP_STORE_CONNECT_KEY_CONTENT"),
-  end
+      is_key_content_base64: true
  desc "Show the version Fastlane will stamp into the next TestFlight archive"
  lane :version do
    UI.message("Git tag version: #{release_version}")
    UI.message("Checked-in app version: #{local_marketing_version}")
    UI.message("Checked-in build number: #{local_build_number}")
  end
  desc "Create CI signing certificate/profile and write ignored secret material under build/signing"
  lane :create_ci_signing do
    api_key = load_app_store_connect_api_key
    FileUtils.rm_rf(SIGNING_OUTPUT_DIR)
    FileUtils.mkdir_p(SIGNING_OUTPUT_DIR)
    cert_id = ENV["SYBIL_SIGNING_CERTIFICATE_ID"].to_s
    keychain_path = nil
    keychain_password = nil
    p12_path = File.join(SIGNING_OUTPUT_DIR, "appstore-signing.p12")
    p12_password = ENV["SYBIL_CI_P12_PASSWORD"].to_s
    if p12_password.empty?
      p12_password = SecureRandom.base64(24)
      UI.important("Generated a p12 password for CI secrets.")
    end
    begin
      if present?(cert_id)
        UI.message("Using existing signing certificate id #{cert_id}")
        export_keychain = ENV["SYBIL_SIGNING_KEYCHAIN"].to_s
        export_keychain = File.expand_path("~/Library/Keychains/login.keychain-db") unless present?(export_keychain)
        run_silent(
          "security", "export", "-k", export_keychain, "-t", "identities", "-f", "pkcs12", "-P", p12_password, "-o", p12_path,
          error_message: "Could not export the local CI signing identity"
        )
      else
        keychain_path = File.join(SIGNING_OUTPUT_DIR, "sybil_ci_signing.keychain-db")
        keychain_password = SecureRandom.base64(24)
        run_silent(
          "security", "create-keychain", "-p", keychain_password, keychain_path,
          error_message: "Could not create temporary signing keychain"
        )
        run_silent(
          "security", "set-keychain-settings", "-lut", "21600", keychain_path,
          error_message: "Could not configure temporary signing keychain"
        )
        run_silent(
          "security", "unlock-keychain", "-p", keychain_password, keychain_path,
          error_message: "Could not unlock temporary signing keychain"
        )
        run_silent(
          "security", "list-keychains", "-d", "user", "-s", keychain_path, *user_keychains,
          error_message: "Could not add temporary signing keychain to the user search list"
        )
        cert(
          api_key: api_key,
          development: false,
          force: true,
          generate_apple_certs: true,
          keychain_password: keychain_password,
          keychain_path: keychain_path,
          output_path: SIGNING_OUTPUT_DIR,
          platform: "ios"
        )
        cert_id = lane_context[SharedValues::CERT_CERTIFICATE_ID]
        UI.user_error!("Could not resolve generated certificate id") unless present?(cert_id)
        run_silent(
          "security", "export", "-k", keychain_path, "-t", "identities", "-f", "pkcs12", "-P", p12_password, "-o", p12_path,
          error_message: "Could not export the generated CI signing identity"
    )
  end
-      UI.user_error!("Could not find exported p12 at #{p12_path}") unless File.exist?(p12_path)
+  # CI signs headlessly, so match needs a fresh unlocked keychain to import
-      signing_identity_p12(p12_path, p12_password)
+  # into. codesign resolves identities through the user keychain *search list*
  # (first match wins; the --keychain flag does not restrict the lookup), and
  # other projects' keychains on this runner hold the same identity but are
  # usually locked — so ours must come first. delete_keychain in the beta
  # lane's ensure removes both the keychain and its search-list entry, which
  # also keeps our (later locked) copy from shadowing those other projects.
  private_lane :prepare_ci_keychain do
    next unless ci?
-      profile_path = recreate_app_store_profile(cert_id)
+    delete_keychain(name: CI_KEYCHAIN_NAME) if File.file?(CI_KEYCHAIN_DB_PATH)
-      UI.user_error!("Could not resolve generated provisioning profile path") unless present?(profile_path) && File.exist?(profile_path)
+    create_keychain(
-
+      name: CI_KEYCHAIN_NAME,
-      secrets_path = File.join(SIGNING_OUTPUT_DIR, "ci-secrets.env")
+      password: CI_KEYCHAIN_PASSWORD,
-      File.write(
+      unlock: true,
-        secrets_path,
+      timeout: 3600,
-        [
+      add_to_search_list: false
          env_line("APPSTORE_CERTIFICATES_FILE_BASE64", Base64.strict_encode64(File.binread(p12_path))),
          env_line("APPSTORE_CERTIFICATES_PASSWORD", p12_password),
          env_line("APPSTORE_PROVISIONING_PROFILE_BASE64", Base64.strict_encode64(File.binread(profile_path))),
          env_line("SYBIL_PROVISIONING_PROFILE_SPECIFIER", PROFILE_SPECIFIER)
        ].join("\n") + "\n"
    )
-    ensure
+
-      system("security", "delete-keychain", keychain_path, out: File::NULL, err: File::NULL) if present?(keychain_path) && File.exist?(keychain_path)
+    others = sh("security list-keychains -d user", log: false)
      .scan(/"([^"]+)"/)
      .flatten
      .reject { |path| path.include?(CI_KEYCHAIN_NAME) }
    sh("security list-keychains -d user -s #{([CI_KEYCHAIN_DB_PATH] + others).shelljoin}")
    ENV["MATCH_KEYCHAIN_NAME"] = CI_KEYCHAIN_NAME
    ENV["MATCH_KEYCHAIN_PASSWORD"] = CI_KEYCHAIN_PASSWORD
  end
-    UI.success("Created CI signing files in #{SIGNING_OUTPUT_DIR}")
+  private_lane :sync_signing do |options|
-    UI.important("Add the values from #{secrets_path} as repository secrets.")
+    match(
-  end
+      type: "appstore",
-
+      readonly: options.fetch(:readonly),
  desc "Build Sybil and upload it to TestFlight"
  lane :beta do
    version = release_version
    build_number = ENV["SYBIL_BUILD_NUMBER"].to_s
    api_key = load_app_store_connect_api_key
    unless present?(build_number)
      build_number = (local_build_number + 1).to_s
      begin
        latest = latest_testflight_build_number(
      app_identifier: APP_IDENTIFIER,
-          version: version,
+      team_id: TEAM_ID,
-          api_key: api_key,
+      profile_name: PROFILE_NAME,
-          initial_build_number: local_build_number
+      git_url: ENV.fetch("MATCH_GIT_URL"),
-        ).to_i
+      git_branch: "master",
-        build_number = [latest + 1, local_build_number + 1].max.to_s
+      git_full_name: "Sybil Release Bot",
-      rescue StandardError => e
+      git_user_email: "james.magahern@me.com",
-        UI.important("Could not look up TestFlight build number: #{e.message}")
+      api_key: options.fetch(:api_key)
-        UI.important("Using checked-in build number + 1: #{build_number}")
+    )
      end
  end
-    UI.user_error!("Build number must be a positive integer") unless build_number.match?(/\A[1-9]\d*\z/)
+  desc "Create or update match signing assets"
-
+  lane :setup_signing do
-    sh("xcodegen --spec #{PROJECT_SPEC.shellescape}")
+    sync_signing(api_key: app_store_api_key, readonly: false)
    xcode_args = [
      xcode_build_setting("MARKETING_VERSION", version),
      xcode_build_setting("CURRENT_PROJECT_VERSION", build_number),
      xcode_build_setting("CODE_SIGN_STYLE", "Manual"),
      xcode_build_setting("DEVELOPMENT_TEAM", TEAM_ID),
      xcode_build_setting("PROVISIONING_PROFILE_SPECIFIER", PROFILE_SPECIFIER),
      xcode_build_setting("CODE_SIGN_IDENTITY", XCODE_CODE_SIGN_IDENTITY)
    ]
    if present?(ENV["SYBIL_SIGNING_KEYCHAIN_PATH"])
      xcode_args << xcode_build_setting("OTHER_CODE_SIGN_FLAGS", "--keychain #{ENV.fetch("SYBIL_SIGNING_KEYCHAIN_PATH")}")
  end
    xcode_args = xcode_args.join(" ")
-    ipa_path = build_app(
+  desc "Build and upload to TestFlight"
  lane :beta do
    prepare_ci_keychain
    api_key = app_store_api_key
    version = release_version
    stamp_marketing_version(version)
    sh("xcodegen", "--spec", PROJECT_SPEC)
    increment_version_number(version_number: version, xcodeproj: PROJECT_FILE)
    increment_build_number(build_number: build_number, xcodeproj: PROJECT_FILE)
    sync_signing(api_key: api_key, readonly: true)
    build_app(
      project: PROJECT_FILE,
      scheme: SCHEME,
      clean: true,
      sdk: "iphoneos",
      export_method: "app-store",
-      output_directory: File.join(IOS_ROOT, "build/fastlane"),
+      xcargs: [
-      output_name: "Sybil-#{version}-#{build_number}.ipa",
+        "DEVELOPMENT_TEAM=#{TEAM_ID.shellescape}",
-      xcargs: xcode_args,
+        "CODE_SIGN_STYLE=Manual",
        "CODE_SIGN_IDENTITY=Apple\\ Distribution",
        "PROVISIONING_PROFILE_SPECIFIER=#{PROFILE_NAME.shellescape}"
      ].join(" "),
      export_options: {
        method: "app-store",
        destination: "export",
        signingStyle: "manual",
        provisioningProfiles: {
          APP_IDENTIFIER => PROFILE_SPECIFIER
        },
        signingCertificate: XCODE_CODE_SIGN_IDENTITY,
        teamID: TEAM_ID,
-        manageAppVersionAndBuildNumber: false,
+        provisioningProfiles: {
-        uploadSymbols: true,
+          APP_IDENTIFIER => PROFILE_NAME
-        stripSwiftSymbols: true
+        }
      }
    )
    ipa_path ||= lane_context[SharedValues::IPA_OUTPUT_PATH]
    UI.user_error!("IPA export failed; no IPA path was returned") unless present?(ipa_path) && File.exist?(ipa_path)
    upload_to_testflight(
      api_key: api_key,
      app_identifier: APP_IDENTIFIER,
      ipa: ipa_path,
      skip_waiting_for_build_processing: true
    )
  ensure
    delete_keychain(name: CI_KEYCHAIN_NAME) if ci? && File.file?(CI_KEYCHAIN_DB_PATH)
  end
 end
@@ -1,48 +0,0 @@
 fastlane documentation
 ----
 # Installation
 Make sure you have the latest version of the Xcode command line tools installed:
 ```sh
 xcode-select --install
 ```
 For _fastlane_ installation instructions, see [Installing _fastlane_](https://docs.fastlane.tools/#installing-fastlane)
 # Available Actions
 ## iOS
 ### ios version
 ```sh
 [bundle exec] fastlane ios version
 ```
 Show the version Fastlane will stamp into the next TestFlight archive
 ### ios create_ci_signing
 ```sh
 [bundle exec] fastlane ios create_ci_signing
 ```
 Create CI signing certificate/profile and write ignored secret material under build/signing
 ### ios beta
 ```sh
 [bundle exec] fastlane ios beta
 ```
 Build Sybil and upload it to TestFlight
 ----
 This README.md is auto-generated and will be re-generated every time [_fastlane_](https://fastlane.tools) is run.
 More information about _fastlane_ can be found on [fastlane.tools](https://fastlane.tools).
 The documentation of _fastlane_ can be found on [docs.fastlane.tools](https://docs.fastlane.tools).
@@ -1,7 +1,7 @@
 # Sybil Server
 Backend API for:
- LLM multiplexer (OpenAI Responses / Anthropic / xAI Chat Completions-compatible Grok / Hermes Agent)
+- LLM multiplexer (OpenAI Responses / Anthropic / xAI Chat Completions-compatible Grok / Gemini / Hermes Agent)
 - Personal chat database (chats/messages + LLM call log)
 ## Stack
@@ -43,6 +43,7 @@ If `ADMIN_TOKEN` is not set, the server runs in open mode (dev).
 - `OPENAI_API_KEY`
 - `ANTHROPIC_API_KEY`
 - `XAI_API_KEY`
 - `GEMINI_API_KEY`
 - `HERMES_AGENT_API_BASE_URL` (`http://127.0.0.1:8642/v1` by default; include the `/v1` suffix)
 - `HERMES_AGENT_API_KEY` (enables the Hermes Agent provider; set to Hermes `API_SERVER_KEY`, or any non-empty value if that local server does not require auth)
 - `HERMES_AGENT_MODEL` (optional fallback/override model id; defaults client-side to `hermes-agent`)
@@ -50,7 +51,7 @@ If `ADMIN_TOKEN` is not set, the server runs in open mode (dev).
 - `CHAT_WEB_SEARCH_ENGINE` (`exa` by default, or `searxng` for chat tool calls only)
 - `SEARXNG_BASE_URL` (required when `CHAT_WEB_SEARCH_ENGINE=searxng`; instance must allow `format=json`)
 - `CHAT_MAX_TOOL_ROUNDS` (`100` by default; maximum model/tool result cycles per chat completion)
- `CHAT_CODEX_TOOL_ENABLED` (`false` by default; enables the `codex_exec` chat tool for OpenAI/xAI)
+- `CHAT_CODEX_TOOL_ENABLED` (`false` by default; enables the `codex_exec` chat tool for managed-tool providers)
 - `CHAT_CODEX_REMOTE_HOST` (required when Codex tool is enabled; SSH host/IP or `user@host`)
 - `CHAT_CODEX_REMOTE_USER` (optional SSH user when host does not include one)
 - `CHAT_CODEX_REMOTE_PORT` (`22` by default)
@@ -58,7 +59,7 @@ If `ADMIN_TOKEN` is not set, the server runs in open mode (dev).
 - `CHAT_CODEX_SSH_KEY_PATH` (recommended: path to a read-only mounted private key)
 - `CHAT_CODEX_SSH_PRIVATE_KEY_B64` (optional fallback private key delivery)
 - `CHAT_CODEX_EXEC_TIMEOUT_MS` (`600000` by default)
- `CHAT_SHELL_TOOL_ENABLED` (`false` by default; enables the `shell_exec` chat tool for OpenAI/xAI on the same devbox)
+- `CHAT_SHELL_TOOL_ENABLED` (`false` by default; enables the `shell_exec` chat tool for managed-tool providers on the same devbox)
 - `CHAT_SHELL_EXEC_TIMEOUT_MS` (`120000` by default)
 ## API
@@ -13,6 +13,7 @@ enum Provider {
  openai
  anthropic
  xai
  gemini
  hermes_agent @map("hermes-agent")
 }
@@ -66,6 +66,7 @@ const EnvSchema = z.object({
  OPENAI_API_KEY: z.string().optional(),
  ANTHROPIC_API_KEY: z.string().optional(),
  XAI_API_KEY: z.string().optional(),
  GEMINI_API_KEY: z.string().optional(),
  HERMES_AGENT_API_BASE_URL: HermesAgentApiBaseUrlSchema,
  HERMES_AGENT_API_KEY: OptionalTrimmedStringSchema,
  HERMES_AGENT_MODEL: OptionalTrimmedStringSchema,
@@ -0,0 +1,501 @@
 import {
  buildChatToolSystemPrompt,
  executeToolCallAndBuildEvent,
  getEnabledChatTools,
  getUnstreamedText,
  looksLikeDanglingToolIntent,
  MAX_DANGLING_TOOL_INTENT_RETRIES,
  MAX_TOOL_ROUNDS,
  prepareToolCallExecution,
  type NormalizedToolCall,
  type ToolAwareCompletionParams,
  type ToolAwareCompletionResult,
  type ToolAwareStreamingEvent,
  type ToolAwareUsage,
  type ToolExecutionEvent,
 } from "../chat-tools.js";
 import {
  buildImageSummaryText,
  buildTextAttachmentPrompt,
  buildTopLevelSystemPrompt,
  getImageAttachments,
  getTextAttachments,
  parseImageDataUrl,
 } from "../message-content.js";
 import type { ChatMessage } from "../types.js";
 type GeminiClient = {
  apiKey: string;
  baseURL: string;
 };
 const INTERNAL_CORRECTION =
  "Internal correction: the previous assistant message claimed it would run a tool, but no tool call was made. If the task needs an available tool, call it now. Otherwise provide the final answer directly without saying you will run a tool.";
 function normalizeModelResourceName(model: string) {
  const trimmed = model.trim().replace(/^\/+/, "");
  return trimmed.startsWith("models/") || trimmed.startsWith("tunedModels/") ? trimmed : `models/${trimmed}`;
 }
 function geminiUrl(client: GeminiClient, model: string, method: "generateContent" | "streamGenerateContent", extraParams: Record<string, string> = {}) {
  const url = new URL(`${client.baseURL.replace(/\/+$/, "")}/${normalizeModelResourceName(model)}:${method}`);
  url.searchParams.set("key", client.apiKey);
  for (const [key, value] of Object.entries(extraParams)) {
    url.searchParams.set(key, value);
  }
  return url;
 }
 function generationConfig(params: Pick<ToolAwareCompletionParams, "temperature" | "maxTokens">) {
  const config: Record<string, unknown> = {};
  if (params.temperature !== undefined) config.temperature = params.temperature;
  if (params.maxTokens !== undefined) config.maxOutputTokens = params.maxTokens;
  return Object.keys(config).length ? config : undefined;
 }
 function toGeminiJsonSchema(schema: unknown): Record<string, unknown> | undefined {
  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return undefined;
  const input = schema as Record<string, unknown>;
  const output: Record<string, unknown> = {};
  if (typeof input.type === "string") output.type = input.type;
  if (typeof input.description === "string") output.description = input.description;
  if (typeof input.format === "string") output.format = input.format;
  if (typeof input.nullable === "boolean") output.nullable = input.nullable;
  if (Array.isArray(input.enum)) output.enum = input.enum.filter((value) => typeof value === "string");
  if (Array.isArray(input.required)) output.required = input.required.filter((value) => typeof value === "string");
  const items = toGeminiJsonSchema(input.items);
  if (items) output.items = items;
  if (input.properties && typeof input.properties === "object" && !Array.isArray(input.properties)) {
    const properties: Record<string, unknown> = {};
    for (const [key, value] of Object.entries(input.properties)) {
      const propertySchema = toGeminiJsonSchema(value);
      if (propertySchema) properties[key] = propertySchema;
    }
    if (Object.keys(properties).length) output.properties = properties;
  }
  return Object.keys(output).length ? output : undefined;
 }
 function toGeminiTools(tools: any[]) {
  const functionDeclarations = tools
    .map((tool) => {
      if (tool?.type !== "function") return null;
      const declaration: Record<string, unknown> = {
        name: tool.function.name,
        description: tool.function.description,
      };
      const parameters = toGeminiJsonSchema(tool.function.parameters);
      if (parameters) declaration.parameters = parameters;
      return declaration;
    })
    .filter(Boolean);
  return functionDeclarations.length ? [{ functionDeclarations }] : undefined;
 }
 function toContentParts(message: ChatMessage) {
  const imageAttachments = getImageAttachments(message);
  const textAttachments = getTextAttachments(message);
  const parts: Array<Record<string, unknown>> = [];
  for (const attachment of imageAttachments) {
    const source = parseImageDataUrl(attachment);
    parts.push({
      inlineData: {
        mimeType: source.mediaType,
        data: source.data,
      },
    });
  }
  const imageSummary = buildImageSummaryText(imageAttachments);
  if (imageSummary) {
    parts.push({ text: imageSummary });
  }
  for (const attachment of textAttachments) {
    parts.push({ text: buildTextAttachmentPrompt(attachment) });
  }
  if (message.content.trim()) {
    parts.push({ text: message.content });
  }
  return parts.length ? parts : [{ text: "" }];
 }
 function buildConversationContent(message: ChatMessage) {
  if (message.role === "system") {
    throw new Error("System messages must be handled separately for Gemini.");
  }
  if (message.role === "tool") {
    const name = message.name?.trim() || "tool";
    return {
      role: "user",
      parts: [{ text: `Tool output (${name}):\n${message.content}` }],
    };
  }
  return {
    role: message.role === "assistant" ? "model" : "user",
    parts: toContentParts(message),
  };
 }
 function buildBaseContents(messages: ChatMessage[]) {
  return messages.filter((message) => message.role !== "system").map((message) => buildConversationContent(message));
 }
 function buildSystemInstruction(params: ToolAwareCompletionParams, toolSystemPrompt?: string) {
  const text = buildTopLevelSystemPrompt(params.messages, params.userLocation, toolSystemPrompt);
  return text ? { parts: [{ text }] } : undefined;
 }
 function mergeUsage(acc: Required<ToolAwareUsage>, usage: any) {
  const normalized = normalizeUsage(usage);
  if (!normalized) return false;
  acc.inputTokens += normalized.inputTokens;
  acc.outputTokens += normalized.outputTokens;
  acc.totalTokens += normalized.totalTokens;
  return true;
 }
 function normalizeUsage(usage: any) {
  if (!usage) return null;
  const inputTokens = usage.promptTokenCount ?? 0;
  const outputTokens = usage.candidatesTokenCount ?? 0;
  const totalTokens = usage.totalTokenCount ?? inputTokens + outputTokens;
  return { inputTokens, outputTokens, totalTokens };
 }
 function getCandidate(response: any) {
  return Array.isArray(response?.candidates) ? response.candidates[0] : null;
 }
 function getParts(response: any) {
  const parts = getCandidate(response)?.content?.parts;
  return Array.isArray(parts) ? parts : [];
 }
 function extractText(response: any) {
  return getParts(response)
    .map((part: any) => (typeof part?.text === "string" ? part.text : ""))
    .join("");
 }
 function stringifyToolArgs(args: unknown) {
  try {
    return JSON.stringify(args ?? {});
  } catch {
    return "{}";
  }
 }
 function normalizeToolCallsFromParts(parts: any[], round: number): NormalizedToolCall[] {
  return parts
    .filter((part) => part?.functionCall)
    .map((part, index) => ({
      id: part.functionCall.id ?? `tool_call_${round}_${index}`,
      name: part.functionCall.name ?? "unknown_tool",
      arguments: stringifyToolArgs(part.functionCall.args),
    }));
 }
 function buildFunctionResponsePart(call: NormalizedToolCall, toolResult: unknown) {
  return {
    functionResponse: {
      id: call.id,
      name: call.name,
      response: toolResult,
    },
  };
 }
 function appendCorrection(conversation: any[], text: string) {
  conversation.push({ role: "model", parts: [{ text }] });
  conversation.push({ role: "user", parts: [{ text: INTERNAL_CORRECTION }] });
 }
 async function parseGeminiResponse(response: Response) {
  const bodyText = await response.text();
  let body: any = null;
  try {
    body = bodyText ? JSON.parse(bodyText) : null;
  } catch {
    body = { raw: bodyText };
  }
  if (!response.ok) {
    throw new Error(body?.error?.message ?? `Gemini API request failed with status ${response.status}.`);
  }
  return body;
 }
 async function generateContent(params: ToolAwareCompletionParams, body: Record<string, unknown>) {
  const response = await fetch(geminiUrl(params.client, params.model, "generateContent"), {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  return parseGeminiResponse(response);
 }
 function getFailureMessage(response: any, text: string, toolCallCount: number) {
  const promptBlockReason = response?.promptFeedback?.blockReason;
  if (promptBlockReason) return `Gemini prompt blocked: ${promptBlockReason}.`;
  const candidate = getCandidate(response);
  const finishReason = candidate?.finishReason;
  if (!finishReason || finishReason === "STOP" || finishReason === "MAX_TOKENS") return null;
  if (text || toolCallCount > 0) return null;
  return candidate?.finishMessage ?? `Gemini response stopped: ${finishReason}.`;
 }
 function buildRequest(params: ToolAwareCompletionParams, conversation: any[], enabledTools: any[] = []) {
  const tools = toGeminiTools(enabledTools);
  return {
    contents: conversation,
    systemInstruction: buildSystemInstruction(params, enabledTools.length ? buildChatToolSystemPrompt(params) : undefined),
    generationConfig: generationConfig(params),
    tools,
    toolConfig: tools ? { functionCallingConfig: { mode: "AUTO" } } : undefined,
  };
 }
 export async function completeWithGeminiApi(params: ToolAwareCompletionParams): Promise<ToolAwareCompletionResult> {
  const enabledTools = getEnabledChatTools(params);
  const conversation = buildBaseContents(params.messages);
  const rawResponses: unknown[] = [];
  const toolEvents: ToolExecutionEvent[] = [];
  const usageAcc: Required<ToolAwareUsage> = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
  let sawUsage = false;
  let totalToolCalls = 0;
  let danglingToolIntentRetries = 0;
  for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
    const response = await generateContent(params, buildRequest(params, conversation, enabledTools));
    rawResponses.push(response);
    sawUsage = mergeUsage(usageAcc, response?.usageMetadata) || sawUsage;
    const parts = getParts(response);
    const text = extractText(response);
    const normalizedToolCalls = normalizeToolCallsFromParts(parts, round);
    const failureMessage = getFailureMessage(response, text, normalizedToolCalls.length);
    if (failureMessage) throw new Error(failureMessage);
    if (!normalizedToolCalls.length) {
      if (danglingToolIntentRetries < MAX_DANGLING_TOOL_INTENT_RETRIES && looksLikeDanglingToolIntent(text)) {
        danglingToolIntentRetries += 1;
        appendCorrection(conversation, text);
        continue;
      }
      return {
        text,
        usage: sawUsage ? usageAcc : undefined,
        raw: { responses: rawResponses, toolCallsUsed: totalToolCalls, api: "gemini.generateContent" },
        toolEvents,
      };
    }
    totalToolCalls += normalizedToolCalls.length;
    conversation.push({ role: "model", parts });
    const toolResultParts: any[] = [];
    for (const call of normalizedToolCalls) {
      const { execution } = prepareToolCallExecution(call);
      const { event, toolResult } = await executeToolCallAndBuildEvent(call, execution, params);
      toolEvents.push(event);
      toolResultParts.push(buildFunctionResponsePart(call, toolResult));
    }
    conversation.push({ role: "user", parts: toolResultParts });
  }
  return {
    text: "I reached the tool-call limit while gathering information. Please narrow the request and try again.",
    usage: sawUsage ? usageAcc : undefined,
    raw: { responses: rawResponses, toolCallsUsed: totalToolCalls, toolCallLimitReached: true, api: "gemini.generateContent" },
    toolEvents,
  };
 }
 function findSseBoundary(buffer: string) {
  const crlf = buffer.indexOf("\r\n\r\n");
  const lf = buffer.indexOf("\n\n");
  if (crlf === -1) return lf === -1 ? null : { index: lf, length: 2 };
  if (lf === -1) return { index: crlf, length: 4 };
  return crlf < lf ? { index: crlf, length: 4 } : { index: lf, length: 2 };
 }
 function parseSseEvent(rawEvent: string) {
  const data = rawEvent
    .split(/\r?\n/)
    .filter((line) => line.startsWith("data:"))
    .map((line) => line.slice("data:".length).trimStart())
    .join("\n")
    .trim();
  if (!data || data === "[DONE]") return null;
  return JSON.parse(data);
 }
 async function* streamGeminiResponses(params: ToolAwareCompletionParams, body: Record<string, unknown>) {
  const response = await fetch(geminiUrl(params.client, params.model, "streamGenerateContent", { alt: "sse" }), {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  if (!response.ok) {
    await parseGeminiResponse(response);
    return;
  }
  if (!response.body) {
    throw new Error("Gemini stream response did not include a body.");
  }
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    let boundary = findSseBoundary(buffer);
    while (boundary) {
      const rawEvent = buffer.slice(0, boundary.index);
      buffer = buffer.slice(boundary.index + boundary.length);
      const event = parseSseEvent(rawEvent);
      if (event) yield event;
      boundary = findSseBoundary(buffer);
    }
  }
  buffer += decoder.decode();
  const tail = buffer.trim();
  if (tail) {
    const event = parseSseEvent(tail);
    if (event) yield event;
  }
 }
 export async function* streamWithGeminiApi(params: ToolAwareCompletionParams): AsyncGenerator<ToolAwareStreamingEvent> {
  const enabledTools = getEnabledChatTools(params);
  const conversation = buildBaseContents(params.messages);
  const rawResponses: unknown[] = [];
  const toolEvents: ToolExecutionEvent[] = [];
  const usageAcc: Required<ToolAwareUsage> = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
  let sawUsage = false;
  let totalToolCalls = 0;
  let danglingToolIntentRetries = 0;
  if (!enabledTools.length) {
    let text = "";
    let latestUsage: any = null;
    for await (const response of streamGeminiResponses(params, buildRequest(params, conversation))) {
      rawResponses.push(response);
      if (response?.usageMetadata) latestUsage = response.usageMetadata;
      const failureMessage = getFailureMessage(response, extractText(response), 0);
      if (failureMessage) throw new Error(failureMessage);
      const delta = extractText(response);
      if (delta) {
        text += delta;
        yield { type: "delta", text: delta };
      }
    }
    sawUsage = mergeUsage(usageAcc, latestUsage) || sawUsage;
    yield {
      type: "done",
      result: {
        text,
        usage: sawUsage ? usageAcc : undefined,
        raw: { streamed: true, responses: rawResponses, toolCallsUsed: 0, api: "gemini.streamGenerateContent" },
        toolEvents: [],
      },
    };
    return;
  }
  for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
    const roundParts: any[] = [];
    let roundText = "";
    let latestRoundResponse: any = null;
    let latestRoundUsage: any = null;
    for await (const response of streamGeminiResponses(params, buildRequest(params, conversation, enabledTools))) {
      rawResponses.push(response);
      latestRoundResponse = response;
      if (response?.usageMetadata) latestRoundUsage = response.usageMetadata;
      roundParts.push(...getParts(response));
      roundText += extractText(response);
    }
    sawUsage = mergeUsage(usageAcc, latestRoundUsage) || sawUsage;
    const normalizedToolCalls = normalizeToolCallsFromParts(roundParts, round);
    const failureMessage = getFailureMessage(latestRoundResponse ?? { candidates: [{ content: { parts: roundParts } }] }, roundText, normalizedToolCalls.length);
    if (failureMessage) throw new Error(failureMessage);
    if (!normalizedToolCalls.length) {
      if (danglingToolIntentRetries < MAX_DANGLING_TOOL_INTENT_RETRIES && looksLikeDanglingToolIntent(roundText)) {
        danglingToolIntentRetries += 1;
        appendCorrection(conversation, roundText);
        continue;
      }
      const unstreamedText = getUnstreamedText(roundText, "");
      if (unstreamedText) {
        yield { type: "delta", text: unstreamedText };
      }
      yield {
        type: "done",
        result: {
          text: roundText,
          usage: sawUsage ? usageAcc : undefined,
          raw: { streamed: true, responses: rawResponses, toolCallsUsed: totalToolCalls, api: "gemini.streamGenerateContent" },
          toolEvents,
        },
      };
      return;
    }
    totalToolCalls += normalizedToolCalls.length;
    conversation.push({ role: "model", parts: roundParts });
    const toolResultParts: any[] = [];
    for (const call of normalizedToolCalls) {
      const { event: initiatedEvent, execution } = prepareToolCallExecution(call);
      yield { type: "tool_call", event: initiatedEvent };
      const { event, toolResult } = await executeToolCallAndBuildEvent(call, execution, params);
      toolEvents.push(event);
      yield { type: "tool_call", event };
      toolResultParts.push(buildFunctionResponsePart(call, toolResult));
    }
    conversation.push({ role: "user", parts: toolResultParts });
  }
  yield {
    type: "done",
    result: {
      text: "I reached the tool-call limit while gathering information. Please narrow the request and try again.",
      usage: sawUsage ? usageAcc : undefined,
      raw: {
        streamed: true,
        responses: rawResponses,
        toolCallsUsed: totalToolCalls,
        toolCallLimitReached: true,
        api: "gemini.streamGenerateContent",
      },
      toolEvents,
    },
  };
 }
@@ -28,6 +28,45 @@ import type { ChatMessage } from "../types.js";
 const INTERNAL_CORRECTION =
  "Internal correction: the previous assistant message claimed it would run a tool, but no tool call was made. If the task needs an available tool, call it now. Otherwise provide the final answer directly without saying you will run a tool.";
 const DEFAULT_ANTHROPIC_MAX_TOKENS = 128_000;
 const MODEL_MAX_TOKENS_CACHE_MS = 24 * 60 * 60 * 1000;
 const modelMaxTokensCache = new Map<string, { maxTokens: number; expiresAt: number }>();
 function readMaxTokens(value: unknown) {
  return Number.isSafeInteger(value) && (value as number) > 0 ? (value as number) : undefined;
 }
 function getModelInfoMaxTokens(modelInfo: any) {
  return readMaxTokens(modelInfo?.max_tokens) ?? readMaxTokens(modelInfo?.maxTokens);
 }
 async function getMessagesMaxTokens(params: ToolAwareCompletionParams) {
  if (params.maxTokens) return params.maxTokens;
  const cached = modelMaxTokensCache.get(params.model);
  if (cached && cached.expiresAt > Date.now()) return cached.maxTokens;
  try {
    const retrieve = params.client?.models?.retrieve;
    if (typeof retrieve === "function") {
      const modelInfo = await retrieve.call(params.client.models, params.model);
      const maxTokens = getModelInfoMaxTokens(modelInfo);
      if (maxTokens) {
        modelMaxTokensCache.set(params.model, {
          maxTokens,
          expiresAt: Date.now() + MODEL_MAX_TOKENS_CACHE_MS,
        });
        return maxTokens;
      }
    }
  } catch {
    // Fall back to the documented max for Claude Opus 4.8 and related high-output models.
  }
  return DEFAULT_ANTHROPIC_MAX_TOKENS;
 }
 function toTools(tools: any[]) {
  return tools
    .map((tool) => {
@@ -160,11 +199,12 @@ function mergeUsage(acc: Required<ToolAwareUsage>, usage: any) {
 export async function completeWithMessagesApi(params: ToolAwareCompletionParams): Promise<ToolAwareCompletionResult> {
  const enabledTools = getEnabledChatTools(params);
  const maxTokens = await getMessagesMaxTokens(params);
  if (!enabledTools.length) {
    const response = await params.client.messages.create({
      model: params.model,
      system: buildTopLevelSystemPrompt(params.messages, params.userLocation),
-      max_tokens: params.maxTokens ?? 1024,
+      max_tokens: maxTokens,
      temperature: params.temperature,
      messages: buildBaseMessages(params),
    } as any);
@@ -192,7 +232,7 @@ export async function completeWithMessagesApi(params: ToolAwareCompletionParams)
    const response = await params.client.messages.create({
      model: params.model,
      system: buildTopLevelSystemPrompt(params.messages, params.userLocation, buildChatToolSystemPrompt(params)),
-      max_tokens: params.maxTokens ?? 1024,
+      max_tokens: maxTokens,
      temperature: params.temperature,
      messages: conversation,
      tools: toTools(enabledTools),
@@ -248,6 +288,7 @@ export async function completeWithMessagesApi(params: ToolAwareCompletionParams)
 export async function* streamWithMessagesApi(params: ToolAwareCompletionParams): AsyncGenerator<ToolAwareStreamingEvent> {
  const enabledTools = getEnabledChatTools(params);
  const maxTokens = await getMessagesMaxTokens(params);
  if (!enabledTools.length) {
    const rawResponses: unknown[] = [];
    const usageAcc: Required<ToolAwareUsage> = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
@@ -259,7 +300,7 @@ export async function* streamWithMessagesApi(params: ToolAwareCompletionParams):
    const stream = await params.client.messages.create({
      model: params.model,
      system: buildTopLevelSystemPrompt(params.messages, params.userLocation),
-      max_tokens: params.maxTokens ?? 1024,
+      max_tokens: maxTokens,
      temperature: params.temperature,
      messages: buildBaseMessages(params),
      stream: true,
@@ -315,7 +356,7 @@ export async function* streamWithMessagesApi(params: ToolAwareCompletionParams):
    const stream = await params.client.messages.create({
      model: params.model,
      system: buildTopLevelSystemPrompt(params.messages, params.userLocation, buildChatToolSystemPrompt(params)),
-      max_tokens: params.maxTokens ?? 1024,
+      max_tokens: maxTokens,
      temperature: params.temperature,
      messages: conversation,
      tools: toTools(enabledTools),
@@ -5,10 +5,11 @@ import {
  type ToolAwareStreamingEvent,
 } from "./chat-tools.js";
 import { completeWithChatCompletionsApi, streamWithChatCompletionsApi } from "./protocols/chat-completions-api.js";
 import { completeWithGeminiApi, streamWithGeminiApi } from "./protocols/gemini-api.js";
 import { completeWithMessagesApi, streamWithMessagesApi } from "./protocols/messages-api.js";
 import { completeWithResponsesApi, streamWithResponsesApi } from "./protocols/responses-api.js";
 import { env } from "../env.js";
-import { anthropicClient, hermesAgentClient, isHermesAgentConfigured, openaiClient, xaiClient } from "./providers.js";
+import { anthropicClient, geminiClient, hermesAgentClient, isHermesAgentConfigured, openaiClient, xaiClient } from "./providers.js";
 import type { ChatMessage, Provider } from "./types.js";
 type ProviderAdapterParams = {
@@ -27,7 +28,7 @@ export type ProviderChatAdapter = {
  stream(params: ProviderAdapterParams): AsyncGenerator<ToolAwareStreamingEvent>;
 };
-type ChatProtocolId = "chat-completions" | "messages" | "responses";
+type ChatProtocolId = "chat-completions" | "gemini" | "messages" | "responses";
 type ChatProtocol = {
  id: ChatProtocolId;
@@ -39,6 +40,7 @@ type ModelCatalogSpec = {
  enabled?: () => boolean;
  fetchModels(client: any): Promise<string[]>;
  fallbackModels?: () => string[];
  sortModels?: (models: string[]) => string[];
 };
 type ProviderBackendSpec = {
@@ -61,6 +63,12 @@ const messagesProtocol: ChatProtocol = {
  stream: streamWithMessagesApi,
 };
 const geminiProtocol: ChatProtocol = {
  id: "gemini",
  complete: completeWithGeminiApi,
  stream: streamWithGeminiApi,
 };
 const responsesProtocol: ChatProtocol = {
  id: "responses",
  complete: completeWithResponsesApi,
@@ -77,6 +85,10 @@ function modelIdsFromListResponse(page: any) {
    : [];
 }
 function stripModelResourcePrefix(model: string) {
  return model.startsWith("models/") ? model.slice("models/".length) : model;
 }
 function isLikelyResponsesApiModel(model: string) {
  const id = model.toLowerCase();
  if (id.includes("embedding") || id.includes("moderation")) return false;
@@ -86,6 +98,37 @@ function isLikelyResponsesApiModel(model: string) {
  return /^(gpt-|o\d|chatgpt-)/.test(id);
 }
 function isLikelyGeminiChatModel(model: string) {
  const id = model.toLowerCase();
  if (!id.startsWith("gemini-")) return false;
  if (id.includes("embedding") || id.includes("embed")) return false;
  if (id.includes("image") || id.includes("imagen") || id.includes("veo")) return false;
  if (id.includes("audio") || id.includes("tts") || id.includes("live")) return false;
  if (id.includes("computer-use") || id.includes("robotics")) return false;
  return true;
 }
 function preferGeminiModels(models: string[]) {
  const preferred = [
    "gemini-3.5-flash",
    "gemini-flash-latest",
    "gemini-3.1-flash-lite",
    "gemini-3-flash-preview",
    "gemini-pro-latest",
  ];
  const modelSet = new Set(models);
  return [...preferred.filter((model) => modelSet.delete(model)), ...[...modelSet].sort((a, b) => a.localeCompare(b))];
 }
 async function fetchJson(url: URL): Promise<any> {
  const response = await fetch(url);
  const body: any = await response.json().catch(() => null);
  if (!response.ok) {
    throw new Error(body?.error?.message ?? `Gemini model fetch failed with status ${response.status}.`);
  }
  return body;
 }
 function withClient(params: ProviderAdapterParams, client: any, enabledTools?: string[]): ToolAwareCompletionParams {
  return {
    client,
@@ -160,6 +203,29 @@ const backendSpecs: Record<Provider, ProviderBackendSpec> = {
      },
    },
  },
  gemini: {
    createClient: geminiClient,
    plainProtocol: geminiProtocol,
    toolProtocol: geminiProtocol,
    managedTools: true,
    modelCatalog: {
      async fetchModels(client) {
        const url = new URL(`${client.baseURL.replace(/\/+$/, "")}/models`);
        url.searchParams.set("key", client.apiKey);
        url.searchParams.set("pageSize", "1000");
        const page = await fetchJson(url);
        return Array.isArray(page?.models)
          ? page.models
              .filter((model: any) => Array.isArray(model?.supportedGenerationMethods) && model.supportedGenerationMethods.includes("generateContent"))
              .map((model: any) => model?.name)
              .filter((id: unknown): id is string => typeof id === "string")
              .map(stripModelResourcePrefix)
              .filter(isLikelyGeminiChatModel)
          : [];
      },
      sortModels: preferGeminiModels,
    },
  },
  "hermes-agent": {
    createClient: hermesAgentClient,
    plainProtocol: chatCompletionsProtocol,
@@ -209,7 +275,8 @@ export function listModelCatalogProviders(): Provider[] {
 export async function fetchProviderCatalogModels(provider: Provider) {
  const spec = backendSpecs[provider].modelCatalog;
  if (!spec) return [];
-  return uniqSorted(await spec.fetchModels(backendSpecs[provider].createClient()));
+  const models = uniqSorted(await spec.fetchModels(backendSpecs[provider].createClient()));
  return spec.sortModels ? spec.sortModels(models) : models;
 }
 export function getProviderCatalogFallbackModels(provider: Provider) {
@@ -6,6 +6,7 @@ const apiToPrismaProvider = {
  openai: "openai",
  anthropic: "anthropic",
  xai: "xai",
  gemini: "gemini",
  "hermes-agent": "hermes_agent",
 } as const satisfies Record<Provider, PrismaProvider>;
@@ -13,6 +14,7 @@ const prismaToApiProvider = {
  openai: "openai",
  anthropic: "anthropic",
  xai: "xai",
  gemini: "gemini",
  hermes_agent: "hermes-agent",
  "hermes-agent": "hermes-agent",
 } as const satisfies Record<PrismaProvider | "hermes-agent", Provider>;
@@ -1,5 +1,5 @@
 import OpenAI from "openai";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
 import { env } from "../env.js";
 export function openaiClient() {
@@ -13,6 +13,14 @@ export function xaiClient() {
  return new OpenAI({ apiKey: env.XAI_API_KEY, baseURL: "https://api.x.ai/v1" });
 }
 export function geminiClient() {
  if (!env.GEMINI_API_KEY) throw new Error("GEMINI_API_KEY not set");
  return {
    apiKey: env.GEMINI_API_KEY,
    baseURL: "https://generativelanguage.googleapis.com/v1beta",
  };
 }
 export function isHermesAgentConfigured() {
  return Boolean(env.HERMES_AGENT_API_KEY);
 }
@@ -1,4 +1,4 @@
-export const PROVIDERS = ["openai", "anthropic", "xai", "hermes-agent"] as const;
+export const PROVIDERS = ["openai", "anthropic", "xai", "gemini", "hermes-agent"] as const;
 export type Provider = (typeof PROVIDERS)[number];
@@ -16,7 +16,7 @@ import { exaClient } from "./search/exa.js";
 import { isFreshSearchCacheHit, normalizeSearchQuery } from "./search-cache.js";
 import type { ChatAttachment } from "./llm/types.js";
-const ProviderSchema = z.enum(["openai", "anthropic", "xai", "hermes-agent"]);
+const ProviderSchema = z.enum(["openai", "anthropic", "xai", "gemini", "hermes-agent"]);
 const MAX_ADDITIONAL_SYSTEM_PROMPT_CHARS = 12_000;
 const EnabledToolsSchema = z.array(z.string().trim().min(1).max(80)).max(20).transform((value) => normalizeEnabledChatTools(value));
@@ -140,6 +140,94 @@ test("plain Chat Completions stream does not send Sybil-managed tools", async ()
  assert.equal(events.at(-1)?.type === "done" ? events.at(-1)?.result.text : null, "Hi");
 });
 test("Messages API defaults max_tokens to the Anthropic model maximum", async () => {
  let requestBody: any = null;
  let retrievedModel: string | null = null;
  const client = {
    models: {
      retrieve: async (model: string) => {
        retrievedModel = model;
        return { id: model, max_tokens: 128000 };
      },
    },
    messages: {
      create: async (body: any) => {
        requestBody = body;
        return {
          content: [{ type: "text", text: "Done" }],
          usage: { input_tokens: 1, output_tokens: 1 },
        };
      },
    },
  };
  const result = await completeWithMessagesApi({
    client: client as any,
    model: "claude-max-default-test",
    messages: [{ role: "user", content: "Say done" }],
  });
  assert.equal(retrievedModel, "claude-max-default-test");
  assert.equal(requestBody?.max_tokens, 128000);
  assert.equal(result.text, "Done");
 });
 test("Messages API preserves explicit maxTokens", async () => {
  let requestBody: any = null;
  let didRetrieveModel = false;
  const client = {
    models: {
      retrieve: async () => {
        didRetrieveModel = true;
        return { max_tokens: 128000 };
      },
    },
    messages: {
      create: async (body: any) => {
        requestBody = body;
        return streamFrom([
          {
            type: "message_start",
            message: {
              usage: { input_tokens: 1, output_tokens: 0 },
            },
          },
          {
            type: "content_block_start",
            index: 0,
            content_block: { type: "text", text: "" },
          },
          {
            type: "content_block_delta",
            index: 0,
            delta: { type: "text_delta", text: "Done" },
          },
          { type: "content_block_stop", index: 0 },
          {
            type: "message_delta",
            delta: { stop_reason: "end_turn", stop_sequence: null },
            usage: { output_tokens: 1 },
          },
          { type: "message_stop" },
        ]);
      },
    },
  };
  const events = await collectEvents(
    streamWithMessagesApi({
      client: client as any,
      model: "claude-explicit-max-test",
      messages: [{ role: "user", content: "Say done" }],
      maxTokens: 4096,
    })
  );
  assert.equal(didRetrieveModel, false);
  assert.equal(requestBody?.max_tokens, 4096);
  assert.equal(events.at(-1)?.type === "done" ? events.at(-1)?.result.text : null, "Done");
 });
 test("fetch_url sends browser-like navigation headers", async () => {
  const originalFetch = globalThis.fetch;
  const fetchCalls: Array<{ input: RequestInfo | URL; init?: RequestInit }> = [];
@@ -27,6 +27,12 @@ test("provider backend registry selects chat protocol and managed-tool mode", ()
    managedTools: true,
    enabledTools: ["web_search"],
  });
  assert.deepEqual(describeProviderChatBackend("gemini", ["web_search"]), {
    provider: "gemini",
    protocol: "gemini",
    managedTools: true,
    enabledTools: ["web_search"],
  });
  assert.deepEqual(describeProviderChatBackend("hermes-agent", ["web_search"]), {
    provider: "hermes-agent",
    protocol: "chat-completions",
@@ -5,8 +5,10 @@ import { fromPrismaProvider, serializeProviderFields, toPrismaProvider } from ".
 test("Hermes Agent provider id maps between API and Prisma enum forms", () => {
  assert.equal(toPrismaProvider("hermes-agent"), "hermes_agent");
  assert.equal(fromPrismaProvider("hermes_agent"), "hermes-agent");
-  assert.deepEqual(serializeProviderFields({ initiatedProvider: "hermes_agent", lastUsedProvider: "xai" }), {
+  assert.equal(toPrismaProvider("gemini"), "gemini");
  assert.equal(fromPrismaProvider("gemini"), "gemini");
  assert.deepEqual(serializeProviderFields({ initiatedProvider: "hermes_agent", lastUsedProvider: "gemini" }), {
    initiatedProvider: "hermes-agent",
-    lastUsedProvider: "xai",
+    lastUsedProvider: "gemini",
  });
 });
@@ -1,6 +1,6 @@
 import type { Provider } from "./types.js";
-const PROVIDERS: Provider[] = ["openai", "anthropic", "xai", "hermes-agent"];
+const PROVIDERS: Provider[] = ["openai", "anthropic", "xai", "gemini", "hermes-agent"];
 function normalizeBaseUrl(value: string) {
  const trimmed = value.trim();
@@ -42,12 +42,13 @@ type ToolLogMetadata = {
  resultPreview?: string | null;
 };
-const BASE_PROVIDERS: Provider[] = ["openai", "anthropic", "xai"];
+const BASE_PROVIDERS: Provider[] = ["openai", "anthropic", "xai", "gemini"];
 const PROVIDERS: Provider[] = [...BASE_PROVIDERS, "hermes-agent"];
 const PROVIDER_FALLBACK_MODELS: Record<Provider, string[]> = {
  openai: ["gpt-4.1-mini"],
  anthropic: ["claude-3-5-sonnet-latest"],
  xai: ["grok-3-mini"],
  gemini: ["gemini-3.5-flash", "gemini-flash-latest"],
  "hermes-agent": ["hermes-agent"],
 };
@@ -55,6 +56,7 @@ const EMPTY_MODEL_CATALOG: ModelCatalogResponse["providers"] = {
  openai: { models: [], loadedAt: null, error: null },
  anthropic: { models: [], loadedAt: null, error: null },
  xai: { models: [], loadedAt: null, error: null },
  gemini: { models: [], loadedAt: null, error: null },
 };
 function escapeTags(value: string) {
@@ -79,6 +81,7 @@ function getProviderLabel(provider: Provider | null | undefined) {
  if (provider === "openai") return "OpenAI";
  if (provider === "anthropic") return "Anthropic";
  if (provider === "xai") return "xAI";
  if (provider === "gemini") return "Gemini";
  if (provider === "hermes-agent") return "Hermes Agent";
  return "";
 }
@@ -266,6 +269,7 @@ async function main() {
    openai: null,
    anthropic: null,
    xai: null,
    gemini: null,
    "hermes-agent": null,
  };
  let model: string = config.defaultModel ?? pickProviderModel(getModelOptions(modelCatalog, provider), null);
@@ -1,4 +1,4 @@
-export type Provider = "openai" | "anthropic" | "xai" | "hermes-agent";
+export type Provider = "openai" | "anthropic" | "xai" | "gemini" | "hermes-agent";
 export type ProviderModelInfo = {
  models: string[];
@@ -123,6 +123,7 @@ const PROVIDER_FALLBACK_MODELS: Record<Provider, string[]> = {
  openai: ["gpt-4.1-mini"],
  anthropic: ["claude-3-5-sonnet-latest"],
  xai: ["grok-3-mini"],
  gemini: ["gemini-3.5-flash", "gemini-flash-latest"],
  "hermes-agent": ["hermes-agent"],
 };
@@ -130,9 +131,10 @@ const EMPTY_MODEL_CATALOG: ModelCatalogResponse["providers"] = {
  openai: { models: [], loadedAt: null, error: null },
  anthropic: { models: [], loadedAt: null, error: null },
  xai: { models: [], loadedAt: null, error: null },
  gemini: { models: [], loadedAt: null, error: null },
 };
-const BASE_PROVIDERS: Provider[] = ["openai", "anthropic", "xai"];
+const BASE_PROVIDERS: Provider[] = ["openai", "anthropic", "xai", "gemini"];
 const ALL_PROVIDERS: Provider[] = [...BASE_PROVIDERS, "hermes-agent"];
 const MODEL_PREFERENCES_STORAGE_KEY = "sybil:modelPreferencesByProvider";
@@ -149,6 +151,7 @@ const EMPTY_MODEL_PREFERENCES: ProviderModelPreferences = {
  openai: null,
  anthropic: null,
  xai: null,
  gemini: null,
  "hermes-agent": null,
 };
 const EMPTY_ACTIVE_RUNS: ActiveRunsState = {
@@ -345,6 +348,7 @@ function loadStoredModelPreferences() {
      openai: typeof parsed.openai === "string" && parsed.openai.trim() ? parsed.openai.trim() : null,
      anthropic: typeof parsed.anthropic === "string" && parsed.anthropic.trim() ? parsed.anthropic.trim() : null,
      xai: typeof parsed.xai === "string" && parsed.xai.trim() ? parsed.xai.trim() : null,
      gemini: typeof parsed.gemini === "string" && parsed.gemini.trim() ? parsed.gemini.trim() : null,
      "hermes-agent":
        typeof parsed["hermes-agent"] === "string" && parsed["hermes-agent"].trim() ? parsed["hermes-agent"].trim() : null,
    };
@@ -354,7 +358,9 @@ function loadStoredModelPreferences() {
 }
 function normalizeStoredProvider(value: unknown): Provider {
-  return value === "anthropic" || value === "xai" || value === "openai" || value === "hermes-agent" ? value : "openai";
+  return value === "anthropic" || value === "xai" || value === "gemini" || value === "openai" || value === "hermes-agent"
    ? value
    : "openai";
 }
 function normalizeStoredModelPreferences(value: unknown): ProviderModelPreferences {
@@ -364,6 +370,7 @@ function normalizeStoredModelPreferences(value: unknown): ProviderModelPreferenc
      openai: typeof parsed.openai === "string" && parsed.openai.trim() ? parsed.openai.trim() : null,
      anthropic: typeof parsed.anthropic === "string" && parsed.anthropic.trim() ? parsed.anthropic.trim() : null,
      xai: typeof parsed.xai === "string" && parsed.xai.trim() ? parsed.xai.trim() : null,
      gemini: typeof parsed.gemini === "string" && parsed.gemini.trim() ? parsed.gemini.trim() : null,
      "hermes-agent":
        typeof parsed["hermes-agent"] === "string" && parsed["hermes-agent"].trim() ? parsed["hermes-agent"].trim() : null,
    };
@@ -395,6 +402,7 @@ function getProviderLabel(provider: Provider | null | undefined) {
  if (provider === "openai") return "OpenAI";
  if (provider === "anthropic") return "Anthropic";
  if (provider === "xai") return "xAI";
  if (provider === "gemini") return "Gemini";
  if (provider === "hermes-agent") return "Hermes Agent";
  return "";
 }
@@ -286,6 +286,14 @@ textarea {
  word-break: break-word;
 }
 .md-content > :first-child {
  margin-top: 0;
 }
 .md-content > :last-child {
  margin-bottom: 0;
 }
 .md-table-scroll {
  max-width: 100%;
  margin: 0.35rem 0 1rem;
@@ -384,7 +392,8 @@ textarea {
 .md-content ul,
 .md-content ol {
-  margin-top: 0.65rem;
+  margin-top: 0.85rem;
  margin-bottom: 0.85rem;
  margin-left: 0;
  padding-left: 0;
  list-style: none;
@@ -396,6 +405,26 @@ textarea {
  padding-left: 1.35rem;
 }
 .md-content ul > li {
  position: relative;
  padding-left: 1.1rem;
 }
 .md-content ul > li::before {
  content: "";
  position: absolute;
  left: 0;
  top: 0.76em;
  width: 0.36rem;
  height: 0.36rem;
  border-radius: 9999px;
  background: hsl(188 86% 62%);
  box-shadow:
    0 0 0 2px hsl(188 86% 62% / 0.12),
    0 0 10px hsl(188 86% 62% / 0.42);
  transform: translateY(-50%);
 }
 .md-content li + li {
  margin-top: 0.3rem;
 }
@@ -149,7 +149,7 @@ export type CompletionRequestMessage = {
  attachments?: ChatAttachment[];
 };
-export type Provider = "openai" | "anthropic" | "xai" | "hermes-agent";
+export type Provider = "openai" | "anthropic" | "xai" | "gemini" | "hermes-agent";
 export type ProviderModelInfo = {
  models: string[];
Author	SHA1	Message	Date
buzzert	622659f6ca	ios: preserve chat scroll position on resume TestFlight / testflight (push) Successful in 1m46s Details	2026-07-12 13:57:45 -07:00
buzzert	93ca8a76c3	adds gemini support TestFlight / testflight (push) Successful in 1m53s Details	2026-07-11 14:16:21 -07:00
buzzertandClaude Fable 5	69f50064a3	ci: restore Ruby PATH export for fastlane step TestFlight / testflight (push) Successful in 1m58s Details act_runner does not carry setup-ruby's PATH changes into later steps, so without this the step runs the toolcache default Ruby (3.3.11) and bundler cannot find the gems installed for 3.1.7. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-11 13:04:47 -07:00
buzzertandClaude Fable 5	e7b81f24bd	ci: put CI keychain first in codesign search list TestFlight / testflight (push) Failing after 19s Details codesign resolves signing identities through the user keychain search list (first match wins) and ignores --keychain for the lookup. This runner hosts another project whose keychain holds the same Apple Distribution identity, so when that keychain is locked, codesign fails with errSecInternalComponent no matter how correctly our own keychain is set up. Prepend the fresh CI keychain to the search list for the build and always delete it afterward, which restores the original list. Also drop the runner-diagnostics step, the GitHub-hosted Ruby PATH export, and the duplicate CODE_SIGN_IDENTITY param. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-11 13:01:42 -07:00
buzzert	20a310a4b1	ci: use Ruby 3.1 for TestFlight upload TestFlight / testflight (push) Failing after 46s Details	2026-07-11 12:01:27 -07:00
buzzert	b6859706db	ios: simplify CI signing keychain setup TestFlight / testflight (push) Failing after 25s Details	2026-07-11 11:55:04 -07:00
buzzert	ea148839d3	Revert "ios: pass match keychain to codesign" This reverts commit `a0e410155d`.	2026-07-11 11:32:00 -07:00
buzzert	a0e410155d	ios: pass match keychain to codesign TestFlight / testflight (push) Failing after 55s Details	2026-07-11 11:29:10 -07:00
buzzert	b5a5d21767	docs: document iOS release workflow	2026-07-11 11:17:05 -07:00
buzzert	0ad96f4f99	ios: center transcript content on iPad TestFlight / testflight (push) Failing after 52s Details	2026-07-11 11:15:01 -07:00
buzzert	b0c2b74c16	remove temporary keychain (unneeded) TestFlight / testflight (push) Successful in 1m46s Details	2026-07-06 09:25:24 -07:00
buzzert	14d2d8cb28	fix spacing between lists and paragraphs	2026-07-05 19:54:34 -07:00
buzzert	03836bbc4c	Raise Anthropic default max tokens	2026-07-05 11:53:17 -07:00
buzzert	76ce62025a	bullets in ul	2026-07-04 20:22:13 -07:00
buzzert	b15473d24e	ios: stamp release version into XcodeGen spec TestFlight / testflight (push) Successful in 1m43s Details	2026-06-26 01:29:54 -07:00
buzzert	a512a65844	ios: accept release tag namespace in Fastfile TestFlight / testflight (push) Successful in 1m55s Details	2026-06-26 01:18:02 -07:00
buzzert	207b44f67f	ios: ci: actually `release/ios/v*`. TestFlight / testflight (push) Failing after 19s Details	2026-06-26 01:15:08 -07:00
buzzert	c5ccd212c9	ios: ci: testflight only on release/v* TestFlight / testflight (push) Successful in 1m55s Details	2026-06-26 01:08:47 -07:00
buzzertandClaude Opus 4.8	ee990dde5d	ios: simplify Fastfile signing now that the runner has a real session With SessionCreate on the runner's launchd job, standard fastlane keychain handling works, so drop the debugging-era workarounds: the manual default-keychain / list-keychains search-list juggling, the login-keychain restoration in cleanup, the verify_ci_signing re-unlock/partition/find-identity step (match already imports the cert and sets the key partition list), and the CODE_SIGN_KEYCHAIN / OTHER_CODE_SIGN_FLAGS xcargs. CI signing is now a single create_keychain + match. No behavior change; validated end-to-end on TestFlight. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 00:52:36 -07:00
buzzertandClaude Opus 4.8	036743fe41	ios: source TestFlight build number from CI run number TestFlight / testflight (push) Successful in 1m53s Details App Store Connect requires CFBundleVersion to be unique and strictly increasing app-wide. latest_testflight_build_number could return a stale value (it missed an existing build 13) and produced colliding build numbers, 409-ing every upload. Use the monotonic Gitea run number (github.run_number -> SYBIL_BUILD_NUMBER) instead. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 00:41:37 -07:00
buzzertandClaude Opus 4.8	4e7ea7ab68	ios: get TestFlight CI signing working TestFlight / testflight (push) Failing after 57s Details Replace the old testflight-release workflow with a single `testflight.yml` Gitea Actions workflow and rework the fastlane `beta` lane: match-based app-store signing into a disposable CI keychain, XcodeGen project generation, version/build-number bumping, and upload to TestFlight. Pin Ruby to 3.1.7 for the runner. Squashes the iterative CI signing debugging history into one commit. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 00:28:27 -07:00
`@@ -1,3 +1,3 @@`
	`source "https://rubygems.org"`	`source "https://rubygems.org"`

	`gem "fastlane", "~> 2.227"`	`gem "fastlane"`
`@@ -1,4 +1,4 @@`
	`export const PROVIDERS = ["openai", "anthropic", "xai", "hermes-agent"] as const;`	`export const PROVIDERS = ["openai", "anthropic", "xai", "gemini", "hermes-agent"] as const;`

	`export type Provider = (typeof PROVIDERS)[number];`	`export type Provider = (typeof PROVIDERS)[number];`