@tekmidian/pai 0.48.0 → 0.50.0

package/docs/workers-config.md

@@ -2,26 +2,33 @@
 
 One hand-editable file: which providers PAI can run workers on, the model
 each provider uses per role, and which provider every `--class` goes to.
-Before this, that lived inside `~/.config/pai/config.json`'s `workers`
+Before this, that lived inside `~/.claude/pai/config.json`'s `workers`
 section — JSON, unrelated to the rest of that file, and undocumented in
 place. Adding a provider meant reading code to find out what fields existed.
 
 ## Where it lives
 
 `~/.claude/pai/workers.yaml` — under the PAI_HOME namespace dir, beside
-PAI's other per-user files (`config.json`, `whisper-rules.md`,
+PAI's other per-user files (`config.yaml`, `whisper-rules.md`,
 `advisor-mode.json`), so nothing PAI writes can collide with a file Claude
 Code itself introduces under `~/.claude`. Set `PAI_WORKERS_YAML=<path>` to
 override this — tests and power users only, and `PAI_HOME=<dir>` to move
 the whole namespace. Only providers, model roles, class routing and MCP
 sets live here. Everything else worker-related — the follow-pane profile,
 log dir, routing cooldown, sub-worker caps, cache-keepalive cadence, the
-machine-wide fallback switch — stays in `config.json`'s `workers` section;
+machine-wide fallback switch — stays in `config.yaml` (or `config.json` until you run `pai config yaml`)'s `workers` section;
 none of it is provider-specific enough to want hand comments.
 
 This file is per-user state: it can hold API keys (`key:`, below), is kept
 mode 0600, and is never committed or shared.
 
+The non-provider settings mentioned above — `pane`, `routing`, `tree`,
+`cacheKeepaliveSecs`, `logDir`, the machine-wide fallback switch — live in
+the main PAI config instead, under its `workers` section: see
+[docs/config.md](config.md) for `config.yaml`'s layout and `pai config
+get workers.cacheKeepaliveSecs` / `pai config set workers.pane.rows 40`
+style access.
+
 Before 2026-09-19 it lived at `~/.config/pai/workers.yaml`, and briefly at
 `~/.claude/workers.yaml` in between. If yours is still at either old
 location, `pai worker config check` and `pai worker providers` say so;
@@ -65,6 +72,18 @@ providers:
       default: k3[1m]
       fast: kimi-for-coding[1m]
 
+# An `engine: image` provider does not spawn Claude — `pai worker run
+# --capability image` POSTs straight to its OpenAI-compatible images API and
+# writes the PNG it gets back. Uncomment and point it at a real provider
+# (still nested under providers:, above) to enable `--capability image`:
+#   pictures:
+#     engine: image
+#     url: https://api.example.com/v1
+#     key: "<your-api-key>"
+#     models:
+#       default: example-image-model
+#       image: example-image-model
+
 # A class names a provider, or provider/role to pick a non-default model.
 # Workers exist to parallelise and to save cost: the default is Sonnet,
 # Haiku for the mechanical classes, and nothing here inherits the
@@ -80,6 +99,13 @@ classes:
   simple: anthropic/fast
   image: glm/image
 
+# Cross-provider capability preference: which provider serves a --capability
+# request, in order, when more than one declares it. Unlisted capabilities
+# fall back to the active provider, then any provider that declares them.
+# capabilities:
+#   image: [pictures, glm]
+#   fast: [anthropic]
+
 mcp_sets:
   desktop: [clickr]
 ```
@@ -107,8 +133,10 @@ init` writes on a machine with no workers.yaml yet.
 - **`providers.<name>.tier`** — cost/quality tier, 1 (cheapest) … 5 (most
   expensive), default 3. Classes can constrain auto-routing to a max tier.
 - **`providers.<name>.models`** — model id per capability. `default` is
-  required; `fast` and `image` are optional and fall back to `default` when
-  a class asks for them and the provider has none.
+  required; every other name is open (`fast`, `image`, or a name of your own
+  choosing, matching `^[a-z][a-z0-9-]*$`) and falls back to `default` when a
+  class or run asks for it and the provider has none — see "Capabilities"
+  below.
 - **`classes.<name>`** — `provider` or `provider/role` (`role` one of
   `default`, `fast`, `image`). An object form
   (`{provider, mcp, maxCostTier, requireTags, order}`) is also accepted for
@@ -123,10 +151,75 @@ Not in the starter, but read when present (same names `pai worker providers
 add` accepts, snake_cased): `enabled: false` (skip in auto-routing without
 deleting the entry), `protocol: openai` + `upstream_url` (routes through the
 built-in Anthropic↔OpenAI proxy), `engine: codex` (runs the provider on the
-Codex CLI instead of Claude Code), `env` (extra environment for runs through
-this provider), `note` (shown in `pai worker providers`), `quota_probe` +
-`quota_skip_at`, `context_window`, `tags`, `usage`, `model_tiers`. Full field
-semantics: `src/workers/config.ts`.
+Codex CLI instead of Claude Code) or `engine: image` (see "Capabilities"
+below), `env` (extra environment for runs through this provider), `note`
+(shown in `pai worker providers`), `quota_probe` + `quota_skip_at`,
+`context_window`, `tags`, `usage`, `model_tiers`. Full field semantics:
+`src/workers/config.ts`.
+
+## Capabilities
+
+A provider's `models` table (above) picks a model *within* that provider —
+`glm/image` runs on whatever `glm.models.image` names. The top-level
+`capabilities:` map instead picks *which provider* serves a capability at
+all, across the whole config:
+
+```yaml
+capabilities:
+  image: [pictures, glm]   # first usable one wins
+  fast: [anthropic]
+```
+
+`pai worker run --capability image -p '<prompt>'` (alias `--for`) resolves
+through this list: the first entry that is enabled, declares an `image`
+model, and passes the same runnable checks as any other provider. A `--class`
+whose implied capability is not `default` (e.g. a class named `image` with no
+provider of its own) resolves the same way; a class already pinned to a
+provider (`image: glm/image`, the starter default) is unaffected — it always
+runs that provider unchanged. An explicit `--provider` always wins over both.
+
+Without a `capabilities:` entry, resolution falls back to the active
+provider (if it declares the capability), then any provider that declares it
+(stable order). If nothing anywhere does, the run refuses to guess: it
+errors naming the config key to set, rather than silently running a normal
+model on a prompt it cannot answer. `pai worker capability` (no args) lists
+every preference and what it resolves to right now; `describeCapabilities`
+truthfully reports "unresolved" or "fallback" in the same situation without
+throwing, so listing your config never fails just because you have not
+finished it.
+
+### The image engine
+
+A provider with `engine: image` (see the commented `pictures:` example
+above) does not spawn Claude Code at all. `pai worker run --capability
+image -p "<prompt>" [--size WxH] [--out <file>]` POSTs one
+OpenAI-compatible request straight to `{url}/images/generations`:
+
+```json
+{"model": "<the resolved model>", "prompt": "<prompt>", "size": "1024x1024", "n": 1, "response_format": "b64_json"}
+```
+
+...decodes the base64 PNG it gets back, and writes it to `--out` (default:
+`<logDir>/<worker-id>.png`). No worktree, no MCP, no follow pane — one
+request, one file. stdout is the same JSON shape `pai worker run` always
+prints for a headless run: `{ok, path, model, provider, durationMs, bytes}`.
+Asking a `claude`/`codex`-engine provider to run `--capability image` is not
+an error by itself — it just means no image-generating provider is
+configured, which the "nothing anywhere does" case above already reports
+clearly.
+
+CLI and MCP agree on the same preferences:
+
+```
+pai worker capability                       # list every preference
+pai worker capability image pictures,glm    # set (first usable wins)
+pai worker capability image --unset         # remove it
+```
+
+The `worker_capability` MCP tool takes the same `action: list|set|unset`,
+`capability`, `providers` shape; `worker_run`'s `capability` field and
+`worker_model`'s `capability` field (now an open set, not just `default` /
+`fast` / `image`) round out the chat-side surface.
 
 ## Provider protocol shapes
 
@@ -311,7 +404,7 @@ that resolves `anthropic` or `anthropic/fast` picks up the override.
    all come from here, validated as a whole (an unknown provider named by a
    class is a load error naming the file and line, not a spawn-time
    surprise).
-2. Else the JSON `workers` section in `config.json` (`providers`, `classes`
+2. Else the JSON `workers` section in `config.json` (or `config.yaml` if it exists) (`providers`, `classes`
    — or the pre-rename `roles` — `mcpSets`, `active`), unchanged from
    before this file existed. Nothing breaks on a machine that has not
    migrated yet.
@@ -346,7 +439,7 @@ pai worker config inline-keys # move every key_file's contents inline as key: (q
 - **no workers.yaml yet**: reads the JSON `workers` section, writes
   workers.yaml with the same header/section comments as the starter, backs
   the pre-migration JSON section up to `workers.json.migrated-<date>` next
-  to `config.json`, and strips `providers`/`classes`/`roles`/`mcpSets`/
+  to `config.json` (or `config.yaml` if it exists), and strips `providers`/`classes`/`roles`/`mcpSets`/
   `active` from the JSON (everything else in that section — pane, log dir,
   routing, tree, cache-keepalive, fallback — stays).
 
@@ -363,7 +456,7 @@ writing anything.
 
 PAI is not a Claude Code plugin — it is a self-contained system that Claude
 Code happens to be the first harness for. `~/.claude/pai/` (`PAI_HOME`) is
-the single home for everything PAI owns: `config.json`, `workers.yaml`,
+the single home for everything PAI owns: `config.yaml`, `workers.yaml`,
 `whisper-rules.md`, `advisor-mode.json`, `session-state/`, `queries/`,
 `logs/workers/` and the rest of PAI's per-user state and caches. `pai config
 path` prints where every one of these currently resolves to; `pai config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekmidian/pai",
-  "version": "0.48.0",
+  "version": "0.50.0",
   "description": "PAI Knowledge OS — Personal AI Infrastructure with federated memory and project management",
   "type": "module",
   "main": "dist/index.mjs",

package/src/hooks/ts/capture-all-events.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Tests for capture-all-events hook
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFileSync, writeFileSync, rmSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('capture-all-events: agent-sessions.json hardening', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // Create a temporary directory for each test
+    tempDir = join(tmpdir(), `test-agent-sessions-${Date.now()}-${Math.random()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    // Clean up temp directory
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('setAgentForSession recovers from corrupt JSON file', async () => {
+    // Import the functions dynamically to inject our test path
+    const sessionFile = join(tempDir, 'agent-sessions.json');
+
+    // Create a corrupt JSON file (truncated in the middle of a string)
+    writeFileSync(sessionFile, '{"session1": "pai", "session2": "designer", "session3": "un');
+
+    // Now simulate setAgentForSession behavior: read the file, handle parse error, write fresh map
+    let mappings: Record<string, string> = {};
+    try {
+      mappings = JSON.parse(readFileSync(sessionFile, 'utf-8'));
+    } catch {
+      // If file exists but is corrupt, start fresh
+      mappings = {};
+    }
+
+    mappings['session4'] = 'researcher';
+
+    // Write with atomic helper would succeed
+    // For this test, we just verify the recovery logic works
+    expect(Object.keys(mappings)).toEqual(['session4']);
+    expect(mappings['session4']).toBe('researcher');
+
+    // Verify we could write valid JSON
+    const testJson = JSON.stringify(mappings, null, 2);
+    expect(() => JSON.parse(testJson)).not.toThrow();
+  });
+
+  it('setAgentForSession preserves existing mappings when adding new one', async () => {
+    const sessionFile = join(tempDir, 'agent-sessions.json');
+
+    // Create a valid sessions file
+    const initialMappings = { session1: 'pai', session2: 'designer' };
+    writeFileSync(sessionFile, JSON.stringify(initialMappings, null, 2));
+
+    // Simulate reading and adding a new session
+    let mappings = JSON.parse(readFileSync(sessionFile, 'utf-8'));
+    mappings['session3'] = 'researcher';
+
+    // Verify all mappings are present
+    expect(Object.keys(mappings).length).toBe(3);
+    expect(mappings['session1']).toBe('pai');
+    expect(mappings['session2']).toBe('designer');
+    expect(mappings['session3']).toBe('researcher');
+  });
+});

package/src/hooks/ts/capture-all-events.ts

@@ -6,11 +6,12 @@
  * Enhanced with agent instance metadata extraction
  */
 
-import { readFileSync, appendFileSync, mkdirSync, existsSync, writeFileSync } from 'fs';
+import { readFileSync, appendFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { historyDir, agentSessionsPath } from './lib/pai-paths';
 import { enrichEventWithAgentMetadata, isAgentSpawningCall } from './lib/metadata-extraction';
 import { isProbeSession } from './lib/project-utils';
+import { writeJsonAtomic } from '../../config/json-store.js';
 
 interface HookEvent {
   source_app: string;
@@ -80,11 +81,17 @@ function setAgentForSession(sessionId: string, agentName: string): void {
     let mappings: Record<string, string> = {};
 
     if (existsSync(mappingFile)) {
-      mappings = JSON.parse(readFileSync(mappingFile, 'utf-8'));
+      try {
+        mappings = JSON.parse(readFileSync(mappingFile, 'utf-8'));
+      } catch {
+        // If file exists but is corrupt, start fresh with the new mapping
+        mappings = {};
+      }
     }
 
     mappings[sessionId] = agentName;
-    writeFileSync(mappingFile, JSON.stringify(mappings, null, 2), 'utf-8');
+    // Fires concurrently across sessions; non-atomic write truncated the file on 2026-09-20
+    writeJsonAtomic(mappingFile, mappings, { backup: false, label: 'agent-sessions.json' });
   } catch (error) {
     // Silently fail - don't block
   }

package/src/hooks/ts/user-prompt/whisper-rules.test.ts

@@ -1,5 +1,8 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, afterEach } from "vitest";
 import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 // whisper-rules.ts calls main() unconditionally at module scope (it's a hook
 // entrypoint, always run as a subprocess) — including a blocking read of fd 0.
@@ -46,4 +49,56 @@ describe("user-prompt/whisper-rules entrypoint", () => {
     expect(stdout).toContain("<system-reminder>");
     expect(stdout).toContain("CURRENT LOCAL TIME");
   });
+
+  describe("cache-keepalive beat prompt", () => {
+    const dirs: string[] = [];
+
+    afterEach(() => {
+      for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
+    });
+
+    function configuredEnv(config: Record<string, unknown>): NodeJS.ProcessEnv {
+      const dir = mkdtempSync(join(tmpdir(), "pai-whisper-keepalive-"));
+      dirs.push(dir);
+      const file = join(dir, "config.json");
+      writeFileSync(file, JSON.stringify(config), "utf8");
+      return { ...process.env, PAI_CONFIG_FILE: file };
+    }
+
+    it("replies with only the minimal tool-free instruction, bypassing rules/advisor", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: true, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "keepalive" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toBe(
+        "<system-reminder>\nReply with a single period and nothing else. Do not call tools.\n</system-reminder>\n"
+      );
+      expect(stdout).not.toContain("CURRENT LOCAL TIME");
+    });
+
+    it("falls through to the normal rule block when the feature is disabled", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: false, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "keepalive" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toContain("CURRENT LOCAL TIME");
+    });
+
+    it("falls through to the normal rule block for a prompt that doesn't match the configured word", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: true, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "please fix the login bug" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toContain("CURRENT LOCAL TIME");
+    });
+  });
 });

package/src/hooks/ts/user-prompt/whisper-rules.ts

@@ -24,6 +24,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveAdvisorMode, type AdvisorConfig } from "../lib/advisor-budget.js";
 import { whisperRulesPath, advisorModePath } from "../../../config/pai-files.js";
+import { loadConfig } from "../../../daemon/config.js";
 
 const WHISPER_FILE = whisperRulesPath();
 const ADVISOR_FILE = advisorModePath();
@@ -181,6 +182,24 @@ function resetReinjectCounter(sessionId: string): void {
  * several times per turn during worker-heavy work, so injecting the ~5KB rule
  * block on each one was landing it 3-5 times in a single turn.
  */
+/**
+ * True when this prompt is the daemon's own idle-triggered cache-keepalive
+ * beat (sessions.cacheKeepalive, src/daemon/config.ts): the daemon typed the
+ * configured word into this session purely to refresh its prompt-cache TTL,
+ * not to ask anything. The whole point is a beat that costs as little output
+ * as possible, so this bypasses every other rule/advisor injection below —
+ * adding ~5KB of context to answer nothing would erase the saving the beat
+ * exists to capture.
+ */
+export function isCacheKeepaliveBeat(prompt: string): boolean {
+  try {
+    const { enabled, prompt: word } = loadConfig().sessions.cacheKeepalive;
+    return enabled && prompt.trim() === word;
+  } catch {
+    return false;
+  }
+}
+
 export function isRelayedPrompt(prompt: string): boolean {
   return (
     /^\s*\[Session:[^\]]+\]/.test(prompt) ||
@@ -204,6 +223,11 @@ function main() {
 
   resetReinjectCounter(sessionId);
 
+  if (isCacheKeepaliveBeat(prompt)) {
+    console.log("<system-reminder>\nReply with a single period and nothing else. Do not call tools.\n</system-reminder>");
+    return;
+  }
+
   if (isRelayedPrompt(prompt)) return;
 
   const isWorker = process.env.PAI_WORKER === "1";

package/statusline-command.sh

@@ -114,15 +114,90 @@ if [ ! -f "$pai_config" ]; then
         pai_config="${XDG_CONFIG_HOME:-$HOME/.config}/pai/config.json"
     fi
 fi
+
+# Providers moved to $pai_home_dir/workers.yaml (top-level `providers:`; see
+# src/workers/config.ts readWorkersSection) on 2026-09-19 — jq never sees the
+# YAML directly (no yq on this machine), so a small node script converts it
+# via the `yaml` package sitting next to this script's own real location
+# (readlink -f "$0": this file is usually reached through a symlink at
+# ~/.claude/statusline-command.sh). The conversion is cached under
+# pai_cache_dir, the cache kept only while it is newer than workers.yaml's own
+# mtime, so node is spawned only when the YAML actually changed. Resolved once
+# into $providers_file (holding just the providers object, unwrapped) so both
+# this lookup and the usage block below read the same data — never re-derived.
+# Any failure (no workers.yaml, no node, parse error) falls back silently to
+# the legacy `.workers.providers` of $pai_config, then to anthropic.
+providers_file=""
+_workers_yaml="${pai_home_dir}/workers.yaml"
+if [ -f "$_workers_yaml" ] && command -v node >/dev/null 2>&1; then
+    _sl_script="$(readlink -f "$0" 2>/dev/null || echo "$0")"
+    _sl_script_dir="$(dirname "$_sl_script")"
+    _providers_cache="${pai_cache_dir}/statusline-providers.json"
+    _yaml_mtime=$(stat -f %m "$_workers_yaml" 2>/dev/null || echo 0)
+    _cache_mtime=$(stat -f %m "$_providers_cache" 2>/dev/null || echo -1)
+    if [ ! -s "$_providers_cache" ] || [ "$_cache_mtime" -lt "$_yaml_mtime" ] 2>/dev/null; then
+        mkdir -p "$pai_cache_dir" 2>/dev/null
+        # umask 077 so the temp file is born 0600 — it must never exist at a
+        # world-readable mode even transiently, since providers carry inline
+        # `key:` secrets and only the allow-listed fields below leave this
+        # subshell.
+        (
+            umask 077
+            NODE_PATH="${_sl_script_dir}/node_modules" node - "$_workers_yaml" \
+                > "${_providers_cache}.tmp" 2>/dev/null <<'PAI_YAML_PROVIDERS'
+const fs = require("fs");
+try {
+    const YAML = require("yaml");
+    const doc = YAML.parse(fs.readFileSync(process.argv[2], "utf8"));
+    const providers = (doc && doc.providers) || {};
+    // Allow-list: only what the status line ever reads from a provider.
+    // workers.yaml is 0600 because providers carry inline `key:` secrets —
+    // this cache must never repeat them (or `env`, `url`, `headers`, …).
+    const safe = {};
+    for (const [name, p] of Object.entries(providers || {})) {
+        safe[name] = {
+            models: (p && p.models) || {},
+            usage: (p && p.usage) || undefined,
+            keyFile: (p && p.keyFile) || undefined,
+        };
+    }
+    process.stdout.write(JSON.stringify(safe));
+} catch {
+    process.exit(1);
+}
+PAI_YAML_PROVIDERS
+        )
+        if [ -s "${_providers_cache}.tmp" ]; then
+            mv "${_providers_cache}.tmp" "$_providers_cache"
+        else
+            rm -f "${_providers_cache}.tmp"
+        fi
+    fi
+    [ -s "$_providers_cache" ] && providers_file="$_providers_cache"
+fi
+if [ -z "$providers_file" ] && [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
+    _providers_legacy="${pai_cache_dir}/statusline-providers-legacy.json"
+    mkdir -p "$pai_cache_dir" 2>/dev/null
+    # Same allow-list and 0600-from-birth handling as the YAML path above:
+    # this legacy config can carry the same inline `key:` secrets.
+    if (umask 077; jq -c '(.workers.providers // {}) | with_entries(.value |= {models, usage, keyFile})' "$pai_config" > "${_providers_legacy}.tmp" 2>/dev/null) \
+        && [ -s "${_providers_legacy}.tmp" ]; then
+        mv "${_providers_legacy}.tmp" "$_providers_legacy"
+        providers_file="$_providers_legacy"
+    else
+        rm -f "${_providers_legacy}.tmp"
+    fi
+fi
+
 model_base="${model_id%%\[*}"
 session_provider=anthropic
-if [ -n "$model_base" ] && [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
+if [ -n "$model_base" ] && [ -n "$providers_file" ] && command -v jq >/dev/null 2>&1; then
     _matched_provider=$(jq -r --arg mb "$model_base" '
-        (.workers.providers // {}) | to_entries[] as $p
+        (. // {}) | to_entries[] as $p
         | (($p.value.models // {}) | to_entries[]) as $m
         | ($m.value | tostring) as $v
         | select($v == $mb or ($v | split("[")[0]) == $mb)
-        | $p.key' "$pai_config" 2>/dev/null | head -1)
+        | $p.key' "$providers_file" 2>/dev/null | head -1)
     [ -n "$_matched_provider" ] && session_provider="$_matched_provider"
 fi
 
@@ -738,9 +813,9 @@ _fetch_provider_usage() {
 if [ "$session_provider" != "anthropic" ]; then
     provider_usage=""
     provider_keyfile=""
-    if [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
-        provider_usage=$(jq -c --arg p "$session_provider" '.workers.providers[$p].usage // empty' "$pai_config" 2>/dev/null)
-        provider_keyfile=$(jq -r --arg p "$session_provider" '.workers.providers[$p].keyFile // empty' "$pai_config" 2>/dev/null)
+    if [ -n "$providers_file" ] && command -v jq >/dev/null 2>&1; then
+        provider_usage=$(jq -c --arg p "$session_provider" '.[$p].usage // empty' "$providers_file" 2>/dev/null)
+        provider_keyfile=$(jq -r --arg p "$session_provider" '.[$p].keyFile // empty' "$providers_file" 2>/dev/null)
         case "$provider_keyfile" in "~/"*) provider_keyfile="$HOME/${provider_keyfile#\~/}" ;; esac
     fi