jagc 0.1.0

package/.env.example

@@ -0,0 +1,7 @@
+JAGC_DATABASE_PATH=/Users/akuzmenko/.jagc/jagc.sqlite
+JAGC_WORKSPACE_DIR=/Users/akuzmenko/.jagc
+JAGC_HOST=127.0.0.1
+JAGC_PORT=31415
+JAGC_API_URL=http://127.0.0.1:31415
+JAGC_RUNNER=pi
+JAGC_TELEGRAM_BOT_TOKEN=

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to jagc are documented here.
+
+This project follows a readable, sectioned changelog format with a permanent **Unreleased** section.
+
+## [Unreleased]
+
+### Added
+
+- _None yet._
+
+### Changed
+
+- _None yet._
+
+### Fixed
+
+- _None yet._
+
+## [0.1.0] - 2026-02-09
+
+### Added
+
+- npm-distributable CLI package (`jagc`) with built artifacts and curated package contents.
+- First supported macOS deployment path via top-level CLI service commands:
+  - `jagc install`
+  - `jagc status`
+  - `jagc restart`
+  - `jagc uninstall`
+  - `jagc doctor`
+- Launchd-managed per-user service installation with workspace-scoped logs and safety defaults.
+- Package smoke loop (`pnpm test:pack`) validating tarball install + runnable server + CLI roundtrip.
+- CI release gate workflow (`pnpm release:gate`) on GitHub Actions.
+
+### Changed
+
+- Deployment docs now treat macOS npm+launchd as the primary supported install path.
+- Local release gate consolidated into a single canonical command.
+- Project license changed from UNLICENSED to MIT (`LICENSE` added).
+
+### Fixed
+
+- Service status/restart/doctor health targeting now resolves host/port from installed service config.
+- Service command failures now return clean one-line CLI errors (no stack dumps).
+- Service manager no longer selects TypeScript server entrypoints for launchd runtime.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Kuzmenko <hotk@hey.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# jagc
+
+> **jagc** = **j**ust **a** **g**ood **c**lanker.
+
+Self-hosted AI assistant to automate your life:
+- **pi-coding-agent** for agent runtime behavior (sessions, context files, skills/prompts/extensions/themes/packages)
+- **SQLite-backed run state + in-process scheduler** for durable run tracking and execution
+
+This README is intentionally short and v0-focused.
+
+For current implemented architecture, see **[`docs/architecture.md`](docs/architecture.md)**.
+For deferred APIs, deployment notes, and post-v0 plans, see **[`docs/future.md`](docs/future.md)**.
+For testing loops (including Telegram behavioral polling clone), see **[`docs/testing.md`](docs/testing.md)**.
+For release/publish procedure, see **[`docs/release.md`](docs/release.md)**.
+Release history lives in **[`CHANGELOG.md`](CHANGELOG.md)**.
+
+## Status
+
+- **Pre-alpha.** Expect breaking changes.
+- **v0 scope is implemented** (server + CLI + threading semantics + Telegram polling controls). CI merge gating runs in GitHub Actions (`pnpm release:gate`).
+- npm publish is tag-driven via GitHub Actions (`vX.Y.Z` tags only, `latest` channel).
+- Core server endpoints are in place: `/healthz`, `/v1/messages`, `/v1/runs/:run_id`, auth catalog/login endpoints (`/v1/auth/providers`, `/v1/auth/providers/:provider/login`, `/v1/auth/logins/:attempt_id{,/input,/cancel}`), `/v1/models`, and thread runtime controls (`/v1/threads/:thread_key/{runtime,model,thinking,session}`).
+- CLI supports the happy path plus runtime controls: `message`, `run wait`, `health`, `auth providers`, `auth login`, `new`, `model list/get/set`, `thinking get/set`, and local service lifecycle commands (`install`, `status`, `restart`, `uninstall`, `doctor`).
+- Default executor runs through pi SDK sessions with SQLite-backed durable run tracking and in-process scheduling/recovery.
+- Same-thread queued follow-ups/steers are accepted and run completion is attributed via pi session events (not prompt promise timing).
+- Same-thread turn ordering (`followUp` / `steer`) is enforced by per-thread pi session controllers; run dispatch/recovery is in-process and single-server-process scoped in v0.
+- Telegram polling adapter is implemented (personal chats), including button-based runtime controls via `/settings`, `/new`, `/model`, `/thinking`, and `/auth`.
+- Server/runtime logs are unified on structured Pino JSON with component-scoped child loggers and request completion events.
+- Telegram chat UX now streams live run progress in-chat (append-style progress edits + typing indicator + compact `>` tool / `~` thinking snippets) while preserving final run output delivery.
+- If Telegram foreground wait times out, the adapter keeps watching in the background and posts the final result when the run completes.
+- Model/thinking changes from Telegram button pickers return to the `/settings` panel with updated runtime state.
+- Outdated Telegram inline callbacks auto-recover by replacing the menu with the latest `/settings` panel.
+- Telegram callback payload limits are enforced; over-limit model/auth options are hidden with an in-chat notice.
+- `JAGC_RUNNER=echo` is available for deterministic smoke tests.
+- macOS single-user deployment is supported via npm global install + launchd (`jagc install` / `status` / `restart` / `uninstall`). Manual templates remain under `deploy/` as fallback examples.
+
+## Locked v0 technology stack
+
+Source of truth: **[`AGENTS.md`](AGENTS.md)**.
+
+- Runtime: TypeScript (ESM) on Node.js 20 + pnpm
+- Server/API: Fastify + Zod + Pino
+- CLI: Commander
+- Agent/runtime: pi-coding-agent
+- Durable run state: SQLite (`runs`, `message_ingest`, `thread_sessions`) + in-process scheduler
+- Telegram: grammY (polling first)
+- Quality/tooling: Biome + Vitest
+- Build: tsdown
+
+## v0 scope (shipped)
+
+Shipped in v0:
+
+- Server:
+  - `GET /healthz`
+  - `POST /v1/messages` (ingest message, start durable run, return `run_id`)
+  - `GET /v1/runs/:run_id` (status/output)
+- CLI:
+  - `jagc message "..." --json`
+  - `jagc run wait <run_id> --json`
+  - `jagc install|status|restart|uninstall|doctor` (macOS service lifecycle + diagnostics)
+- Telegram:
+  - **Polling mode only** for v0
+  - Personal chats only
+  - One active run per Telegram thread (`thread_key = telegram:chat:<chat_id>`)
+  - Queued input behavior aligned with pi semantics (`steer` / `followUp`)
+  - `/new` resets the current Telegram thread's pi session; the next message creates a fresh session
+
+### v0 acceptance behavior
+
+- `jagc message "ping" --json` returns JSON including:
+  - `run_id`
+  - `status` (`succeeded|failed|running`)
+  - `output` (when succeeded)
+  - `error.message` (when failed)
+- If two messages arrive for the same thread while a run is active:
+  - `steer` interrupts at the next tool boundary
+  - `followUp` waits for idle
+- Different threads run concurrently.
+
+## Contracts to stabilize early
+
+We intentionally lock only these early:
+
+1. **Workspace contract** (`JAGC_WORKSPACE_DIR`) and override rules
+2. **Ingress envelope + idempotency semantics** (internal)
+3. **Thread/run concurrency + queued message behavior** (`steer` / `followUp`)
+
+Everything else remains flexible during pre-alpha.
+
+## Minimal workspace contract
+
+`JAGC_WORKSPACE_DIR` points to a trusted local repo.
+
+Canonical layout (v0):
+
+```text
+$JAGC_WORKSPACE_DIR/
+  AGENTS.md           # auto-created on first startup (global user profile + assistant instructions)
+  SYSTEM.md           # auto-created on first startup (global assistant behavior baseline)
+  APPEND_SYSTEM.md    # optional
+  skills/             # auto-seeded with bundled skills on first startup (no overwrite)
+  prompts/            # optional
+  extensions/         # auto-seeded with bundled extensions on first startup (no overwrite)
+  themes/             # optional
+  tools/              # optional
+  jagc.json           # optional
+  settings.json       # auto-created on first startup (pi workspace settings + default packages)
+  .gitignore          # auto-managed: .sessions/, auth.json, git/, jagc.sqlite*
+```
+
+## Configuration (v0 minimum)
+
+| Variable | Required | Notes |
+| --- | --- | --- |
+| `JAGC_DATABASE_PATH` | No | SQLite DB file path (default `$JAGC_WORKSPACE_DIR/jagc.sqlite`; relative paths resolve under `JAGC_WORKSPACE_DIR`) |
+| `JAGC_WORKSPACE_DIR` | No | Workspace + pi agent directory (default `~/.jagc`) |
+| `JAGC_HOST` | No | Server bind host (default `127.0.0.1`) |
+| `JAGC_PORT` | No | Server bind port (default `31415`) |
+| `JAGC_API_URL` | No | CLI API target (default `http://127.0.0.1:31415`) |
+| `JAGC_RUNNER` | No | `pi` (default) or `echo` for deterministic local/smoke runs |
+| `JAGC_LOG_LEVEL` | No | `info` by default (`fatal|error|warn|info|debug|trace|silent`) |
+| `JAGC_TELEGRAM_BOT_TOKEN` | No | Required only when Telegram adapter is enabled |
+| `JAGC_WEBHOOK_BEARER_TOKEN` | No | Required when generic `POST /v1/webhooks/:source` ingress is enabled |
+
+Auth setup and provider credential details: [`docs/auth.md`](docs/auth.md).
+
+By default jagc uses `JAGC_WORKSPACE_DIR=~/.jagc` for workspace files and sets `JAGC_DATABASE_PATH` to `$JAGC_WORKSPACE_DIR/jagc.sqlite`. On startup it ensures the directory exists, creates `SYSTEM.md`, `AGENTS.md`, and `settings.json` from built-in templates if missing (without overwriting existing files), seeds bundled `defaults/skills/**` and `defaults/extensions/**` files into the workspace if missing (without overwriting existing files), and keeps `.gitignore` entries for `.sessions/`, `auth.json`, `git/`, `jagc.sqlite`, `jagc.sqlite-shm`, and `jagc.sqlite-wal`. The default `settings.json` pre-installs `git:github.com/default-anton/pi-librarian` and `git:github.com/default-anton/pi-subdir-context`; users can edit/remove them later. jagc still does not copy `~/.pi/agent/{settings.json,auth.json}` automatically.
+
+## Quick start (macOS, supported path)
+
+1. Install Node.js 20+ and npm.
+2. Install jagc globally:
+   - `npm install -g jagc@latest`
+3. Install + start the user service:
+   - `jagc install`
+4. Verify:
+   - `jagc status`
+   - `jagc health --json`
+
+Update to latest:
+
+- `npm install -g jagc@latest`
+- `jagc restart`
+
+Uninstall service (keep workspace data):
+
+- `jagc uninstall`
+
+Uninstall service and delete local workspace data (`~/.jagc` by default):
+
+- `jagc uninstall --purge-data`
+
+Remove the npm package binary as well:
+
+- `npm uninstall -g jagc`
+
+If the service fails to start, run diagnostics:
+
+- `jagc doctor`
+
+## Quick start (dev)
+
+1. `mise install` (rerun when required tools are missing or `.tool-versions` changes)
+2. `pnpm install`
+3. Set required env vars (see `.env.example`)
+4. `pnpm dev` (applies SQL migrations from `migrations/` on startup)
+5. Verify:
+   - `pnpm smoke`
+   - `pnpm test`
+   - or manually: `pnpm dev:cli health --json` then `pnpm dev:cli message "ping" --json`
+   - inspect provider/model catalog: `pnpm dev:cli model list --json`
+   - inspect auth status / start OAuth login: `pnpm dev:cli auth providers --json` and `pnpm dev:cli auth login openai-codex`
+   - inspect thread runtime controls: `pnpm dev:cli model get --thread-key cli:default --json` and `pnpm dev:cli thinking get --thread-key cli:default --json`
+   - reset thread session: `pnpm dev:cli new --thread-key cli:default --json`
+
+### CLI runtime controls (v0)
+
+```bash
+# provider/model catalog
+jagc model list --json
+
+# read current thread model + thinking
+jagc model get --thread-key cli:default --json
+jagc thinking get --thread-key cli:default --json
+
+# reset current thread session (next message starts fresh)
+jagc new --thread-key cli:default --json
+
+# set model + thinking for a thread
+jagc model set openai/gpt-5 --thread-key cli:default --json
+jagc thinking set medium --thread-key cli:default --json
+
+# OAuth login via jagc broker
+jagc auth providers --json
+jagc auth login openai-codex
+# optional: stable owner key to resume the same login flow
+jagc auth login openai-codex --owner-key cli:default
+```
+
+## Security baseline
+
+- Workspace code is **trusted** and runs with server permissions.
+- Third-party pi packages are **trusted code**; review before installing.
+- Local CLI usage requires no auth for v0.
+- Generic webhook ingress (`POST /v1/webhooks/:source`) requires bearer-token auth (`Authorization: Bearer ...`).
+- Hardening path after v0: add HMAC-signed payload verification + replay protection (timestamp/nonce window).
+- Run as unprivileged user; keep secrets out of repos.
+
+## License
+
+MIT. See [`LICENSE`](./LICENSE).
+
+---
+
+## Deferred scope
+
+See **[`docs/future.md`](docs/future.md)** for the post-v0 roadmap (webhook hardening, CI automation, operator UX, and deployment maturity).
+
+Pre-v0 long-form draft details were intentionally removed during docs tightening; recover them from git history if needed.

package/defaults/AGENTS.md

@@ -0,0 +1,84 @@
+## Global instructions (always on)
+
+- Treat this file as the default instruction layer for all chats and projects.
+- Be direct, opinionated, and practical. Skip corporate tone and filler.
+- Never open with canned fluff ("Great question", "Absolutely", etc.).
+- Keep answers short by default; expand only when asked or when risk is high.
+- Call out bad ideas early. Be respectful, but don't sugarcoat.
+- Ask clarifying questions only when blocked.
+- When repository-specific instructions exist, follow the closest repo `AGENTS.md` for local rules and use this file for personal/global preferences.
+
+## How this template works
+
+- Each section has guidance plus placeholders.
+- Guidance explains what belongs in the section.
+- Placeholders are the parts to fill in and update over time.
+- If something is unknown, leave `<fill me>` and continue.
+
+## How to address me (the user)
+
+### Guidance
+
+- Use my preferred name/call-sign when known; otherwise skip name-based greetings.
+- Mirror my language.
+- Use pronouns only when explicitly known.
+- Use timezone-aware answers when scheduling matters.
+
+### Data
+
+- Name: <fill me>
+- Call me: <fill me>
+- Pronouns: <fill me>
+- Timezone: <fill me>
+- Language(s): <fill me>
+
+## User preferences (free-form)
+
+### Guidance
+
+- Store durable preferences here as they are learned in conversation.
+- Keep entries concrete and actionable (tone, format, tooling, workflow, constraints).
+- Prefer short bullets over prose.
+
+### Entries
+
+- <fill me>
+- <fill me>
+
+## Environment facts (agent-maintained)
+
+### Guidance
+
+- Discover and maintain these from the local environment; ask only when blocked.
+- Keep values factual and specific.
+
+### Data
+
+- OS + shell: <fill me>
+- Toolchains/package managers: <fill me>
+- Core local services/devices: <fill me>
+
+## Important paths (path + one-line purpose)
+
+### Guidance
+
+- Track high-signal paths as they become relevant.
+- Format each entry as: ``/absolute/path`` — one sentence on what it contains and why it matters.
+
+### Entries
+
+- `/absolute/path` — <fill me>
+- `/absolute/path` — <fill me>
+
+## Safety and guardrails
+
+- Confirm before destructive/irreversible actions.
+- Never perform purchases, financial transfers, or account-level changes without explicit approval.
+- Never expose secrets or private data outside the current task scope.
+- If a request is risky or ambiguous, propose the safest concrete next step first.
+
+## Maintenance
+
+- Keep this file concise and instruction-first.
+- Update it whenever the user corrects a preference.
+- Update environment facts and important paths when newly discovered.

package/defaults/SYSTEM.md

@@ -0,0 +1,27 @@
+## Role
+
+You are my personal AI assistant. Be useful, decisive, and honest.
+
+## Core behavior
+
+- Have a point of view. If there are multiple options, pick one by default and explain tradeoffs briefly.
+- Don't sound corporate. Remove policy-speak, hedging, and fake enthusiasm.
+- Never open with 'Great question', 'I'd be happy to help', or 'Absolutely'. Just answer.
+- Brevity is mandatory. If one sentence works, use one sentence.
+- Humor is allowed when it helps clarity or tone. Don't force it.
+- Call out bad ideas early. Be blunt but respectful.
+- Swearing is allowed when it lands. Keep it occasional and intentional.
+- Don't pretend certainty: if unsure, say what you know, what you're assuming, and what to check next.
+
+## Vibe
+
+- Practical over performative.
+- Warm, sharp, and unafraid to disagree.
+- Treat me like a capable adult with limited time.
+'Be the assistant you'd actually want to talk to at 2am. Not a corporate drone. Not a sycophant. Just... good.
+
+## Safety defaults
+
+- Confirm before destructive actions, purchases, account changes, or irreversible operations.
+- Protect private data and secrets by default.
+- If a request is risky or ambiguous, propose the safest concrete next step.

package/defaults/settings.json

@@ -0,0 +1,3 @@
+{
+  "packages": ["git:github.com/default-anton/pi-librarian", "git:github.com/default-anton/pi-subdir-context"]
+}

package/deploy/launchd/com.jagc.server.plist

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>com.jagc.server</string>
+
+    <!--
+      Prefer `jagc install` for managed setup.
+      This file is the manual fallback when operators need to hand-edit launchd config.
+    -->
+    <key>ProgramArguments</key>
+    <array>
+      <string>/opt/homebrew/bin/node</string>
+      <string>/usr/local/lib/node_modules/jagc/dist/server/main.mjs</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>/Users/you/.jagc</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>ProcessType</key>
+    <string>Background</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>PATH</key>
+      <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+      <key>JAGC_WORKSPACE_DIR</key>
+      <string>/Users/you/.jagc</string>
+      <key>JAGC_DATABASE_PATH</key>
+      <string>/Users/you/.jagc/jagc.sqlite</string>
+      <key>JAGC_HOST</key>
+      <string>127.0.0.1</string>
+      <key>JAGC_PORT</key>
+      <string>31415</string>
+      <key>JAGC_RUNNER</key>
+      <string>pi</string>
+      <key>JAGC_LOG_LEVEL</key>
+      <string>info</string>
+      <!-- Optional provider env vars -->
+      <!-- <key>OPENAI_API_KEY</key><string>...</string> -->
+      <!-- Optional Telegram polling -->
+      <!-- <key>JAGC_TELEGRAM_BOT_TOKEN</key><string>...</string> -->
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>/Users/you/.jagc/logs/server.out.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/Users/you/.jagc/logs/server.err.log</string>
+  </dict>
+</plist>

package/deploy/systemd/jagc-restart.service

@@ -0,0 +1,6 @@
+[Unit]
+Description=Restart jagc (triggered by jagc.path)
+
+[Service]
+Type=oneshot
+ExecStart=/bin/systemctl restart jagc.service

package/deploy/systemd/jagc.env.example

@@ -0,0 +1,23 @@
+# Copy to: /etc/jagc/jagc.env
+# Make sure this file is readable by the jagc service user.
+
+# All jagc-specific env vars are prefixed with JAGC_.
+# (Exception: PI_CODING_AGENT_DIR is owned by pi-coding-agent.)
+
+# SQLite database file
+JAGC_DATABASE_PATH=/var/lib/jagc/workspace/jagc.sqlite
+
+# Path to the user config repo (workflows/, AGENTS.md, SYSTEM.md, skills/, ... )
+JAGC_WORKSPACE_DIR=/var/lib/jagc/workspace
+
+# Server bind
+JAGC_PORT=31415
+
+# Optional: isolate pi-coding-agent state (sessions, global settings)
+# PI_CODING_AGENT_DIR=/var/lib/jagc/pi-agent
+
+# Provider credentials (example)
+# OPENAI_API_KEY=...
+
+# Telegram (optional)
+# JAGC_TELEGRAM_BOT_TOKEN=...

package/deploy/systemd/jagc.path

@@ -0,0 +1,12 @@
+[Unit]
+Description=EXPERIMENTAL: restart jagc when workspace workflows change
+
+# Safer default: do NOT enable this unit in production.
+# Prefer explicit/manual restarts after reviewing workspace changes.
+# If you opt in, scope restarts to workflow code changes only.
+[Path]
+PathModified=/var/lib/jagc/workspace/workflows
+Unit=jagc-restart.service
+
+[Install]
+WantedBy=multi-user.target

package/deploy/systemd/jagc.service

@@ -0,0 +1,24 @@
+[Unit]
+Description=jagc server
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=jagc
+Group=jagc
+WorkingDirectory=/var/lib/jagc/workspace
+EnvironmentFile=/etc/jagc/jagc.env
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+ExecStart=/usr/bin/env node /usr/local/lib/node_modules/jagc/dist/server/main.mjs
+ExecReload=/bin/kill -HUP $MAINPID
+Restart=on-failure
+RestartSec=2
+TimeoutStopSec=30
+KillSignal=SIGINT
+
+# Logs end up in journald. View with:
+#   journalctl -u jagc -f
+
+[Install]
+WantedBy=multi-user.target

package/dist/api-contracts-BPwE7cri.mjs

@@ -0,0 +1,118 @@
+import { z } from "zod";
+
+//#region src/shared/run-types.ts
+const deliveryModes = ["steer", "followUp"];
+
+//#endregion
+//#region src/shared/api-contracts.ts
+const deliveryModeSchema = z.enum(deliveryModes);
+const thinkingLevels = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const thinkingLevelSchema = z.enum(thinkingLevels);
+const postMessageRequestSchema = z.object({
+	source: z.string().trim().min(1).default("cli"),
+	thread_key: z.string().trim().min(1).default("cli:default"),
+	user_key: z.string().trim().min(1).optional(),
+	text: z.string().min(1),
+	delivery_mode: deliveryModeSchema.default("followUp"),
+	idempotency_key: z.string().trim().min(1).optional()
+});
+const runParamsSchema = z.object({ run_id: z.string().trim().min(1) });
+const threadParamsSchema = z.object({ thread_key: z.string().trim().min(1) });
+const authProviderParamsSchema = z.object({ provider: z.string().trim().min(1) });
+const authLoginAttemptParamsSchema = z.object({ attempt_id: z.string().trim().min(1) });
+const oauthOwnerHeaderName = "x-jagc-auth-owner";
+const runResponseSchema = z.object({
+	run_id: z.string(),
+	status: z.enum([
+		"running",
+		"succeeded",
+		"failed"
+	]),
+	output: z.record(z.string(), z.unknown()).nullable(),
+	error: z.object({ message: z.string() }).nullable()
+});
+const apiErrorResponseSchema = z.object({ error: z.object({
+	code: z.string(),
+	message: z.string()
+}) });
+const providerModelSchema = z.object({
+	provider: z.string(),
+	model_id: z.string(),
+	name: z.string(),
+	reasoning: z.boolean(),
+	available: z.boolean()
+});
+const providerAuthStatusSchema = z.object({
+	provider: z.string(),
+	has_auth: z.boolean(),
+	credential_type: z.enum(["api_key", "oauth"]).nullable(),
+	oauth_supported: z.boolean(),
+	env_var_hint: z.string().nullable(),
+	total_models: z.number().int().nonnegative(),
+	available_models: z.number().int().nonnegative()
+});
+const providerCatalogSchema = providerAuthStatusSchema.extend({ models: z.array(providerModelSchema) });
+const authProvidersResponseSchema = z.object({ providers: z.array(providerAuthStatusSchema) });
+const modelCatalogResponseSchema = z.object({ providers: z.array(providerCatalogSchema) });
+const oauthLoginPromptKindSchema = z.enum(["prompt", "manual_code"]);
+const oauthLoginPromptSchema = z.object({
+	kind: oauthLoginPromptKindSchema,
+	message: z.string(),
+	placeholder: z.string().nullable(),
+	allow_empty: z.boolean()
+});
+const oauthLoginAttemptStatusSchema = z.enum([
+	"running",
+	"awaiting_input",
+	"succeeded",
+	"failed",
+	"cancelled"
+]);
+const oauthLoginAttemptSchema = z.object({
+	attempt_id: z.string(),
+	owner_key: z.string(),
+	provider: z.string(),
+	provider_name: z.string().nullable(),
+	status: oauthLoginAttemptStatusSchema,
+	auth: z.object({
+		url: z.string(),
+		instructions: z.string().nullable()
+	}).nullable(),
+	prompt: oauthLoginPromptSchema.nullable(),
+	progress_messages: z.array(z.string()),
+	error: z.string().nullable()
+});
+const submitOAuthLoginInputRequestSchema = z.object({
+	kind: oauthLoginPromptKindSchema.optional(),
+	value: z.string()
+});
+const threadRuntimeStateSchema = z.object({
+	thread_key: z.string(),
+	model: z.object({
+		provider: z.string(),
+		model_id: z.string(),
+		name: z.string().nullable()
+	}).nullable(),
+	thinking_level: thinkingLevelSchema,
+	supports_thinking: z.boolean(),
+	available_thinking_levels: z.array(thinkingLevelSchema)
+});
+const setThreadModelRequestSchema = z.object({
+	provider: z.string().trim().min(1),
+	model_id: z.string().trim().min(1)
+});
+const setThreadThinkingRequestSchema = z.object({ thinking_level: thinkingLevelSchema });
+const resetThreadSessionResponseSchema = z.object({
+	thread_key: z.string(),
+	reset: z.literal(true)
+});
+
+//#endregion
+export { oauthLoginAttemptSchema as a, resetThreadSessionResponseSchema as c, setThreadModelRequestSchema as d, setThreadThinkingRequestSchema as f, threadRuntimeStateSchema as g, threadParamsSchema as h, modelCatalogResponseSchema as i, runParamsSchema as l, thinkingLevels as m, authProviderParamsSchema as n, oauthOwnerHeaderName as o, submitOAuthLoginInputRequestSchema as p, authProvidersResponseSchema as r, postMessageRequestSchema as s, authLoginAttemptParamsSchema as t, runResponseSchema as u };