main
40 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 aminekaabachi
|
901aa8d12a | feat(web): white-label UI branding via config.yaml (#2857) | ||
|
Edwin He
|
0f1afc3502 |
feat(web): let a shared-with viewer leave a session (#4571)
* feat(web): let a shared-with viewer leave a session Every sidebar row action is owner-only, so a session someone shared with you could only be cleared by asking its owner to revoke you. The revoke endpoint couldn't serve it either: it required manage access AND blocked self-modification outright. Allow a self-revoke on the existing endpoint instead of adding a route. Removing someone else still needs manage; removing your own grant needs only read, since giving up access requires no privilege. The pre-existing owner-grant check is what prevents orphaning, and it already covers the self case — so an owner still can't leave (they archive or delete), while a manage-level guest can. Leaving a sub-agent is refused, since its access lives on the parent and revoking the child would delete nothing while reporting success. The sidebar gets a "Leave session" item on non-owned rows with a confirm dialog, and a session_removed push so the row also drops from the leaver's other open tabs. Nothing is deleted server-side, so the owner re-sharing brings the session back. Co-authored-by: Isaac Signed-off-by: Edwin He <41037314+Edwinhe03@users.noreply.github.com> * refactor(web): reuse the row's destructive slot for Leave, not a new item The non-owner's row menu already had a Delete item rendered permanently disabled ("only the session owner can delete this session") — a row that could never do anything, sitting in exactly the slot Leave wanted. Resolve that one slot by ownership instead of stacking a second item under it: the owner gets Delete, a shared-with viewer gets Leave, reusing the trash icon and destructive styling. Single-user mode keeps the plain owner Delete. Net fewer lines in the menu than before, since the disabled branch and its tooltip wrapper go away. Co-authored-by: Isaac Signed-off-by: Edwin He <41037314+Edwinhe03@users.noreply.github.com> * refactor(web): drop the session_removed push; the diff already covers it The self-leave path pushed a session_removed discovery event to the leaver's own streams. It was marginal: the leaver's initiating tab already drops the row via the mutation's onSuccess splice, and their other tabs converge on the next watch-set diff (which reports the now-inaccessible id as removed) — the handler even skipped the push whenever the row was watched, to avoid double-reporting with that diff. Its only unique effect was an instant drop for a listed-but-unwatched row in another of the leaver's tabs, versus a one-refetch delay. Unlike the session_added push (mandatory — a brand-new session is undiscoverable by the watch-set diff), the removal is always discoverable, so this push isn't load-bearing. Drop it and the client-side removed handler stays as-is (still driven by the diff). Owner-side roster liveness (the Share modal reflecting a grantee leaving) is a separate follow-up. Co-authored-by: Isaac Signed-off-by: Edwin He <41037314+Edwinhe03@users.noreply.github.com> * fix(web): satisfy oxlint — top-level type import + string toast CI's oxlint (which runs --deny-warnings, and couldn't run locally due to a stale-config/version mismatch) flagged two issues in the leave changes: - Sidebar.rowActions.test.tsx used an inline `typeof import("@/lib/identity")` type annotation, forbidden by typescript/consistent-type-imports. Switched to a top-level `import type * as IdentityModule`, matching the repo idiom. - The leave onError handler passed inline <span> JSX to showToast, which react/no-unstable-nested-components reads as a component defined during render. showToast takes a ReactNode, so pass a plain string instead. Co-authored-by: Isaac Signed-off-by: Edwin He <41037314+Edwinhe03@users.noreply.github.com> --------- Signed-off-by: Edwin He <41037314+Edwinhe03@users.noreply.github.com> |
||
|
Michael Stolarz
|
060fba449b |
feat(sandbox): add Blaxel provider (#4383)
* feat(sandbox): add Blaxel provider Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> * docs(sandbox): complete Blaxel launch guide Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> * fix(ci): avoid Blaxel smoke test import collision Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> * fix(ci): update Blaxel smoke test import Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> * fix(sandbox): derive Blaxel launch-token TTL from sandbox max age Blaxel deletes a sandbox at its configured max age regardless of activity, so a fixed 7-day launch token outlived the host it authenticated. Derive the token TTL from sandbox.blaxel.ttl plus a one hour reconnect margin, and reject a malformed ttl at config parse. Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> --------- Signed-off-by: Michael Stolarz <146425971+SystemSculpt@users.noreply.github.com> |
||
|
Zeyi (Rice) Fan
|
430994b50d |
feat(cli): add omnigent start as the on switch for hosting (#4321)
## Related issue Closes OMNI-2524 — https://linear.app/omnigent/issue/OMNI-2524 ## Summary - In local mode `omnigent host --background` (#4317) already starts the local server *and* registers this machine as a host, so it is effectively the "turn Omnigent on" command — but finding it means knowing the `host` concept and a flag. `omnigent start` is that command under the name people look for, and is symmetric with the existing `omnigent stop`. - It is a full alias, not a second implementation: same `--server` / `--non-interactive` options, the same CLI → config → local target resolution (`_resolve_host_server`), delegating to the same `_run_background_host()`. `host --background` keeps working for scripts that want the host lifecycle by name (`host status` / `host stop`). Registered in `_CLICK_SUBCOMMANDS` too: `main()` consults that allowlist before handing argv to click, so a top-level command missing from it can be misread as the removed ad-hoc chat (enforced by `test_click_subcommands_allowlist_covers_registered_commands`). - The stop hint each entry point echoes is now passed in, so `start` suggests `omnigent stop` while `host --background` keeps mirroring its own invocation. ``` $ omnigent start Started the host daemon in the background (pid 52359). server: http://127.0.0.1:6767 log: ~/.omnigent/logs/host/host-20260806-212352-515540.log Stop it with: omnigent stop ``` ## Test Plan - `uv run --extra dev pytest tests/host/test_cli_host.py -q` → 23 passed. - Manually: `omnigent start` printed the block above in ~4s; `omnigent host status` showed `mode=local process=online host=online`; a second `omnigent start` reported `already running (pid 52359)` with no second spawn; and `omnigent stop` reported `Stopped 1 daemon(s) and the background server`, after which `host status` and `server status` were both clear. - `omnigent --help` lists `start` next to `stop`; `omnigent start --help` documents the alias and both options. ## Demo N/A — CLI-only change; the new output is quoted above. ## Type of change - [ ] Bug fix - [x] Feature - [ ] UI / frontend change - [ ] Refactor / chore - [ ] Docs - [ ] Test / CI - [ ] Breaking change ## Test coverage - [x] Unit tests added / updated - [ ] Integration tests added / updated - [ ] E2E tests added / updated - [x] Manual verification completed - [ ] Existing tests cover this change - [ ] Not applicable ## Coverage notes Two new tests in `tests/host/test_cli_host.py` cover `start` spawning the same detached local-mode daemon (with the local server URL reported, the foreground loop skipped, and `omnigent stop` — not `host stop` — suggested), and `start --server <url> --non-interactive` passing the target through to both the sign-in pre-flight and the daemon argv. The daemon spawn and local-server discovery are stubbed, so no process or log file is created; the detached daemon itself was covered by the manual run above. ## Changelog `omnigent start` starts the local server and registers this machine as a host — the on switch to go with `omnigent stop`. Signed-off-by: Zeyi (Rice) Fan <zeyi.f@databricks.com> |
||
|
Serena Ruan
|
7efe05623b |
revert(sessions): unwind the #2150 approval/attribution stack (#3446, #3422, #3416) (#4318)
* revert(sessions): remove delegated approval authority (#3446) Reverts the delegated approval feature from #3446, returning to owner-only approval (the deny-by-default behavior from #3416). Owners can no longer delegate a "can_approve" capability to shared editors; approvals are again restricted to the session owner, while editors keep reject/cancel. The change is a faithful inverse of #3446 rebased on current main: files untouched since #3446 revert byte-identical to their pre-feature state; files later commits also modified keep those newer changes and drop only the approval lines. Migration handled non-destructively for deployed databases: - The original additive migration (c4d5e6f7a8b9) is kept intact so already-migrated databases still resolve their history. - A new forward migration (f7a8b9c0d1e2) drops the session_permissions .can_approve column; its downgrade re-adds it. Also removes a dangling import of _approval_access_from_grants in sessions/__init__.py left by the later wildcard-import refactor (#3934), which otherwise broke server import after the helper was reverted. Signed-off-by: Serena Ruan <serena.rxy@gmail.com> * revert(sessions): remove shared-message attribution (#3422) Reverts the model-visible shared-message authorship feature from #3422. Messages no longer gain `[author]:` prefixes in the model prompt, the SHARED_SESSION_AUTHORSHIP_INSTRUCTION framework instruction is removed, and the OMNIGENT_SHARED_MESSAGE_ATTRIBUTION_ENABLED switch is gone. Persisted `created_by` authorship (a store-level column predating #3422) is unaffected. Rebased on current main, keeping later independent work in the same regions: - Smart Routing's conditional `model_override` on the native-terminal forward path is preserved. - The `host_store` parameter added to the event-forward path is kept. - The two `test_external_interrupt_*` tests from #4160 (which overlap #3422's added block in test_sessions_endpoints.py) are kept; only #3422's `test_external_user_message_strips_model_author_prefix` is removed. Also removes dangling imports of `_strip_pending_author_prefix` in orchestration.py and sessions/__init__.py left after the helper's definition was reverted. Signed-off-by: Serena Ruan <serena.rxy@gmail.com> * revert(sessions): restore editor approval authority (#3416) Reverts the owner-only approval restriction from #3416. Approval events and URL-based elicitation resolution are gated at LEVEL_EDIT again, so shared editors — not only the owner — can resolve approvals. SECURITY REGRESSION (intentional, per request): #3416 was a security fix. Shared-session tools execute with the session owner's runner identity and ambient credentials, so a shared editor can once more authorize owner-credentialed tool calls. This, together with the #3422 and #3446 reverts, fully unwinds the #2150 stack and re-opens #2150. Signed-off-by: Serena Ruan <serena.rxy@gmail.com> --------- Signed-off-by: Serena Ruan <serena.rxy@gmail.com> |
||
|
Zeyi (Rice) Fan
|
52166e5dec |
feat(cli): add omnigent host --background to run the host daemon detached (#4317)
## Related issue Closes OMNI-2516 — https://linear.app/omnigent/issue/OMNI-2516 ## Summary - `omnigent host` only ever ran in the foreground, so registering a machine as a host cost a dedicated terminal — even though the detached daemon it needs already exists and is what `run` / `claude` / `codex` spawn via `_ensure_host_daemon()`. `--background` exposes that path directly: spawn (or adopt) the daemon, report it, and return. - Sign-in stays interactive. A detached daemon has no terminal to run the browser login on, so `_ensure_databricks_server_auth()` runs in the foreground *before* the spawn; otherwise the daemon dies in the background with an opaque "redirected to a login page" error. `--non-interactive` still fails with the `omnigent login` hint instead of prompting. - In local mode the daemon also owns the local Omnigent server, so the command waits for that server and reports its URL — otherwise the Web UI is unreachable without a follow-up `omnigent server status`. That makes `omnigent host --background` the whole "start everything" step, which is now the README quickstart (it replaces the `server --background` + `host` pair). - A daemon that dies on startup (bad URL, missing credentials) leaves nothing on the terminal, so the command waits a 2s grace and surfaces the daemon log rather than falsely reporting success. Output is a colorized headline plus aligned detail rows, with the stop command on its own line so it can be copied: ``` Started the host daemon in the background (pid 74241). server: https://dbc-…/api/2.0/omnigent log: ~/.omnigent/logs/host/host-20260806-205308-765542.log Stop it with: omnigent host stop --server https://dbc-…/api/2.0/omnigent ``` That stop command mirrors the invocation: `host` and `host stop` resolve their target identically (the `--server` value, else config, else local), so the flag is echoed only when the user named a target — a bare `host --background` prints a bare `omnigent host stop`. Colorizing reuses the existing `NO_COLOR`-aware helper, renamed `_help_style` → `_cli_style` now that it is not help-only. ## Test Plan - `uv run --extra dev pytest tests/host/test_cli_host.py -q` → 21 passed. - Manually, local mode: `omnigent host --background` reported `server: http://127.0.0.1:6767` and a bare `omnigent host stop` (no `--server` typed, none echoed), which then stopped it. - Manually, remote mode: `omnigent host --background --server https://dbc-…` printed the block quoted above; `omnigent host status` showed `process=online host=online`; re-running reported `already running (pid …)` with no second spawn; and the echoed `host stop --server …` stopped it. ## Demo N/A — CLI-only change; the new output is quoted above. ## Type of change - [ ] Bug fix - [x] Feature - [ ] UI / frontend change - [ ] Refactor / chore - [ ] Docs - [ ] Test / CI - [ ] Breaking change ## Test coverage - [x] Unit tests added / updated - [ ] Integration tests added / updated - [ ] E2E tests added / updated - [x] Manual verification completed - [ ] Existing tests cover this change - [ ] Not applicable ## Coverage notes Four new tests in `tests/host/test_cli_host.py` cover the spawn output (including the local server URL and a flagless stop hint), that the foreground daemon loop and in-process local-server bring-up are skipped, reuse of a healthy daemon via an explicit `--server ""` (whose stop hint keeps the flag), and that sign-in runs before the spawn. The daemon spawn and local-server discovery are stubbed, so no process or log file is created. Manual verification covered both modes end to end; the exits-immediately grace path is covered by tests only. ## Changelog `omnigent host --background` starts the local server and registers this machine as a host without tying up a terminal. Signed-off-by: Zeyi (Rice) Fan <zeyi.f@databricks.com> |
||
|
Ilya Bogin
|
d178e8a363 |
Add a deep-research example agent (#95)
* Add deep-research example (single agent over an MCP search server) A single-agent example that answers a question with a cited, cross-checked report: it plans sub-queries, searches the live web and reads full pages through an MCP search server, and verifies claims across independent sources. It is the repo's first example that wires an MCP server via tools/mcp/*.yaml (auto-discovered), so it also documents the MCP extension path. One agent plus one MCP server, no sub-agents — the simplest example to copy from. Runs zero-config against a public, keyless endpoint. Signed-off-by: Ilya Bogin <ilya.bogin@keenable.ai> * test: add e2e coverage for the deep-research example agent The examples-coverage-sync drift guard (test_every_agent_has_a_dedicated_test_file) requires every example agent to have a dedicated e2e test. The deep-research example shipped without one, failing E2E Tests (shard 0/4). Add a structural test via validate_agent_def_structure (infra-free: the agent's tools come from the hosted Keenable MCP server and it runs on the claude-sdk harness, so it can't run end-to-end in CI). Because the agent name 'deep-research' has a hyphen (not a valid Python test-module name), the test lives in test_deep_research_example.py and the guard is told via a 'deep-research' entry in _ALT_COVERED, mirroring the existing 'openai-coder' handling. Signed-off-by: Ilya Bogin <ilya.bogin@keenable.ai> * docs: show deep research search provider options Signed-off-by: Pat Sukprasert <pat.sukprasert@databricks.com> --------- Signed-off-by: Ilya Bogin <ilya.bogin@keenable.ai> Signed-off-by: Pat Sukprasert <pat.sukprasert@databricks.com> Co-authored-by: Pat Sukprasert <pattara.sk127@gmail.com> Co-authored-by: Pat Sukprasert <pat.sukprasert@databricks.com> |
||
|
Pat Sukprasert
|
77209694c2 |
feat(acp): support OpenClaw Gateway ACP registration (#3420)
* feat(acp): support per-agent Omnigent MCP toggle Signed-off-by: Pat Sukprasert <pat.sukprasert@databricks.com> * fix(acp): preserve empty MCP session field Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> * fix(acp): honor MCP toggle for embedded agents Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> * fix(acp): validate MCP toggle type Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> * fix(setup): report invalid ACP config Signed-off-by: Pat Sukprasert <pat.sukprasert@databricks.com> --------- Signed-off-by: Pat Sukprasert <pat.sukprasert@databricks.com> Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> |
||
|
Pat Sukprasert
|
fa96f946ef |
✨ feat(sessions): Add shared-message attribution (#3422)
- Preserve trusted authorship across history, buffered turns, and native harnesses - Label model-visible messages while keeping owner credentials authoritative Refs #2150 Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> |
||
|
Zeyi (Rice) Fan
|
355556dff4 |
chore(ci): migrate .github/ci-deps to pnpm and update docs for pnpm dev workflow (#3379)
- Add .github/ci-deps to the root pnpm workspace so it uses the shared pnpm lockfile and install machinery. - Regenerate pnpm-lock.yaml entries for the e2e-ci-deps package. - Replace npm install --ignore-scripts in ci.yml and flake-stress-e2e.yml with pnpm install --frozen-lockfile --ignore-scripts --filter e2e-ci-deps. - Update electron-build.yml to use setup-pnpm and filter installs for web and web/electron. - Update omnidev source so the local dev supervisor installs and runs Vite with pnpm. - Update developer docs (README.md, CONTRIBUTING.md, web/README.md, web/electron/README.md, dev/omnidev/README.md, tests/e2e_ui visual/README.md and COVERAGE_GAPS.md) to reference pnpm commands. - Add a minimal root package.json with packageManager: pnpm@11.15.1 and remove the explicit version from .github/actions/setup-pnpm so CI uses the same source of truth. Signed-off-by: Zeyi (Rice) Fan <zeyi.f@databricks.com> |
||
|
Zeyi (Rice) Fan
|
c7b24b8b05 |
refactor(cli): replace omni server start with omni server --background (#3105)
## Related issue N/A ## Summary - Removes the `omni server start` subcommand. `omni server` already starts the server (in the foreground), so `start` was a redundant way to launch it; the only thing it added was the detached/background mode. - Adds a `--background` flag to `omni server` that reproduces the former `start` behavior: spawn (or reuse) the managed detached local server instead of running uvicorn in the foreground. `omni server stop` / `omni server status` are unchanged. - Updates the desktop app's CLI shell-out, docs, skill files, and tests to the new invocation. ## Test Plan - `omni server start` now exits `2` with "No such command 'start'" (verified via `CliRunner`). - `omni server --background` routes to `ensure_local_omnigent_server()` and short-circuits before the foreground port-bind check; prints the URL and captured log path on spawn, "already running" on reuse, and omits the log line when `log_path` is unknown (3 renamed tests pass). - `omni server stop` / `omni server status` behave as before (verified via CliRunner with stubbed registry). - `server --help` lists `--background` and only the `stop`/`status` subcommands; bare `omni server` still reaches the foreground port-bind check. - `node --check web/electron/src/omnigent_cli.js` passes; the spawn primitive in `host/local_server.py` invokes the bare `omnigent.cli server` foreground command, so it is unaffected by the `start` removal. ## Demo N/A ## Type of change - [ ] Bug fix - [ ] Feature - [ ] UI / frontend change - [x] Refactor / chore - [ ] Docs - [ ] Test / CI - [x] Breaking change ## Test coverage - [ ] Unit tests added / updated - [ ] Integration tests added / updated - [ ] E2E tests added / updated - [x] Manual verification completed - [x] Existing tests cover this change - [ ] Not applicable ## Coverage notes Renamed the three `test_server_start_*` tests in `tests/cli/test_server_lifecycle.py` to `test_server_background_*` (invoking `server --background`); updated comments in `tests/host/test_local_server.py`. Manually verified routing, help output, and the desktop CLI arg via ad-hoc CliRunner/node checks. ## Changelog `omni server start` is removed; use `omni server --background` to launch the detached managed server instead. |
||
|
Zeyi (Rice) Fan
|
e18d7e3dad |
docs(readme): restore Telemetry section, drop Configuration section (#2963)
The Telemetry disclosure section added in #2934 ( |
||
|
Zeyi (Rice) Fan
|
c555ba9cc5 |
feat(config): per-harness startup command/args overrides + OMNIGENT_*_PATH standardization (#2933)
Add a polymorphic `harness:` key in config.yaml — a scalar (legacy) or a mapping with `default` plus per-harness `command`/`args` overrides. The legacy scalar form still works and auto-migrates to the mapping form on the next config write. Harness binary-path precedence: `OMNIGENT_<NAME>_PATH` env var > `harness.<id>.command` config > built-in default. `args` follow the same precedence with config args as the base and CLI pass-through args appended. Env-var standardization: `OMNIGENT_<NAME>_PATH` (base id, `-native` suffix stripped) is the canonical per-binary override, unifying the headless `HARNESS_*_PATH` and native `OMNIGENT_*_PATH` conventions into one namespaced name. The env var keys off the underlying binary, not the harness id, so `claude-sdk` (which runs the `claude` CLI) shares `OMNIGENT_CLAUDE_PATH` with `claude-native`. The legacy `HARNESS_<NAME>_PATH` (codex/pi/kimi/goose/qwen/hermes) is still read as a deprecated fallback — a one-time runner-side log warning when it provides the value, plus a terminal-visible CLI startup notice for interactive invocations. Slated for removal in v0.8.0. The pre-existing `omnigent claude --command` flag is deprecated (warns on use, pointing to `OMNIGENT_CLAUDE_PATH`/config) and will be removed in a future release. No other native command gained a `--command` flag — override via env or config. New module `omnigent/harness_startup_config.py` (leaf resolver, lazy-imports the alias helper): `resolve_harness_config`, `resolve_harness_command`, `resolve_harness_args`, `resolve_harness_path`, `config_harness_path_override`. Config deep-merge of the `harness` mapping across global+local (per-harness sub-keys). Write-side scalar→mapping migration with a one-time stderr notice. `config set harness=<id>` deep-merges into existing overrides; `config list` renders the default + notes overrides. `args` wiring: the 11 native Click commands thread config args as the base with CLI pass-through args appended (via `_resolve_harness_startup_args`). The 7 env-resolver native commands (pi/cursor/kiro/goose/hermes/qwen/kimi) thread `harness.<name>-native.command` config into `OMNIGENT_*_PATH` before `_ensure_backend`. The 5 headless spawn-env builders (codex/pi/kimi/goose/qwen) set `OMNIGENT_*_PATH` from config when ambient env is unset. Signed-off-by: Zeyi Fan <zeyi.f@databricks.com> |
||
|
Zeyi (Rice) Fan
|
5fd0012fae |
docs(readme): add telemetry disclosure section (#2934)
## Related issue N/A ## Summary - Add a **Telemetry** section to the README disclosing that Omnigent collects anonymized usage data by default, with no sensitive or personally identifiable information. - Link to the [Usage Telemetry](https://omnigent.ai/docs/deploy/telemetry) docs page for opt-out instructions, and note that managed-service users should consult their service agreement. ## Test Plan - Previewed the rendered markdown locally; verified the section sits between "Write your own agent" and "Contributing" and the docs link points to https://omnigent.ai/docs/deploy/telemetry. ## Demo N/A ## Type of change - [ ] Bug fix - [ ] Feature - [ ] UI / frontend change - [ ] Refactor / chore - [x] Docs - [ ] Test / CI - [ ] Breaking change ## Test coverage - [ ] Unit tests added / updated - [ ] Integration tests added / updated - [ ] E2E tests added / updated - [x] Manual verification completed - [ ] Existing tests cover this change - [ ] Not applicable ## Coverage notes Docs-only change; verified by reading the rendered README diff. Signed-off-by: Zeyi (Rice) Fan <zeyi.f@databricks.com> |
||
|
Pat Sukprasert
|
03f910e337 | docs: document optional install extras (#2640) | ||
|
Pat Sukprasert
|
b95e41eca8 | feat(cli): add omnigent uninstall workflow (#2550) | ||
|
Pat Sukprasert
|
bc140bc5c0 |
docs(readme): point to the harness test bench (#2349)
* docs(readme): point to the harness test bench The harness test bench (tests/harness_bench/) has no pointer from the root README, so contributors adding or changing harness support can easily miss it. Link to it from the Contributing section alongside the design doc. Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> * Apply suggestion from @PattaraS --------- Signed-off-by: Pat Sukprasert <pattara.sk127@gmail.com> |
||
|
ychamare
|
7fc9cee923 |
feat(desktop): opt-in macOS notification sound, with a turn-end settle (#1864)
The macOS desktop app raised OS notifications when a session needed
attention (a turn finishing, the agent asking for input, a runner
disconnecting) but never played a sound, unlike the iOS app. Add an
opt-in notification sound driven entirely from the desktop shell, and
stop step-by-step agents from sounding on every milestone.
Desktop shell (web/electron/src/main.js):
- New macOS "Notifications" menu: a "Play Notification Sound" toggle
(OFF by default — the user opts in) and a picker of the system sounds
in /System/Library/Sounds (default Glass); selecting one previews it.
Persisted in settings.json, read live so a change applies to the next
notification.
- The notify handler plays the chosen sound via `afplay` in both the
foreground and background — macOS mutes the frontmost app's own
notification sound, so we mute the toast and play it ourselves, audible
either way and never doubled. A per-session throttle guards a burst.
Notification timing + focus (web/src/hooks/useIdleNotifications.ts):
- Defer a turn-end notification by a 10s settle and cancel it if the
session resumes to running, so a multi-step agent that streams
milestones notifies once at the end instead of once per step. A new
elicitation ("needs response") still fires immediately.
- A session is suppressed while the user is actively viewing it (window
focused AND it's the open conversation). Window focus is read from the
authoritative focus/blur events (and any pointer/key interaction) rather
than a polled document.hasFocus(), which the Electron shell could
misreport.
- Skip notifications for a session whose runner is offline: when nothing
is actively running, the only thing that flips a session terminal is the
server reconciling a dead-runner session (a stale `running` dropping to
`failed`/`idle`), not a real completion — so it must not beep. Stops the
phantom beep after the app sits idle with only stale sessions left.
- Beep a session's turn-end at most once until the user views it: a
session that finishes again while its notification is still outstanding
does not ring again. This also collapses the multiple turn-ends a single
async task produces (launching subagents, then reporting back) into one
beep. The mark clears when the user views the session.
Docs: web/electron/README.md (notification, foreground-cue, and menu
bullets) and the README desktop blurb.
Tests: useIdleNotifications.test.tsx covers the settle, the
focus-from-events fix, the offline-runner filter, and the re-notification
dedup. tests/e2e_ui/sessions/test_idle_notifications.py adds a Playwright
test asserting the turn-end settle deferral end to end — a backgrounded
turn-end stays silent through the settle window, then lands exactly once.
Co-authored-by: Isaac
Signed-off-by: Yuri Chamarelli <yuri.chamarelli@databricks.com>
Co-authored-by: Yuri Chamarelli <yuri.chamarelli@databricks.com>
|
||
|
Michael Gardner
|
d80a288a6f |
feat(kiro-native): surface TUI approvals in Chat (#1293)
* feat(kiro-native): surface TUI approvals in Chat Signed-off-by: Michael Gardner <gardnmi@gmail.com> * chore: remove Kiro elicitation plan from PR Signed-off-by: Michael Gardner <gardnmi@gmail.com> * fix(kiro-native): harden permission mirror per review Address review findings on the Kiro permission mirror: - Reap finished web-delivery tasks from the pending map each poll, so a completed *or failed* keystroke delivery frees the single-prompt slot. Previously a failed delivery left the slot occupied forever, silently blocking every later prompt from reaching the web mirror. - Re-validate the visible prompt's focus and title for `accept` after the pre-Enter settle delay (symmetric with the decline path), so a focus or title drift during the settle window fails closed instead of pressing Enter on the wrong row. - Drop the redundant `event.request_id in pending` skip clause (subsumed by the `or pending` guard). - Correct docs/kiro-native-elicitation.md: cancelling a parked task only reliably aborts a verdict still waiting on the web user; a mid-delivery keystroke worker cannot be interrupted, and the per-keypress focus/title re-validation is what prevents a stray verdict from landing on a later prompt. Also document the one-at-a-time / Terminal-only fallback. Adds regression tests for the reaping behavior and the accept re-validation. Co-authored-by: Isaac * fix(test): use a benign completion token in kiro elicitation e2e The approve-path e2e asked Kiro to echo a `kiro-approval-<hex>` token right after a tool-approval prompt. A safety-conscious model reads "reply with this exact token" in an approval context as an attempt to emit a spoofed tool-approval signal and declines, so the turn-complete assertion failed even though the card -> approve -> Kiro-continues loop succeeded. Use a neutral `kiro-pwd-done-<hex>` token and plain framing, matching the render-parity sibling's benign-token pattern. Co-authored-by: Isaac * fix(kiro-native): truncate the title in the elicitation message content_preview was already capped at _PREVIEW_MAX but the card message interpolated the full untruncated title, so untrusted Kiro-derived text could reach the card unbounded. Reuse the truncated preview for both, matching the doc's untrusted-input handling. Co-authored-by: Isaac * fix(test): prove kiro approval continuation structurally, not via token echo Renaming the completion token was not enough: a safety-conscious model refuses the whole pattern of "after the approved command, output this exact token," reading it as an attempt to forge an approval signal, and runs the command but declines to emit the token. Drop the token entirely and assert continuation structurally instead -- after web approve, the gate releases, an assistant reply renders, and the turn finishes (no lingering working indicator). This no longer depends on model compliance or a machine-specific command output. Co-authored-by: Isaac * docs(kiro-native): document the single-slot reaper in race handling The race-handling section described the one-at-a-time slot but not the mechanism that frees it. Note that the slot is released when the delivery task finishes (delivered, failed checks, or timed out), not only on a recorder response, so a stuck verdict cannot wedge the slot for the session. Co-authored-by: Isaac --------- Signed-off-by: Michael Gardner <gardnmi@gmail.com> Co-authored-by: Dhruv Gupta <dhruv.gupta@databricks.com> Co-authored-by: Pat Sukprasert <pattara.sk127@gmail.com> |
||
|
Dhruv Gupta
|
08f85891dd |
docs(readme): refresh for 0.3.0 — harnesses, sandboxes, deploy targets (#1435)
* docs(readme): refresh for 0.3.0 — harnesses, sandboxes, deploy targets Bring the README up to date with the 0.3.0 feature set, scoped to what we fully support: - lead with the harnesses that have full native support in 0.3.0 (Claude Code, Codex, Cursor, Hermes, OpenCode, Pi) across the intro, launch examples, prerequisites, and the agent-YAML `harness:` list; the limited-support natives (kimi, qwen, goose, antigravity, kiro) are no longer advertised as first-class - make the macOS desktop app more visible (tagline + a dedicated bullet) - add Databricks to the cloud-sandbox list - add Railway, Cloudflare, Databricks Apps, and the Cloudflare/Tailscale local-expose paths to the deploy menu - add the AWS Bedrock credential kind - surface MCP tools in "Write your own agent" - drop the cursor/copilot auth-hint comments in the cross-harness example Co-authored-by: Isaac * docs(readme): drop Scribe from the example-agents section Co-authored-by: Isaac * docs(readme): trim launch examples Drop the agent.yaml line from the runtime-launch box and collapse the Polly/Debby cross-harness examples to one generic line each. Co-authored-by: Isaac * docs(readme): drop "AI agent framework" framing, call it just the meta-harness Reverts the SEO framing from #520; Omnigent is described as an open-source meta-harness. Co-authored-by: Isaac * docs(readme): add PyPI version and GitHub tag badges Co-authored-by: Isaac * docs(readme): add Discord badge; swap hero for desktop-app screenshot placeholder Discord invite from omnigent-ai/omnigent-site (components/links.js). Hero now points at docs/images/omnigent-desktop.png (terminal view in the desktop app) — image to be dropped in. Co-authored-by: Isaac * docs(readme): add desktop-app screenshot as the hero image Co-authored-by: Isaac * docs(readme): drop AWS Bedrock from the credentials table Co-authored-by: Isaac * docs(readme): update desktop-app hero screenshot Co-authored-by: Isaac * docs(readme): drop desktop-app bullet, label hermes as "Hermes Agent", refresh hero Co-authored-by: Isaac * docs(readme): trim badges to PyPI, License, Discord, Status Co-authored-by: Isaac |
||
|
Zeyi (Rice) Fan
|
0548405741 | Native Windows support (core / degraded mode) — re-land (#1236) | ||
|
ankushbhatiya
|
cd91556d3c |
feat: add Kimi Code as a harness (#271) (#521)
* feat(kimi): add Kimi Code CLI as a harness (#271) Wires Moonshot AI's upstream Kimi Code CLI (https://github.com/MoonshotAI/Kimi-Code) into Omnigent as a first-class harness alongside Claude Code, Codex, Cursor, Pi, and Antigravity. One ``kimi -p <prompt> --output-format stream-json`` subprocess per Omnigent turn parses the JSONL transcript on stdout, captures the kimi session id from the ``role:"meta"`` event for ``-S <id>`` resume on the next turn, and uses the subprocess's ``cwd=`` for the working directory (upstream has no ``--work-dir`` flag). Only the upstream curl-installed ``kimi`` binary is supported. The legacy pypi ``kimi-cli`` package is intentionally NOT detected — its command-line surface (``--print``, list-of-blocks content, etc.) is incompatible with the upstream binary the issue targets. What landed: - ``omnigent/inner/kimi_executor.py`` — Inner executor. ``handles_tools_internally=True`` (Kimi runs its own bash/edit/read tools); supports session resume, ``-C`` continue-last, ``--plan``, ``--skills-dir`` (repeatable), per-spawn model override via env-var contract. - ``omnigent/inner/kimi_harness.py`` — FastAPI wrap via ``ExecutorAdapter`` with env-driven lazy executor construction. - Runtime/registry: ``omnigent/runtime/harnesses/__init__.py`` registers ``kimi`` + ``kimi-code`` alias; ``omnigent/spec/_omnigent_compat.py`` allowlist; ``omnigent/harness_aliases.py`` canonicalisation; ``omnigent/runtime/workflow.py`` ``AgentHarnessType`` entry + minimal ``_build_kimi_spawn_env`` (emits MODEL + CWD only — upstream kimi has no per-spawn provider override, so a spec declaring provider/Databricks auth now raises loudly). - CLI/onboarding: ``omnigent kimi`` subcommand (shortcut for ``run --harness kimi``), default system prompt entry, ``_CLICK_SUBCOMMANDS`` allowlist, first-run plan fallback gated on ``kimi`` binary presence, ``KIMI_KEY`` install spec with curl install_hint and ``kimi login`` argv, ``KIMI_SURFACE`` readiness wiring. - Model layer: ``model_override``, ``model_catalog`` identity entry, ``runner/app.py`` model env key + spawn-env dispatch. - Frontend: ``ap-web/src/components/AgentCard.tsx`` fall-through comment (BotIcon for now; dedicated glyph deferred). - Tests: ``tests/inner/test_kimi_harness.py`` (38 cases covering registry, FastAPI routes, env-var factory, argv builder for upstream syntax, event translator for content-as-string + ``role:"meta"`` session capture + stderr fallback, capability flags, run-turn with stubbed subprocess, session resume, tools-without-bridge warning). Spawn-env tests in ``tests/runtime/test_provider_spawn_env.py``; readiness + install-spec tests; ``tests/cli/test_cli.py`` stubs the kimi binary check so first-run-plan tests stay deterministic. - Docs: ``README.md`` mentions, ``docs/AGENT_YAML_SPEC.md`` Kimi section, ``examples/kimi_hello.yaml`` single-file launcher, ``docs/KIMI_FOLLOWUPS.md`` enumerating deferred work (Omnigent-side provider injection + MCP tool bridge via the ``kimi acp`` ACP server, native TUI in a tmux pane, dedicated glyph, multimodal/video input, mid-turn interrupt, token usage, spec-level plan/thinking fields, built-in agent specs). - E2E: ``tests/e2e/test_kimi_executor_e2e.py`` gated on ``OMNIGENT_E2E_KIMI=1`` + ``kimi`` on PATH. Resolves #271. Signed-off-by: Ankush Bhatiya <ankushb@gmail.com> * fix(kimi): address PR review — auth/sandbox/adapter/stream-limit Incorporates the Polly review on #521: - B1: drop unrelated `databricks_supervisor` from the harness allowlist (passed validation but had no module/builder, crashing at spawn). - B2: reject declared `executor.auth` in `_build_kimi_spawn_env` (upstream kimi has no per-spawn provider override). Removed the unreachable raises in `configure_agent_harness_with_provider` (never called for kimi). - B3: serialize `spec.os_env` into `HARNESS_KIMI_OS_ENV` and apply a platform sandbox launcher in `KimiExecutor` (mirrors qwen) so kimi's in-process tools run confined when the spec requests it. - B4: add `Executor.forwards_observed_tool_results()` (True for kimi) so the adapter forwards self-contained tool-loop results instead of suppressing them as dispatched-tool duplicates. - B5: pass a 16 MiB stdout `limit=` so large JSONL lines don't overrun asyncio's 64 KiB default and crash the turn. - Non-blocking: drop the random-UUID session-id fallback; leave it None so a missed resume hint starts a fresh session instead of passing an id upstream may reject. Adds tests for each and updates docs/KIMI_FOLLOWUPS.md. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(kimi-native): native Kimi Code TUI harness with web-UI transcript + tool approval Add the kimi-native harness: `omni kimi` launches the interactive kimi TUI in a tmux pane embedded in the web UI (mirrors cursor-native), alongside the existing headless SDK `kimi` harness (kept for sub-agent / `run --harness kimi` use). - harness: kimi_native + bridge/executor/credentials/hook; runner terminal auto-create, interrupt/stop, and registry/alias/onboarding/model-catalog wiring - transcript forwarder: tail the kimi wire.jsonl and mirror user/assistant turns into the chat, so replies render in the web UI (not just the embedded pane) - interactive tool approval: the PermissionRequest hook publishes the web-UI approval card and types the verdict (Approve once / Reject) into the TUI - Kimi glyph (@lobehub/icons), `omni setup` drill-in, and new-session picker dedup (native TUI only; the SDK kimi agent is hidden from the picker) Co-authored-by: Isaac * fix(kimi-native): web-UI approvals, working dir, latency, icon Round of fixes from live-testing the native + SDK Kimi harnesses: - Approvals: the shared PermissionRequest endpoint hard-coded an ``elicit_claude_`` id regex, 400-ing every kimi hook POST so the approval card never published. Generalize to ``elicit_<harness>_``. Add ``timeout = 600`` to the kimi hooks (kimi kills hooks at 30s, severing the approval long-poll) and ``-I`` to the hook command (kimi runs hooks with cwd=workspace; a workspace with its own ``omnigent/`` shadowed the install and the hook died on ImportError). - Working directory: ``omni --harness kimi`` now runs the SDK kimi in the launch folder, matching claude. Add ``kimi`` to ``_OS_ENV_HARNESSES`` (launcher os_env block), make the harness wrap fall back to ``OMNIGENT_RUNNER_WORKSPACE``, and — the real fix — thread the session workspace ``cwd`` (not the /tmp bundle workdir) into ``HARNESS_KIMI_CWD`` in ``_build_kimi_spawn_env``, mirroring pi. - Latency: bring the forwarder poll (0.7→0.25s), bridge poll (0.2→0.15s), paste settle (0.3→0.1s) and send timeout (10→5s) to claude-native parity; replace the unverified ``_settle_pane`` idle markers (carried over from cursor-native, never matched, so every web→TUI injection ate the full 30s readiness timeout) with the real K2.7 footer marker ``context:``. - Icon: SubagentsPanel branded SDK-harness sessions (no wrapper label) as the generic bot; add a harness-substring fallback mirroring AgentCard so ``omni --harness kimi`` shows the Kimi glyph. - Docs: remove docs/KIMI_FOLLOWUPS.md and reword the 11 code comments that pointed at it (the deferred work stays noted inline). Co-authored-by: Isaac * fix(kimi): use os.environ.copy() for subprocess env (exfil-scan) The CI exfil scanner blocks the `dict(os.environ)` shape in added lines (wholesale-environ-dump heuristic). The native wrappers legitimately copy the environment for the subprocess they spawn — the grandfathered claude/codex/pi/cursor/opencode wrappers all do the same. Switch the two new kimi sites to the idiomatic `os.environ.copy()`, which is identical behavior and doesn't trip the heuristic. Co-authored-by: Isaac * test(e2e-ui): cover Kimi native picker + SDK-kimi dedup Adds the Playwright e2e_ui coverage the E2E UI Required gate asked for on the new user-visible Kimi UI: - test_start_session_kimi_native_picker_and_wrapper_labels: the picker renders the harness-derived label "Kimi" (not the raw "kimi-native-ui"), and create POSTs the terminal-first wrapper labels (omnigent.ui: terminal + omnigent.wrapper: kimi-native-ui). - test_start_session_picker_hides_sdk_kimi: with both the native and SDK kimi rows in the catalog, the picker offers only the native row and drops the SDK `kimi` (NEW_SESSION_HIDDEN_AGENTS) — one "Kimi" to pick. Mirrors the existing pi/opencode/antigravity native-agent tests. Both pass locally against a spawned server + chromium. Co-authored-by: Isaac * test(e2e): cover kimi in the example + live-harness drift guards Two backend e2e drift guards failed because the kimi PR added the `kimi`/`kimi-native` harnesses + examples/kimi_hello.yaml without updating them: - test_examples_coverage_sync: allowlist `kimi_hello` (SDK-kimi launcher YAML) — covered by tests/inner/test_kimi_harness.py + the picker e2e_ui suite; a live round-trip needs the kimi CLI + Moonshot auth (not in CI). Same shape as the qwen_perm_test entry. - test_run_harness_live_matrix: exclude `kimi` (needs the kimi CLI + Moonshot auth, like hermes) and `kimi-native` (terminal-first TUI via `omni kimi`, like kiro-/qwen-/goose-native) from the live gateway probe matrix, with docstring rationale mirroring the existing exclusions. Both pass locally. Co-authored-by: Isaac --------- Signed-off-by: Ankush Bhatiya <ankushb@gmail.com> Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: aravind-segu <aravind.segu@databricks.com> |
||
|
Michael Gardner
|
6f0257dbc7 |
feat(kiro): add native CLI harness (#899)
* feat: add Kiro native CLI harness Signed-off-by: Michael Gardner <gardnmi@gmail.com> * fix(kiro): avoid ambient env in tmux attach Signed-off-by: Michael Gardner <gardnmi@users.noreply.github.com> * fix: restore uv.lock pypi.org sources (drop accidental databricks-proxy re-lock) A local `uv run` during the merge re-locked uv.lock against this machine's Databricks-internal pypi proxy, flipping every package source URL. Kiro changes no dependencies and pyproject.toml is unchanged vs main, so restore main's uv.lock verbatim (pypi.org sources). Only registry URLs differed — no version or hash changes. Co-authored-by: Isaac * test(e2e-ui): add native-kiro render-parity suite (E2E UI Required gate) The E2E UI Required gate flagged that #899 changes the agent-picker/session UI (adds Kiro) without a tests/e2e_ui/** test. Add test_native_kiro_render_parity.py mirroring the cursor/goose siblings — composer-IN parity, a TUI-originated turn surfacing OUT, and no duplicate rendering — plus the native_kiro_session fixture. Skip-gated on kiro-cli + tmux, so it skips in CI (no Kiro account provisioned) exactly like the goose/cursor suites, and runs for real where Kiro is signed in. Verified: collects + skips cleanly (kiro-cli absent); ruff clean. Co-authored-by: Isaac * fix: restore ap-web/package-lock.json npmjs.org sources (drop databricks npm-proxy) Same root cause as the uv.lock fix: an npm command during round-1 merge re-resolved one dependency (yaml-1.10.3) against this machine's Databricks-internal npm proxy (npm-proxy.cloud.databricks.com), which CI (pinned to registry.npmjs.org) can't reach -> 'npm ci' ETIMEDOUT. ap-web/package.json is unchanged vs main and Kiro adds no npm dependency, so restore main's package-lock.json verbatim (clean npmjs.org sources). Co-authored-by: Isaac * test(e2e): exclude kiro-native from the live-harness matrix coverage check test_run_harness_live_matrix_covers_registered_coding_harnesses asserts every registered coding harness is either in the live no-AGENT e2e matrix or explicitly excluded. kiro-native is a terminal-first TUI launched via `omni kiro` (tmux pane + bridge dir), not `omnigent run --harness kiro-native`, so — like goose-native / qwen-native / cursor-native — it can't run in this matrix. Add it to the exclusion set with the matching rationale; its coverage is the kiro-native bridge/executor/ forwarder unit tests + the test_native_kiro_render_parity e2e_ui suite. Co-authored-by: Isaac * test(ap-web): set isNativeWrapper in /compact composer menu tests #1139 gated "/compact" behind isNativeWrapper (hidden for non-native harnesses), but the three slash-menu-UX tests that assert "/compact" tops/appears in the suggestions still rendered a non-native composer, so they now fail on main (and on every PR that merges main). Render those three with isNativeWrapper:true so "/compact" is offered, restoring the built-in ordering the tests pin. Test-only; no behavior change. Fixes the inherited ChatPage.composer.test.tsx red on this PR. Co-authored-by: Isaac * test(kiro): cover kiro_native launcher helpers (raise coverage 43%→70%) The kiro-native launcher (omnigent/kiro_native.py) was the largest coverage gap on this PR: its CLI/daemon orchestration is only exercised by the live render-parity e2e, which skips in CI when kiro-cli is absent. Add focused unit tests (with a fake httpx client) for the unit-testable surface: executable resolution, launch-argv assembly, terminal-payload decoding, tmux attach gating, startup-progress forwarding, preflight, resume-id resolution, and the create/fetch/ ensure/find/wait session helpers (success + error branches). Lifts kiro_native.py from 43% to 70%; remaining misses are the daemon-driven async orchestration covered by runner/e2e paths. Co-authored-by: Isaac * test(kiro): rename test env var to avoid exfil-scan false positive The CI exfil scanner flags any added file containing a secret-named source (regex `[A-Z0-9]+_SECRET\b`) together with a network sink. The tmux-allowlist test used `OMNIGENT_SECRET` purely as a non-allowlisted sample var, which matched the secret regex and — combined with the fake httpx client's .post()/.get() in the same file — tripped the "secret-named source + network sink" block. Rename it to a neutral `OMNIGENT_UNLISTED_VAR`; the test's intent (filtering non-allowlisted keys) is unchanged. Co-authored-by: Isaac --------- Signed-off-by: Michael Gardner <gardnmi@gmail.com> Signed-off-by: Michael Gardner <gardnmi@users.noreply.github.com> Co-authored-by: Pat Sukprasert <pattara.sk127@gmail.com> |
||
|
Corey Zumar
|
3804401b20 |
docs(readme): list all sandbox providers in the cloud-sandboxes highlight (#1184)
The highlight listed only Modal / Daytona / Islo. Add the other launchers that ship in the repo -- E2B, CoreWeave, Kubernetes, OpenShell, Boxlite -- as uniform peers in the list, each linked to its canonical site. The Kubernetes provider (server-managed on-demand Pods) landed in #881. Signed-off-by: dbczumar <corey.zumar@databricks.com> |
||
|
Serena Ruan
|
cfb05db785 |
Revert "Native Windows support (core / degraded mode) (#1109)" (#1129)
This reverts commit
|
||
|
Zeyi (Rice) Fan
|
c11c6a38d1 |
Native Windows support (core / degraded mode) (#1109)
* feat(platform): add cross-platform process + platform primitives Introduce two dependency-light foundation modules for native Windows support: - omnigent/_platform.py: IS_WINDOWS/IS_POSIX/IS_LINUX/IS_DARWIN flags, default_shell_argv() (cmd.exe on Windows, bash/sh on POSIX), and stable_user_id() (uid on POSIX, hashed login name on Windows). - omnigent/inner/_proc.py: spawn_kwargs() (start_new_session on POSIX, CREATE_NEW_PROCESS_GROUP on Windows), terminate_tree()/kill_tree() (process-group fast path on POSIX, psutil descendant walk everywhere), and process_alive() replacing os.kill(pid, 0). psutil is already a core dependency, so no new packages. POSIX-only symbols (os.killpg/getpgid, signal.SIGKILL) are resolved via getattr so the module imports and type-checks on Windows. No call sites switched yet; later phases migrate to these helpers. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): stop POSIX import-time crashes so the package loads On Windows several modules crashed at import before anything could run, blocking `import omnigent`, `omnigent --help`, and `omnigent server`. - server/performance_metrics.py: make `import resource` optional and fall back to psutil (a core dep) for RSS on Windows; load average already degrades to None. - terminals/ws_bridge.py, claude_native.py: guard the POSIX-only fcntl/pty/termios/tty imports behind `sys.platform != win32` (mypy special-cases this and still type-checks them on the Linux CI). These drive the tmux/PTY terminals, which are disabled on Windows. - Replace module-level / core-path `os.getuid()` namespacing with _platform.stable_user_id() and `/tmp`/`TMPDIR` with tempfile.gettempdir() in claude_sdk_executor (core SDK path) and the cursor/goose/claude native bridges; guard the POSIX ownership check in claude_native_bridge. Verified: a full walk of every omnigent submodule reports zero POSIX import failures; `import omnigent`, `omnigent --help`, and importing server.app / runner.app / the harness manager all succeed on Windows. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(windows): route process spawn/kill/liveness through _proc Replace POSIX-only process management with the cross-platform _proc helpers so child agent/server/runner processes spawn, tear down, and are probed correctly on Windows. - Spawning: swap `start_new_session=True` (and the os.name-conditional variant) for `**_proc.spawn_kwargs()`, which yields start_new_session on POSIX and CREATE_NEW_PROCESS_GROUP on Windows. Sites: cli.py (×2), chat.py, host/local_server.py, codex_executor, codex_native_app_server, runner transports tcp/uds, update_check. - Teardown: replace os.killpg-based `_terminate/_kill_process_tree` and the transport `_kill()` paths with _proc.terminate_tree/kill_tree (process-group fast path on POSIX, psutil descendant walk everywhere). - Liveness: replace `os.kill(pid, 0)` probes with _proc.process_alive. This was an outright bug on Windows, where os.kill(pid, 0) maps to TerminateProcess and would KILL the probed process — including the parent-death watchdogs in runner/_entry and runtime/harnesses/_runner, and process_manager's orphan sweep. - Guard the remaining force-kill signal refs with getattr(signal, SIGKILL, signal.SIGTERM) for the bare-pid kill paths in cli.py and host/local_server.py. Remaining live SIGKILL/os.kill(pid,0) sites are POSIX-gated only (the tmux PTY ws_bridge and the Linux-only prctl). Verified: process_alive probes a live process without killing it; all touched modules import on Windows; ruff clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(windows): TCP-loopback server<->harness IPC; disable egress proxy The harness process manager talked to each conversation subprocess over a Unix-domain socket, which asyncio's Proactor loop cannot provide on Windows. Introduce a transport abstraction so the same manager works on both platforms. - process_manager.py: add `_HarnessEndpoint` encapsulating UDS (POSIX) vs TCP-loopback (Windows) — spawn flags, readiness probe, httpx wiring, and cleanup. `_HarnessEndpoint.create` picks UDS on POSIX and a free 127.0.0.1 port on Windows. `_wait_for_socket_bind` -> `_wait_for_bind` probes the endpoint generically; `_SubprocessEntry` now carries the endpoint. - _runner.py (child): accept `--bind host:port` alongside `--socket`, and configure uvicorn with host/port or uds accordingly. - egress/controller.py: fail loud when an agent requests L7 egress rules on Windows (the proxy is a Unix-socket MITM listener with no Windows analog). POSIX is unchanged (still UDS; the public socket_path() returns the same path the endpoint binds). Verified end-to-end on Windows: a real _runner child binds TCP loopback, _wait_for_bind detects readiness, and an httpx request over the TCP transport returns 200. process_manager unit tests pass (3/3). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(windows): windows_jobobject sandbox backend (process containment) Add a Windows platform-default sandbox backend that contains the helper process tree via a kernel Job Object, since Windows has no bwrap/seatbelt equivalent. - New SandboxBackend.post_spawn(policy, pid) hook (default no-op): acts on an already-running pid, the model Job Objects require (a process is assigned to a job only after it exists). Returns a ContainmentHandle the parent holds and closes on teardown. - New windows_jobobject_sandbox.py: CreateJobObject + JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE + AssignProcessToJobObject via ctypes/kernel32 (no new dependency). resolve() returns an active policy and warns once that this backend does NOT isolate filesystem/network (read/write/allow_network are advisory on Windows); activate() is a no-op. Degrades gracefully (logs, returns None) if the Win32 calls fail (e.g. a non-nestable parent job in CI). - sandbox.py: register windows_jobobject and make it the Windows platform default; an explicit linux_bwrap/darwin_seatbelt still errors loudly on Windows. The backend module is imported only on Windows (it touches ctypes.windll) to keep the POSIX import graph untouched. - os_env.py: after Popen, call post_spawn for active policies and store the handle; close it in _stop_locked so kill-on-close reaps any descendants that outlive proc.terminate(). Verified on Windows: default resolves to windows_jobobject; an explicit linux_bwrap errors; and assigning a live process to the job then closing the handle terminates it (kill-on-close). POSIX is unchanged (the launcher backends keep the no-op post_spawn default). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(windows): disable native terminals, cross-platform shell, packaging Phase 5-7 of native Windows support. - Native terminals: gate create_terminal_instance (the tmux/PTY chokepoint) and the `omnigent claude`/`codex`/`cursor` CLI commands behind a clear, actionable Windows error pointing to the SDK harnesses / web UI, instead of letting them crash on tmux/PTY. - Shell: make os_env._shell_argv and the shell_path fallback Windows-aware (cmd.exe uses /c, PowerShell uses -NoProfile -Command; POSIX bash/sh unchanged), and route model_catalog's provider auth_command (a core auth path) through _platform.default_shell_argv instead of a hardcoded /bin/sh. - Packaging: mark pexpect/pyte (POSIX PTY libs, never imported on the core path) as `platform_system != 'Windows'`, and document the native Windows install path (uv) plus its degraded-mode caveats in the README. Verified on Windows: _shell_argv emits correct argv per shell; the native terminal entrypoint and create_terminal_instance both reject with the actionable message; all touched modules import. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(windows): platform skip markers, primitives tests, Windows CI - Add posix_only / windows_only pytest markers and auto-skip wrong-OS tests in tests/conftest.py (keys off os.name). Keeps the Linux suite unchanged and lets a Windows run skip POSIX-only tests cleanly. - New tests/inner/test_proc_and_platform.py covering _platform flags + shell argv, _proc spawn/terminate/liveness (incl. the non-destructive probe regression), the UDS/TCP harness endpoint, and the windows_jobobject backend (default selection + kill-on-close + fail-loud bwrap), gated by platform markers. - New non-blocking .github/workflows/windows.yml: installs via uv, asserts import omnigent and omnigent --help, runs the Windows-support unit tests as a hard gate, and a broader not-posix_only sweep as continue-on-error. Not wired into merge-ready, so it does not block. - Regenerate uv.lock for the pexpect/pyte platform markers (normalizer check passes); needed so the existing locked uv sync CI stays green. Verified on Windows: the hard CI test set passes (16 passed, 1 skipped). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * style: ruff-format windows_jobobject_sandbox.py Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): force web-ui asset MIME types so the SPA loads Starlette StaticFiles derives Content-Type from mimetypes.guess_type, which on Windows reads the registry, where .js is commonly mapped to text/plain. Browsers then refuse to execute the bundled SPA ES modules (disallowed MIME type), so omnigent server served a blank web UI on Windows. Register the web asset types .js/.mjs/.css/.json/.map/.wasm/.svg explicitly at server import via mimetypes.add_type. Harmless and deterministic cross-platform; removes the dependency on the host MIME registry. Verified on Windows: a real built assets/*.js now serves as text/javascript through the actual _SPAStaticFiles path (was text/plain). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): dereference Git-symlink example bundles on no-symlink checkout The bundled polly/debby example agents are Git symlinks under omnigent/resources/examples pointing at the top-level examples dir. On a Windows checkout with core.symlinks false (Developer Mode off / Git not elevated), Git materializes each symlink as a regular text file whose content is the link target. The spec loader then read the stub instead of the agent directory and failed to parse it as a YAML mapping. Re-checking out with symlink support needs Developer Mode or admin, so fix it at runtime: add _platform.resolve_repo_symlink, which on Windows detects a small single-line regular file whose content resolves to an existing path (the Git-symlink stub shape) and returns the real target; a no-op for real dirs/files, multi-line or unresolvable content, and off Windows. Apply it in cli._bundled_example_path and the server polly/debby bundle sources. Verified on Windows: the polly example now resolves to the real examples/polly directory with config.yaml. Added windows_only unit tests for the stub dereference and the leave-real-specs-untouched guard. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): pass Windows system env vars to sandboxed helpers A sandboxed os_env helper is spawned with a deny-by-default env allowlist (build_helper_env). The allowlist was POSIX-only (PATH/HOME/USER/...), so on Windows the child got no SYSTEMROOT. Winsock loads its providers from %SystemRoot%\system32\mswsock.dll, so the helper died at import asyncio with WinError 10106 (WSAEPROVIDERFAILEDINIT). Because windows_jobobject makes the sandbox active by default, this hit every agent that runs an os_env helper on Windows. Add the non-sensitive Windows system constants to the passthrough allowlist: SYSTEMROOT (mandatory for Winsock), plus SYSTEMDRIVE, WINDIR, COMSPEC, PATHEXT, NUMBER_OF_PROCESSORS, and PROCESSOR_*. Python uppercases env keys on Windows, so the names match os.environ as stored; they are absent on POSIX, so listing them is a no-op there (only present vars pass through). The security posture is unchanged - these are system constants, not credential-bearing. Verified on Windows: build_helper_env for an active sandbox now contains SYSTEMROOT, and a child spawned with that env imports asyncio cleanly (was WinError 10106). Added a windows_only regression test. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): pass USERPROFILE/home + appdata to spawned subprocesses The host->runner spawn (and the os_env helper spawn) filter the environment through a POSIX-centric allowlist. After SYSTEMROOT was added, the runner got past import asyncio but then crashed at Path.home with Could-not-determine-home-directory, because on Windows that needs USERPROFILE (or HOMEDRIVE+HOMEPATH), the analog of POSIX HOME which is already allowed. Consolidate the Windows passthrough set into _platform.WINDOWS_ENV_PASSTHROUGH (system constants plus USERPROFILE/HOMEDRIVE/HOMEPATH plus APPDATA/LOCALAPPDATA) and reference it from both os_env._DEFAULT_ENV_PASSTHROUGH and host.connect._RUNNER_ENV_ALLOWLIST, so the two allowlists can no longer diverge. All are non-sensitive path/identity constants, consistent with HOME/PATH already being allowed; absent on POSIX so a no-op there. Verified on Windows: the host runner env now carries SYSTEMROOT and USERPROFILE, and a child spawned with it imports asyncio, resolves Path.home, and imports ClaudeSDKExecutor. Extended the windows_only regression tests. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): use the real temp dir for the harness instance dir The harness process manager pinned its instance/socket parent to the literal /tmp/omnigent, which on Windows resolves to \tmp\omnigent on the current drive (the symptom: instance_dir=\tmp\omnigent\ap-... in the logs). Keep /tmp/omnigent on POSIX (Unix socket paths have a tight length limit and gettempdir can be a long /var/folders path on macOS), but on Windows use tempfile.gettempdir()/omnigent. Windows uses TCP loopback for the harness IPC, so there is no socket-path length concern there. Verified: _default_tmp_parent() now resolves under %LOCALAPPDATA%\Temp\omnigent on Windows. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(windows): stop parent-death watchdog from killing the runner instantly The runner spawned by the host daemon exited cleanly (code 0) the moment it finished startup. Cause: the parent-death watchdogs treat a getppid() mismatch as the parent having died. On POSIX that is a reliable, PID-reuse-proof signal (orphans reparent to init). On Windows there is no reparenting AND os.getppid() is unreliable: the venv interpreter launcher breaks the parent link, so a spawned child reports a getppid that does not match its spawner (measured: child 15880 vs spawner 19852). So the getppid check fired immediately, the killer requested graceful shutdown, and the runner tore itself down right after HarnessProcessManager started. On Windows, skip the getppid heuristic and rely solely on an explicit liveness probe of the passed-in parent_pid (_proc.process_alive, psutil). Fixes both watchdogs: runner._entry._parent_is_orphaned and runtime.harnesses._runner parent watchdog. Verified on Windows: _parent_is_orphaned(<live pid>) is False (runner stays up) and True for a dead pid. Added a windows_only regression test. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(windows): actionable client error when a native terminal is used A claude/codex/cursor-native (tmux/PTY) agent run on Windows hits the create_terminal_instance guard and surfaces a generic see-runner-logs banner in the web UI. Make the client-facing message Windows-aware: tell the user native terminals are not supported on Windows and to use an SDK harness (claude-sdk/cursor/copilot/codex) or run on Linux/macOS. The full cause is still logged for operators. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(security): use SHA-256 (not SHA-1) for the user-id namespacing digest CodeQL flagged stable_user_id() for hashing the login name with SHA-1. The digest is only used to namespace per-user scratch directories (a filesystem-safe token), not for security, but switch to SHA-256 with usedforsecurity=False to document intent and clear the weak-algorithm finding. Output is still a 12-char hex token; behavior is otherwise unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore: address code-quality review comments - _proc._ProcessLike and sandbox.ContainmentHandle: give the Protocol methods pass bodies instead of bare ellipsis (clears the statement-has-no-effect finding). - windows_jobobject_sandbox: import ctypes.wintypes as a submodule import rather than mixing a plain ctypes import with a from-ctypes-import (clears the dual-import-style finding). - windows_jobobject_sandbox: replace the module-level warned flag plus global statement with a functools.cache one-time warner (clears the unused-global-variable finding; behavior unchanged, the caveat is still logged exactly once per process). ruff and mypy clean; tests/inner/test_proc_and_platform.py 18 passed, 1 skipped. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(runtime): restore _pid_alive POSIX semantics (zombie counts as present) Phase 2 of this PR switched process_manager._pid_alive from os.kill(pid, 0) to the psutil _proc.process_alive probe. Those differ for a killed-but-not- yet-reaped process: os.kill(pid, 0) reports the zombie as present, psutil reports it as dead. That broke test_get_client_respawns_after_crash (and risked ~17 other call sites): the test SIGKILLs a harness and waits on not _pid_alive(pid) as a proxy for fully-reaped, which is the moment the asyncio child watcher sets the subprocess returncode and get_client respawns. With zombie-as-dead the wait returned at the zombie stage, before the reap, so get_client saw returncode None, did not respawn, and the first request to the dead client raised httpx.ReadError every time. _pid_alive answers is-this-PID-present-in-the-table (the os.kill idiom); _proc.process_alive answers is-this-a-live-non-zombie-process (liveness, used by the parent-death watchdogs). They are different predicates. Restore os.kill(pid, 0) on POSIX for _pid_alive (exact pre-PR behavior; its only production caller, the orphan sweep, checks non-child PIDs where zombies never occur) and keep psutil only on Windows, where os.kill(pid, 0) would map to TerminateProcess. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> |
||
|
Sabhya Chhabria
|
ae774b8f79 |
feat(harness): add GitHub Copilot SDK harness (#330)
* feat(harness): add GitHub Copilot SDK harness
Add a first-party `harness: copilot` that drives the GitHub Copilot SDK
(`github-copilot-sdk`), mirroring how the cursor and antigravity SDK
harnesses are wired. The Python SDK bundles the Copilot CLI binary it
drives as a backing server, so the harness needs only the pip dependency
(optional `copilot` extra, lazy-imported) — no separate CLI install.
- `omnigent/inner/copilot_executor.py`: `CopilotExecutor` — one persistent
`CopilotClient` + `CopilotSession` per conversation, streaming
`SessionEvent`s into ExecutorEvents (text/reasoning deltas, tool
execution, usage). Omnigent `sys_*` tools bridge in-process via SDK
`Tool`s whose async handler routes to `_tool_executor` (awaited in the
SDK's own loop — no thread hop). PHASE_LLM_REQUEST/RESPONSE policy parity.
- `omnigent/inner/copilot_harness.py`: the `create_app()` wrap reading
`HARNESS_COPILOT_*` env vars.
- `omnigent/onboarding/copilot_auth.py`: a GitHub token store (dedicated
`copilot:` config block + secret store), resolved like the cursor key.
- Wiring: harness registry, spec allowlist + `github-copilot` alias,
spawn-env builder, runner dispatch + model-env map, model-override set,
readiness check, `omnigent setup` management, ap-web label, docs.
- Auth: a GitHub token with Copilot access (fine-grained PAT w/ "Copilot
Requests", or a gh/Copilot-CLI OAuth token). No Databricks gateway path.
- `pyproject.toml` / `uv.lock`: `copilot` extra (`github-copilot-sdk>=1,<2`).
- Tests: executor (fake-SDK), harness wrap, spawn-env, auth; readiness
test updated for the new spellings.
Verified end-to-end against a local server: a standalone copilot agent,
an agentic file create/read tool loop, and polly + debby running their
orchestrator brain on `--harness copilot`.
Co-authored-by: Isaac
* fix(copilot): reap CLI on start failure + don't mask mid-turn errors; add e2e skill
Fixes found by a live multi-agent bug-bash of the copilot harness:
- HIGH: `client.start()` ran outside the cleanup try/except, so a start
failure (bad token, version skew) dropped the only reference to the
client without stopping it — orphaning the bundled Copilot CLI subprocess
(the SDK only reaps it in `stop()`, never on a start error path). Moved
`start()` inside the try so `_safe_stop(client)` covers it.
- LOW: a `SESSION_ERROR` / `MODEL_CALL_FAILURE` arriving after partial text
streamed was masked — the turn was reported as a clean `TurnComplete`
with the partial text. Now surface it as an `ExecutorError` whenever the
SDK returned no successful final message, even if some text streamed.
- Document the known limitation (parity with cursor): Copilot's *native*
tools (create/view/edit/bash) run inside the SDK, so they bypass
`on:[tool_call]` policies and leave no transcript item; bridged `sys_*`
tools are gated + recorded. Gate built-ins at the LLM phase or sandbox.
- Add the `copilot-sdk-e2e-dev` skill (parity with cursor/antigravity),
capturing the test recipe and the bug-bash's known sharp edges.
- Tests: cover the start-failure teardown and the mid-turn-error-not-masked
paths.
The bug-bash also surfaced two pre-existing, harness-agnostic issues left
out of scope (native-tool transcript items in the shared executor adapter;
top-level `policies:` silently dropped in the shared spec parser).
Co-authored-by: Isaac
* test(copilot): address review findings + prove polly-on-copilot brain e2e
Adversarial swarm review + live polly e2e of the Copilot SDK harness
surfaced small correctness fixes and coverage gaps; this addresses them
and adds durable e2e coverage for copilot as polly's orchestrator brain.
Code fixes:
- copilot_executor: unwrap the SDK's structured TOOL_EXECUTION_COMPLETE
error ({"message","code"}) and result wrapper ({"content",...}) so the
tool error/result carry the payload, not a Python dict repr.
- cli: list `copilot` in the --harness help text (parity with peers).
Tests (executor): policy-deny gates (PHASE_LLM_REQUEST/RESPONSE), session
restart on tool/model change, mid-turn send_and_wait failure (retryable +
recreate), tool-result unwrap + BLOCKED/CANCELLED classification, interrupt,
empty-prompt, no-tool-executor branch, paragraph break, cache_read accumulation.
Tests (harness wrap): assert real adapter routes + os_env/bundle_dir/ambient
token. Tests (auth): inline github_token + dangling keychain ref.
E2E:
- add gated real-network tests/e2e/test_polly_copilot_e2e.py (polly brain on
--harness copilot; skipped without a Copilot token, like the CLI probes).
- document the polly-brain recipe in the copilot-sdk-e2e-dev skill.
- exclude copilot from the gateway-auth live-matrix coverage test (it auths
via a GitHub token, no Databricks gateway — same as cursor/antigravity).
Also fix model_override.py formatting (ruff).
Co-authored-by: Isaac
|
||
|
Enes Yilmaz
|
7408e09a1f |
feat(examples): add Scribe documentation orchestrator (#1060)
Scribe is the docs counterpart to Polly: a documentation orchestrator that turns change context (git diff, commit history, PRs) into release notes, changelogs, and migration guides. It authors prose itself and delegates only read-only code investigation. The bundle adds a claude-sdk orchestrator, a read-only researcher sub-agent (claude-sdk), a cross-vendor reviewer sub-agent (codex) for an optional fact-check, three doc skills (changelog, migration-guide, api-docs), a structural test mirroring test_example_debby.py, and a README mention. Closes #110 Signed-off-by: Enes Yilmaz <enesyilmaz5157@gmail.com> |
||
|
Serena Ruan
|
54c5382a31 |
feat: Add Qwen Code as a harness (rebased + hardened #818) (#1020)
* feat(harness): add Qwen Code support
- Add qwen_executor.py: RPC-mode executor that spawns 'qwen --mode rpc'
and communicates via JSONL protocol
- Add qwen_harness.py: FastAPI harness wrap mirroring claude-sdk/codex
- Register 'qwen' harness in _HARNESS_MODULES
- Add 'qwen-code' alias to HARNESS_ALIASES
- Include unit tests (test_qwen_executor.py) and e2e test
- Import order fixed to satisfy ruff E402/I001 rules
* feat(harness): add Qwen Code integration
This PR adds full Qwen Code support to Omnigent, mirroring the Kimi
integration pattern. The harness routes through OpenAI-compatible
providers and supports Databricks gateway authentication.
Changes:
- omnigent qwen CLI command with --resume support
- Spec validation for 'qwen' and 'qwen-code' harness identifiers
- Provider routing via HARNESS_QWEN_* env vars
- Databricks profile/model prefix detection
- Full integration with onboarding, runner, workflow, model layer
Files added:
- omnigent/qwen_native.py: Native Qwen wrapper for CLI
- docs/QWEN_FOLLOWUPS.md: Deferred work tracking
Tests updated:
- test_harness_install.py: Added qwen install spec test
- test_harness_readiness.py: Added expected_keys for qwen spellings
- test_provider_spawn_env.py: Added 2 tests for _build_qwen_spawn_env
Documentation:
- README.md: Added qwen to harness options comment
- AGENT_YAML_SPEC.md: Added Qwen section with examples
* test(qwen): expand test coverage and fix provider routing
- tests/inner/test_qwen_executor.py: Expand from 4 to 31 tests covering:
* Registry/allowlist (OMNIGENT_HARNESSES, OMNIGENT_HARNESS_ALIASES)
* FastAPI app shape (/health route present)
* Env-var factory (HARNESS_QWEN_* → executor kwargs)
* _build_argv (every flag passed to qwen)
* Event translator (text_delta, tool_call, turn_complete, error)
* run_turn end-to-end with stubbed subprocess
* Missing-binary error path
* Capability flags (handles_tools_internally, supports_streaming)
* Session lifecycle and process termination
- omnigent/runtime/workflow.py: Add qwen to provider routing:
* _PROVIDER_HARNESS_FAMILY: 'qwen': OPENAI_FAMILY
* _HARNESS_GATEWAY_FLAG: 'qwen': 'HARNESS_QWEN_GATEWAY'
* _QWEN_FAMILY_KEY: family key mapping for gateway base URLs
- tests/runtime/test_provider_spawn_env.py:
* Add test_qwen_uses_openai_global_default
* Add test_qwen_falls_back_to_catalog_default_model
* fix(qwen): resolve lint errors and test issues
- omnigent/qwen_native.py: Simplified to 99 lines from 324, matching kimi
pattern using run.main(['--harness', 'qwen', *args]) instead of full
native TUI launcher. Removed unused imports (asyncio, json, etc.)
- omnigent/cli.py: Fixed E501 line too long in _DEFAULT_HARNESS_PROMPTS
- omnigent/onboarding/harness_readiness.py: Refactored long condition
to fix E501 error
- tests/inner/test_qwen_executor.py:
* Removed unused imports (subprocess, sys)
* Fixed test_tool_server_rejects_wrong_token with timeout handling
* Simplified process_kill_on_timeout test to match actual behavior
* Removed unused variable assignments in stubbed run_turn tests
* docs(qwen): add AgentCard.tsx comment and example
- ap-web/src/components/AgentCard.tsx: Add qwen to iconForAgent fallback
logic (falls back to BotIcon like other non-native harnesses), update
doc comments to document this behavior.
- examples/qwen_hello.yaml: Single-file launcher example for Qwen Code,
mirroring the pattern of existing examples. Includes install instructions
and provider configuration guidance.
* fix(qwen): resolve runtime crash and simplify implementation
- omnigent/qwen_native.py: Deleted entirely. The native TUI launcher
was over-engineered (324 lines) with missing imports, unused variables,
and dead code. Replaced with a simple 5-line forward to run.main.
- omnigent/cli.py: Simplified qwen command from 60 lines to 18 lines.
Removed --server/--resume/--session options (not needed for headless
harness). Now forwards all args directly to omnigent run --harness qwen.
- tests/cli/test_cli.py: Added test_qwen_command_forwards_to_run_main
smoke test to catch this regression class in CI.
- tests/onboarding/test_harness_install.py: Fixed npm package name from
@qwen/qwen-code to @qwen-code/qwen-code (verified on npm registry).
- ap-web/src/components/AgentCard.tsx: Removed dead code that checked
agent.harness?.includes("qwen"). Added comment explaining qwen falls
back to BotIcon for now.
- examples/qwen_hello.yaml: Fixed npm package name and simplified quick-start
to use omnigent run instead of python -m omnigent.
* fix(qwen): rewrite QwenExecutor to use ACP (qwen --acp) protocol
The previous QwenExecutor was entirely broken against qwen v0.18+:
1. Wrong launch flag: invoked 'qwen --mode rpc' which does not exist.
The process exited immediately, causing EPIPE (Broken pipe) on the
next write to stdin.
2. Wrong protocol: the old executor spoke a custom JSONL dialect
(session_start/text_delta/turn_complete) that qwen never implemented.
3. Sync/async mismatch: called .drain() on a synchronous Popen
TextIOWrapper which has no such attribute.
Fix: rewrite the executor to drive qwen via ACP (Agent Communication
Protocol), a JSON-RPC 2.0 protocol over newline-delimited stdin/stdout
launched with 'qwen --acp'. Session lifecycle:
1. initialize - one-time capability handshake per subprocess
2. session/new - create a session; use the server-assigned sessionId
(qwen may remap the client-proposed id)
3. session/prompt - send user turn; consume streaming session/update
notifications (agent_message_chunk) and await the
final response with stopReason
The StreamReader limit is raised to 16 MiB to prevent the
'Separator is not found, and chunk exceed the limit' error on large
session/new responses (model lists etc).
Also fixes:
- Remove unused ToolCallRequest import in qwen_executor.py
- Fix stale 'RPC mode' comments in harnesses/__init__.py and e2e test
- Update docs/QWEN_FOLLOWUPS.md to reflect ACP instead of RPC mode
- Replace test_qwen_executor.py: old tests imported deleted _ToolServer
and tested dead API. New tests cover construction, close() lifecycle,
_rpc_id monotonicity, _read_stdout dispatch, _ensure_session server-ID
handling, run_turn success/ACP-error/session-reset paths, and
harness registry/alias wiring. All 22 tests pass.
Fixes #806
* fix(qwen): attachments, provider routing, permission gating, docs
- Forward attached files (fenced inline text) and images (real ACP image
blocks when qwen advertises promptCapabilities.image); fixes weak models
narrating tool calls as prose on file turns and dropped images.
- Add provider/gateway credential routing: translate HARNESS_QWEN_GATEWAY_*
into OPENAI_BASE_URL/API_KEY/MODEL for the qwen subprocess (verified
end-to-end vs an OpenAI-compatible gateway).
- Route session/request_permission through Omnigent's TOOL_CALL policy +
elicitation; fix approval-event flattening and elicitation branding.
- Expand tests (executor, agent integration, gateway, wrap wiring);
refactor QWEN_FOLLOWUPS by priority; remove examples/qwen_hello.yaml.
Co-authored-by: Isaac
* fix(qwen): address code-quality review nits + e2e drift guards on #1020
Code-quality bot nits:
- Comment the intentional empty except blocks in _read_stderr/_read_stdout
(cancellation/EOF on shutdown is expected, not an error).
- Drop redundant local `import json` in _qwen_auth_configured (module-level
json already imported).
- Remove dead `fake_readline_gen` helper in
test_read_stdout_resolves_pending_future.
- Normalize test_cli.py to a single import style for omnigent.cli: import the
qwen helpers directly and monkeypatch via string targets instead of
`import omnigent.cli as c`.
E2E drift guards (CI shard 0/1 failures):
- Add qwen_perm_test to _ALT_COVERED in test_examples_coverage_sync.py
(covered by tests/inner/test_qwen_agent_integration.py + the dedicated
test_per_harness_qwen.py round-trip, not a test_example_<name>.py).
- Exclude qwen from test_run_harness_live_matrix_covers_registered_coding_harnesses:
the qwen wrap routes via HARNESS_QWEN_GATEWAY_BASE_URL/AUTH_COMMAND rather
than the shared HARNESS_<HARNESS>_GATEWAY probe wiring, so it can't ride the
shared no-AGENT matrix; its live round-trip is covered by test_per_harness_qwen.py.
Co-authored-by: Isaac
* fix(qwen): remove unused constants flagged by code-quality on #1020
- qwen_executor.py: drop unused ACP method constants
_AGENT_METHOD_SESSION_LOAD / _AGENT_METHOD_SESSION_CANCEL (only
initialize/session.new/session.prompt are actually sent).
- qwen_harness.py: drop unused _TRUTHY_STRINGS (no _truthy parser here,
unlike the sibling wraps it was copied from).
- workflow.py: drop vestigial _QWEN_FAMILY_KEY — it mapped families to a
HARNESS_QWEN_GATEWAY_BASE_URLS (plural) object, but the qwen wrap routes
via the singular HARNESS_QWEN_GATEWAY_BASE_URL + AUTH_COMMAND, so the map
was never consulted.
Co-authored-by: Isaac
* fix(qwen): fix 3 ACP turn-loop correctness bugs in QwenExecutor
1. JSON-RPC id-namespace collision (CRITICAL): _read_stdout matched a
message to a pending future by id alone. qwen mints its own request ids
from a counter that can collide with ours, so a server-initiated request
(e.g. session/request_permission) could resolve our prompt future with a
request object — dropping the real response and hanging the turn. Now
require "no method" before treating a message as a response.
2. Human-approval timeout (MAJOR): the turn deadline was absolute, but
_respond_to_agent_request blocks synchronously on human elicitation. An
approval slower than the remaining budget tripped a spurious timeout even
though the user approved. The deadline is now idle-based — reset on every
inbound message, including after the approval round-trip.
3. Chunk truncation race (MAJOR): the reader can enqueue several chunks and
resolve the prompt future before run_turn drains the queue, so a bare
fut.done() check returned with chunks still buffered. Completion is now
gated on fut.done() AND an empty queue.
Adds regression tests for each (each fails on the pre-fix code).
Co-authored-by: Isaac
* fix(qwen): wake futures on stdout EOF + reset handshake on restart
Two crash-recovery correctness bugs in QwenExecutor:
- _read_stdout: a clean EOF (the normal manifestation of subprocess
death) exited the reader without failing pending futures, so an
in-flight session/prompt hung until the 300s idle timeout. Now fail
pending futures with EOFError on EOF so run_turn fails fast.
- _start_process: _initialized is a one-way latch never reset on
process death, so a restart after a crash skipped the ACP initialize
handshake and qwen rejected the next session/new. Reset _initialized
and _image_supported at the top of _start_process.
Also updates QWEN_FOLLOWUPS.md (OS sandbox under "What works today";
narrow the File I/O pending item to Omnigent-side execution/recording).
Co-authored-by: Isaac
---------
Co-authored-by: Ankush Bhatiya <ankushb@gmail.com>
|
||
|
Yuan Tang
|
9b90d1b9ad |
docs: Add contributors graph to README (#819)
* docs: Add star history and contributors graph to README Added sections for Star History and Contributors in README. * Update README.md Co-authored-by: Serena Ruan <82044803+serena-ruan@users.noreply.github.com> --------- Co-authored-by: Serena Ruan <82044803+serena-ruan@users.noreply.github.com> |
||
|
kishor-rkrishnan
|
b5d6a9dabb |
docs(readme): list cursor-native and pi-native harnesses in agent example (#815)
The "Write your own agent" YAML example listed the native variants for Claude and Codex (claude-native, codex-native) but omitted them for Cursor and Pi, even though cursor-native and pi-native are first-class registered harnesses (omnigent/runtime/harnesses/__init__.py). Make the list consistent so all four native-CLI harnesses appear. Signed-off-by: kishor-rkrishnan <286408206+kishor-rkrishnan@users.noreply.github.com> Co-authored-by: kishor-rkrishnan <286408206+kishor-rkrishnan@users.noreply.github.com> |
||
|
Denny Lee
|
ec99b8a7a2 | docs: add AI agent framework language to README for SEO (#520) | ||
|
Dhruv Gupta
|
13e59425c3 |
feat(installer): add --extra flag to install_oss.sh (#396)
Let the bootstrap installer pass optional-dependency extras through to uv tool install, e.g. `... | sh -s -- --extra databricks`. The flag is repeatable and accepts comma-separated values; extras attach across all install modes (latest, --version, and --repo source via a PEP 508 direct reference). Document the Databricks form in the README. |
||
|
Sabhya Chhabria
|
468a57b4a5 |
feat(harness): add Google Antigravity SDK harness (#194)
* feat(harness): add Google Antigravity SDK harness Add an `antigravity` harness that wraps Google's `google-antigravity` Python SDK, alongside the existing claude-sdk / codex / pi / openai-agents SDK harnesses. Defaults to Gemini 3 Pro (SDK can also drive Claude / GPT-OSS) and authenticates with an Antigravity / Gemini API key. Validated against google-antigravity==0.1.3: `Agent.chat` is async and returns a final `ChatResponse` (text / thoughts / tool_calls / usage_metadata), and `LocalAgentConfig.tools` is `list[Callable]`. - AntigravityExecutor (omnigent/inner/antigravity_executor.py): drives the SDK Agent, maps ChatResponse -> Omnigent events (TextChunk / ReasoningChunk / ToolCallRequest / TurnComplete + usage), reuses one Agent per session, and exposes Omnigent's tools (sys shell/file, sub-agents, MCP) to the agent as callables routed through the ExecutorAdapter `_tool_executor` bridge — so an Antigravity agent can act as a Polly / Debby orchestrator or worker under policy. - antigravity_harness.py: create_app() + env-var-driven lazy executor, mirroring the openai-agents wrap. - Wire the harness through the registry, omnigent-compat allowlist + aliases (agy / google-antigravity), workflow spawn-env + provider/Databricks plumbing, model-catalog resolution, provider-config family, onboarding readiness + setup wizard, and an optional `antigravity` extra. - Docs: AGENT_YAML_SPEC.md harness section + README harness list. - Tests: executor mapping + tool exposure (stubbed SDK), harness wrap, spawn-env, alias + readiness coverage. Note: the SDK authenticates via Gemini API key / Vertex AI and has no OpenAI-compatible base_url, so OpenRouter / Databricks gateway routing is not available through it; base_url_override is threaded for forward-compat but dropped when the installed SDK doesn't accept it. Token-level streaming (response.chunks / agent.conversation) is a follow-up. https://claude.ai/code/session_01TQQwTkk5Y7VvLet4nUim6g * feat(antigravity): register Gemini API key via omnigent setup Antigravity is Gemini-native (no OpenAI-compatible gateway), so it sits outside the anthropic/openai provider-family machinery. Add a dedicated `antigravity:` credential — stored in the secret store, referenced from a top-level config block, resolved via the shared resolve_secret — surfaced as an Antigravity entry in `omnigent setup` (set/replace/remove a Gemini key). `_build_antigravity_spawn_env` threads it to the harness when the spec declares no auth. Mirrors the Cursor api-key setup flow (PR #204). Also tighten verbose comments/docstrings across the antigravity files and drop the "(Gemini)" suffix from the UI harness label. Co-authored-by: Isaac * chore(deps): refresh uv.lock to satisfy uv sync --locked Regenerate uv.lock so it complies with the P7D dependency cooldown configured in uv.toml. The previous lockfile predated the cooldown (no [options] block), so the cooldown-aware `uv sync --locked` check re-resolved and failed. Re-locking records `exclude-newer-span = "P7D"` and rolls recently-published transitive deps back into the cooldown window, keeping `uv sync --locked` stable. * test(antigravity): exclude antigravity from the live no-AGENT harness matrix The coverage meta-test (test_run_harness_live_matrix_covers_registered_coding_harnesses) requires every registered coding harness to have a live round-trip row OR be explicitly excluded. Antigravity is Gemini-native — it authenticates with a Gemini API key (or Vertex AI), not the Databricks gateway/profile this matrix uses, and its SDK launches a native binary needing modern glibc — so it can't round-trip through this gateway-backed matrix. Exclude it (same rationale as cursor). Co-authored-by: Isaac --------- Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: Claude <sabhyac26@icloud.com> |
||
|
Dhruv Gupta
|
fca3ef4d49 |
feat: add omni upgrade and a PyPI-release update notice (#188)
* feat: add `omni upgrade` and a PyPI-release update notice Gives users a clean way to stay current across PyPI releases now that we publish from the OSS repo. Three parts: - Version-aware server signature: fold the installed package version into `server_config_signature()` so a running local server is respawned on the new code through the existing config-drift path after *any* upgrade (including a manual `uv tool upgrade`) — no explicit restart needed. - `omni upgrade`: detects the install shape (uv/pip/pipx/poetry), checks PyPI for a newer release, drains in-flight sessions (or `--force`), stops the local server + daemon, then runs the matching upgrade command. `--check` reports availability and exits non-zero. Reuses the installer detection / command builder that PR #172 left dormant in update_check. - Release-available notice (the PR #172 redo): nags only when a strictly newer release exists on PyPI (source of truth: pypi.org JSON), fires once per release, never blocks the hot path (the network lookup runs in a detached background process; the foreground only reads a cache), is TTY-only, and points at `omni upgrade`. Silenced by OMNIGENT_NO_UPDATE_CHECK. Dev clones keep the git "commits behind" notice. Adds `packaging` as a direct dependency (PEP 440 comparison) and a design doc at docs/omni-upgrade-design.md. Co-authored-by: Isaac * refactor(update-check): query the configured index via the Simple API Replace the hardcoded `pypi.org/pypi/<name>/json` (Warehouse-only) probe with the Simple Repository API of the *resolved* package index, so the update check works on corporate mirrors / air-gapped networks and stays consistent with the index `omni upgrade` (uv/pip) actually pulls from. - `fetch_latest_version()` (renamed from `fetch_latest_pypi_version`): GET `<index>/<name>/` with the PEP 691 JSON `Accept` header; read `versions` (PEP 700), else parse wheel/sdist filenames; PEP 503 HTML fallback when the index ignores the JSON header. Picks the latest non-pre-release via `packaging`. - `_resolve_index_url()`: honors `OMNIGENT_INDEX_URL` / `UV_DEFAULT_INDEX` / `UV_INDEX_URL` / `PIP_INDEX_URL` (in that order), default `pypi.org/simple`. URL-embedded credentials work for private mirrors. - `omni upgrade`'s unreachable-index error now names the index/override. - Tests cover PEP 691 JSON, files fallback, HTML fallback, prerelease filtering, error swallowing, and index-precedence; docs/README updated. Verified end to end against pypi.org/simple and the Databricks proxy. Co-authored-by: Isaac * feat(update-check): resolve the index from uv/pip config files too Env-var-only index detection missed the common corporate setup where the mirror is configured in `~/.config/uv/uv.toml` or `pip.conf` (not an env var) — exactly where `uv tool install` found it — so on those machines the check fell back to a (blocked) pypi.org and silently did nothing. `_resolve_index_url()` now falls back, after the index env vars, to: - uv config (`uv.toml`): legacy `index-url`, or a `[[index]]` marked `default = true` (a non-default `[[index]]` is supplementary and ignored); - pip config (`pip.conf`): `[global]` / `[install]` `index-url`, checking `$PIP_CONFIG_FILE`, the XDG/user, and system locations. Also stop appending the "run `omnigent setup` to configure a model credential" hint to `omni upgrade` failures — its errors (unreachable index, dev checkout, install error) are never about a model credential. Tests cover uv `index-url` / default `[[index]]` / ignored-supplementary, pip.conf, and env-beats-config; verified live that an `index-url` in a temp `uv.toml` is picked up. Docs/README updated. Co-authored-by: Isaac * feat(upgrade): add `--pre` to consider pre-releases (TestPyPI rc validation) `omni upgrade --pre` includes pre-releases (rc / beta / dev) in the version check and appends the installer's allow-pre-releases flag (uv `--prerelease allow`, pip `--pre`, pipx `--pip-args=--pre`) so the upgrade can land on a release candidate. Without it, the check stays stable-only — a stable user is still never nagged about an rc. This makes the release flow's TestPyPI validation step testable end to end: point the index at TestPyPI (OMNIGENT_INDEX_URL / UV_DEFAULT_INDEX) and `omni upgrade --pre [--check]` detects the candidate. - `fetch_latest_version(include_prereleases=False)` threads the flag. - `_build_upgrade_suggestion(info, allow_prerelease=False)` appends the per-installer pre-release flag. - Tests: include-prereleases fetch, the suggestion flag matrix, and the `omni upgrade --pre --check` detection (+ without-`--pre` ignores the rc). Co-authored-by: Isaac * fix(upgrade): pin pip upgrade to the running interpreter omni upgrade shelled out to a bare 'pip', which resolves against PATH and can target a different environment than the one running omni (e.g. a conda env shadowing the venv that holds the install) — silently upgrading the wrong copy. Use '<sys.executable> -m pip' so the wheel lands where the running CLI lives. uv-tool/pipx are unaffected (global per-user registries). Signed-off-by: dbczumar <corey.zumar@databricks.com> * fix(upgrade): drain only running sessions, not idle-connected ones `omni upgrade` gated its drain on *connected* sessions, but an idle session keeps its host/runner connection open indefinitely — so a box with idle sessions (e.g. 39 open tabs, none mid-turn) made the drain "Waiting for N in-flight session(s)…" forever. Gate on the session-list `status` field instead: wait only for sessions that are actually `"running"` (a runner mid-turn, or with a still-running sub-agent). Idle-but-connected sessions no longer block the upgrade; the server's own graceful SIGTERM shutdown still drains any runner that is mid-turn. Renames the helper to `_count_running_sessions`. Regression test reproduces the 39-idle-connected hang. Co-authored-by: Isaac --------- Signed-off-by: dbczumar <corey.zumar@databricks.com> Co-authored-by: dbczumar <corey.zumar@databricks.com> |
||
|
Sabhya Chhabria
|
88de81a459 |
feat(harnesses): cursor first-party harness via the Cursor Python SDK (sys_* tool bridge) (#203)
* Feat/cursor cli harness (#2) * feat(harnesses): add cursor first-party harness Add Cursor's `cursor-agent` CLI as a first-party Omnigent harness, alongside claude-sdk / codex / pi / openai-agents. - CursorExecutor drives a persistent `cursor-agent acp` (Agent Client Protocol) session via AcpClient: one session per Omnigent conversation, kept open across turns. It maps ACP `session/update` notifications to ExecutorEvents (assistant text → TextChunk, agent thoughts → ReasoningChunk, tool calls → ToolCall events) and finishes on the prompt response's `stopReason`. First-turn system-prompt prepend (ACP has no system-prompt field); persistent session reused across turns; `databricks-*` model ids dropped in favor of cursor's default (cursor rejects gateway ids); `os_env.sandbox` → cursor's `--sandbox` mode (mirrors codex); deny-by-default env allowlist; interrupt via `session/cancel`. - cursor_harness reads `HARNESS_CURSOR_*` env config. - cursor-agent talks only to Cursor's own backend (`CURSOR_API_KEY` / `cursor-agent login`) with no custom base-URL, so the Databricks gateway path does not apply — documented in README and AGENT_YAML_SPEC. - Named `cursor` to match the bare-vendor convention of `codex` / `pi` (`-native` is reserved for a future TUI bridge). Registration covers `_HARNESS_MODULES`, `OMNIGENT_HARNESSES`, `_SDK_MODEL_OVERRIDE_HARNESSES`, the runner spawn-env builder/dispatch, CLI harness help / default prompt, and the ap-web harness picker label — so it is selectable everywhere claude/codex are (spec, CLI, `/model`, sub-agent specs, web UI). - Tools: cursor uses its own native tools (auto-approved headlessly). Bridging Omnigent's spec-declared tools needs an http/sse MCP server via ACP `session/new` mcpServers (a follow-up); ACP exposes no token usage and no mid-turn steer, so `usage=None` and `supports_live_message_queue()` is False. - Tests: ACP client (handshake / prompt streaming / permission auto-allow), executor (update→event mapping / session reuse / model-drop / sandbox / interrupt), harness-wrap config flow, alias + model-override coverage, and a live e2e (skips without cursor-agent). Verified end-to-end against a real cursor-agent. Signed-off-by: Jared Champion <jared.champion@databricks.com> * test(e2e): exclude cursor from the gateway-backed live harness matrix The live no-AGENT matrix authenticates every harness through the Databricks gateway/profile, but cursor-agent talks only to Cursor's own backend (CURSOR_API_KEY) and rejects gateway model ids, so it cannot run there. Add it to the exclusion set alongside the native harnesses; cursor's live coverage is the gated row in tests/e2e/omnigent/test_per_harness_cursor.py. Signed-off-by: Jared Champion <jared.champion@databricks.com> * feat(onboarding): surface cursor in `omnigent setup` Add Cursor as a row in the interactive setup wizard and gate its readiness, matching the first-class treatment of claude/codex/pi. Cursor is the first login-only, non-npm harness: it authenticates against its own backend via `cursor-agent login` (or CURSOR_API_KEY), with no provider/gateway credential, and its CLI ships via a curl installer rather than npm. - harness_install.py: add the cursor install spec (binary cursor-agent, login/logout/status subcommands). HarnessInstallSpec gains install_hint (the manual install command for non-npm CLIs) and login_status_key (cursor's status JSON reports isAuthenticated, not loggedIn). harness_install_command rejects a package-less key; install_harness_cli no-ops for it. - harness_readiness.py: gate cursor on cursor-agent being on PATH (login state needs a subprocess, so the daemon checks install only, like the other CLIs), and include it in the hello-frame readiness map. - cli.py: add a Cursor row to `omnigent setup` whose drill-in shows the manual install command when missing and otherwise drives cursor-agent login/logout — it has no provider credential to configure. - Tests: cursor install spec / required-CLI / isAuthenticated verdict / non-npm install no-op, plus readiness coverage. Signed-off-by: Jared Champion <jared.champion@databricks.com> --------- Signed-off-by: Jared Champion <jared.champion@databricks.com> * fix(cursor): harden ACP session lifecycle and error surfacing Addresses review findings on the cursor harness: - _ensure_session closes the spawned client on setup failure, so a bad CURSOR_API_KEY / rejected model can no longer orphan a cursor-agent process + reader tasks; the captured stderr tail is attached so the failure (e.g. an auth error) is debuggable instead of a bare "closed the connection". - The session/prompt error path now drops the session (mirroring the mid-turn AcpError path) so a retry rebuilds a fresh session and re-sends the system prompt, rather than reusing a wedged session with is_first_turn already False. - Separate short timeout for the initialize / session/new handshake so a spawned-but-mute cursor-agent fails fast instead of hanging the first turn for the full 600s turn budget. - prompt_stream cancels its pending notification getter on abandonment and treats a cancelled prompt future (interrupt) as a clean end of turn. - Observability: log headless permission auto-allow, warn on reader crashes, and log failed session/cancel writes. Tests: - tests/runtime/test_cursor_spawn_env.py: the previously-uncovered spec -> HARNESS_CURSOR_* mapping, incl. the DatabricksAuth -> no API-key contract. - executor lifecycle: setup failure (stderr + no leak), mid-turn server death, prompt-error session drop, session-restart-on-prompt-change, empty-prompt completion. - ACP connection-closed fails in-flight requests instead of hanging. - Drop a duplicated registry assertion; correct the stale stream-json e2e docstring (the harness drives ACP). Co-authored-by: Isaac * docs(cursor): tighten inline comments and docstrings Condense the verbose explanatory comments and docstrings added by the cursor harness without dropping the rationale they carry. Co-authored-by: Isaac * feat(cursor): drive the Cursor Python SDK with the sys_* tool bridge Rework the cursor harness from the cursor-agent ACP transport to the Cursor Python SDK (cursor-sdk), so Omnigent's spec-declared tools (sys_session_send et al.) are exposed to the Cursor model as callable tools — full first-party parity (orchestration, policy gating, spec tools) with the claude-sdk / codex / pi / openai-agents harnesses. Why: cursor-agent's ACP mode accepts an mcpServers config but only surfaces MCP servers as read-only resources (ListMcpResources / FetchMcpResource), never as callable tools (verified four ways). The SDK's LocalAgentOptions(custom_tools=…) registers Python-callback tools the model invokes — the same in-process bridge pattern the claude-sdk harness uses. - CursorExecutor drives a persistent cursor_sdk.AsyncAgent over a launch_bridge() client (one per conversation), maps run.messages() SDKMessages to ExecutorEvents, and builds custom_tools from the turn's ToolSpecs. Each tool's execute hops from the SDK callback daemon thread back to the main loop via run_coroutine_threadsafe to await _tool_executor; the cursor "mcp" custom-tool envelope is unwrapped so observed events carry the real tool name. - Auth: a Cursor API key (CURSOR_API_KEY / spec api_key); the SDK does not reuse cursor-agent login. Remove the unused ACP client and HARNESS_CURSOR_PATH knob. - Add cursor-sdk>=0.1.7 to the baseline deps. Verified live end to end: a real cursor model invoked a bridged tool, which routed through _tool_executor (correct name + args) and returned its value. Tests: rewrite test_cursor_executor.py against an injected fake cursor_sdk (no key/network); spawn-env + harness + e2e updated for the SDK. Co-authored-by: Isaac * fix(cursor): address review — policy enforcement, SDK readiness, tool/history correctness Addresses the PR review on the cursor-sdk harness: 1. Policy bypass — run_turn now evaluates PHASE_LLM_REQUEST before the LLM call (DENY blocks the send) and PHASE_LLM_RESPONSE after the stream before TurnComplete (DENY blocks persistence), via the adapter-installed _policy_evaluator — parity with the claude-sdk / pi harnesses. 3. Readiness gated the wrong prerequisite — harness_readiness now gates cursor on the cursor-sdk package being importable (its actual runtime), not on a cursor-agent CLI on PATH; the Cursor API key resolves at runtime like the other SDK harnesses, so it is not gated. 4. Stale custom tools across turns — session invalidation now includes a stable tool-schema fingerprint, so a changed tool set rebuilds the agent (custom tools are fixed at agent creation). 5. Passed history dropped — _build_cursor_prompt serializes prior history whenever is_first_turn and len(messages) > 1 (not only with multiple user messages), so a pass_history sub-agent's single-user-message context survives. 6. `npm install -g None` — cursor no longer maps to a required CLI (_HARNESS_NAME_TO_KEY), so the sub-agent preflight returns None for it (no false block, no bogus npm hint); tool_dispatch also falls back to a CLI's install_hint when it has no npm package. (2) Setup capturing/validating the Cursor API key is handled by the separate auth-setup change; readiness no longer treats a cursor-agent login as sufficient. Tests: policy request/response DENY + ALLOW, changed-tool-set rebuild, single-user-message history serialization, cursor-sdk-gated readiness, and SDK-harnesses-need-no-CLI; updated the readiness/install tests that encoded the old CLI-backed assumption. Co-authored-by: Isaac * fix(cursor): thread an ambient CURSOR_API_KEY into the harness spawn-env The cursor harness runs in a spawned subprocess and the cursor-sdk requires the API key in that process's environment. _build_cursor_spawn_env only set HARNESS_CURSOR_API_KEY from a spec's ApiKeyAuth, so a cursor agent with no declared auth (e.g. a web-UI "New Chat" pick, or `omnigent run --harness cursor`) failed at Agent.create with `missing_api_key` even when CURSOR_API_KEY was exported / present on the host. Fall back to an ambient CURSOR_API_KEY when the spec declares no api-key auth, so an exported key (or a host launched with one) flows to the harness. A spec ApiKeyAuth still wins; a DatabricksAuth profile is still never forwarded as the cursor key. Tests: ambient CURSOR_API_KEY -> HARNESS_CURSOR_API_KEY when no spec auth; spec api-key wins over ambient; the no-auth / DatabricksAuth cases clear the ambient key first so they stay deterministic. Co-authored-by: Isaac * fix(ap-web): prettier-format the cursor agentLabels entry The cursor entry in BRAIN_HARNESS_LABELS had a redundantly-quoted key ("cursor" -> cursor) that failed `prettier --check` (ap-web npm test + pre-commit). Reformat to satisfy the format gate. Co-authored-by: Isaac * feat(cursor): register CURSOR_API_KEY via omnigent setup (#204) The cursor harness drives the Cursor SDK, which requires a CURSOR_API_KEY (a cursor-agent login does not apply). Let a user register that key once through `omnigent setup` instead of exporting it in every shell. - onboarding/cursor_auth.py (new): store the key in the omnigent secret store and reference it from a dedicated top-level `cursor:` config block (keychain:/env:), resolved via the shared resolve_secret(). A dedicated block — not the global `auth:` — keeps the SDK harnesses from mis-consuming a Cursor key as their gateway credential. - cli.py: the Cursor entry in `omnigent setup` now sets / replaces / removes the API key (hidden prompt, soft crsr_ prefix check, $CURSOR_API_KEY adoption); the secret is never echoed. - runtime/workflow._build_cursor_spawn_env: when a spec declares no auth, resolve the stored CURSOR_API_KEY -> HARNESS_CURSOR_API_KEY (an explicit spec api-key still wins; a DatabricksAuth never adopts it). - onboarding/harness_readiness: cursor is "ready" when a key is resolvable (config or env), not gated on the cursor-agent binary the SDK no longer needs. Tests: cursor_auth unit tests, spawn-env config-fallback, key-based readiness, and the setup add/remove/env-adopt flow. Co-authored-by: Isaac --------- Signed-off-by: Jared Champion <jared.champion@databricks.com> Co-authored-by: championj-db <170588186+championj-db@users.noreply.github.com> |
||
|
Arya Buddha
|
4401e6960a |
docs: add bubblewrap as a prerequisite and install step (#178)
* docs: add bubblewrap as a prerequisite and install step (#177) bubblewrap (bwrap) is required on Linux: the native claude/codex/pi harnesses wrap each agent terminal in a bwrap OS-sandbox, and the linux_bwrap backend is mandatory and fail-loud, yet it was listed nowhere in the prerequisites and the installer never offered to set it up the way it does for uv, git, and tmux. - README.md / CONTRIBUTING.md: list bubblewrap as a Linux-only prereq, noting macOS uses the built-in seatbelt sandbox. - scripts/install_oss.sh: add a Linux-only check_bubblewrap step that mirrors check_tmux (offers to install via the detected package manager, warns rather than fails otherwise). - deploy/docker/Dockerfile: install bubblewrap in the host stage so the image matches deploy/islo/README.md, which already states the host target ships bubblewrap (native harness terminals fail to start without it in managed sandboxes). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Signed-off-by: Arya Buddha <40647186+AryaBuddha@users.noreply.github.com> * fix(install): don't abort installer on macOS in check_bubblewrap `check_bubblewrap` early-returns on non-Linux with a bare `[ ... ] || return`, which returns the failed test's status (1). Under `set -eu`, `main` calls it bare before `install_omnigent`, so on macOS the installer aborts right after the tmux check and never installs Omnigent — breaking the documented `curl ... install_oss.sh | sh` path on a supported OS (`check_platform` allows Darwin). Return 0 explicitly so the Linux-only guard is a clean no-op elsewhere. Verified across sh/bash/dash: with the fix, a simulated macOS run proceeds to install_omnigent and exits 0. Co-authored-by: Isaac --------- Signed-off-by: Arya Buddha <40647186+AryaBuddha@users.noreply.github.com> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: Dhruv Gupta <dhruv.gupta@databricks.com> |
||
|
Yossi Eliaz
|
111a781cd6 |
[codex] add islo sandbox provider (#42)
* add islo sandbox provider * islo: clear seeded apiKeyHelper for injected Claude creds + deploy guide Signed-off-by: dbczumar <corey.zumar@databricks.com> * ruff-format managed_hosts.py Signed-off-by: dbczumar <corey.zumar@databricks.com> --------- Signed-off-by: dbczumar <corey.zumar@databricks.com> Co-authored-by: dbczumar <corey.zumar@databricks.com> |
||
|
dbczumar
|
22d4f536e3 |
Update README tagline
Signed-off-by: dbczumar <corey.zumar@databricks.com> |
||
|
Dhruv Gupta
|
b3fb64710c | Welcome to omnigent |