Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
feat(cyclops): add browser bash chat (#6769)
r33drichards54d62e72ef44
diff --git a/libs/fleet/agent.test.ts b/libs/fleet/agent.test.tsnew file mode 100644index 0000000000..b13872dbe2--- /dev/null+++ b/libs/fleet/agent.test.ts@@ -0,0 +1,206 @@+import assert from "node:assert/strict"+import test from "node:test"+import {+ BrowserBashAgent,+ normalizeBashArguments,+ sanitizeError,+ type AssistantMessage,+ type AgentEvent,+ type TurnClient,+} from "./src/browser-agent.ts"+import { gzipSync, gunzipSync } from "./src/node-zlib-browser.ts"++test("clamps model-selected bash limits", () => {+ assert.deepEqual(+ normalizeBashArguments({ command: "echo ok", timeout_ms: 1, max_output_chars: 9_999_999 }),+ { command: "echo ok", timeout_ms: 250, max_output_chars: 100_000 },+ )+})++test("sanitizes control characters in bash execution errors", () => {+ assert.equal(sanitizeError(new Error("\u0000failed\nwith\u007fcontrols\u0085")), "failed with controls")+ assert.equal(sanitizeError(new Error("\u0000\u001f\u007f\u009f")), "Bash execution failed")+})++test("keeps one virtual filesystem per conversation", async () => {+ const unused: TurnClient = async () => ({ role: "assistant", content: "done", tool_calls: [] })+ const agent = new BrowserBashAgent(unused)+ await agent.executeBash("one", { command: "echo alpha > note.txt" })+ assert.equal((await agent.executeBash("one", { command: "cat note.txt" })).stdout, "alpha\n")+ assert.notEqual((await agent.executeBash("two", { command: "cat note.txt" })).exit_code, 0)+})++test("browser zlib shim fails only when gzip-backed commands execute", async () => {+ const agent = new BrowserBashAgent(async () => ({ role: "assistant", content: "", tool_calls: [] }))+ assert.equal((await agent.executeBash("zlib-shim", { command: "printf normal" })).stdout, "normal")++ assert.throws(() => gzipSync(new Uint8Array()), /gzip commands are unsupported in the browser/)+ assert.throws(() => gunzipSync(new Uint8Array()), /gzip commands are unsupported in the browser/)+})++test("runs tool calls until the assistant finishes", async () => {+ const requests: Parameters<TurnClient>[1][] = []+ const responses: AssistantMessage[] = [+ {+ role: "assistant",+ content: "",+ tool_calls: [{ id: "call-1", type: "function", function: { name: "bash", arguments: '{"command":"printf hello"}' } }],+ },+ { role: "assistant", content: "The command printed hello.", tool_calls: [] },+ ]+ const client: TurnClient = async (_id, messages, _signal, onDelta) => {+ requests.push(messages)+ onDelta?.(requests.length === 1 ? "Running bash." : "Bash finished.")+ return responses.shift()!+ }+ const events: AgentEvent[] = []+ const agent = new BrowserBashAgent(client)+ await agent.run("conversation-1", [{ role: "user", content: "Run it" }], event => events.push(event))++ assert.deepEqual(requests, [+ [{ role: "user", content: "Run it" }],+ [+ {+ role: "tool",+ tool_call_id: "call-1",+ content: JSON.stringify({ stdout: "hello", stderr: "", exit_code: 0, timed_out: false, truncated: false }),+ },+ ],+ ])+ assert.deepEqual(+ events.map(event => event.type),+ ["generation_start", "assistant_delta", "tool_start", "tool_result", "generation_start", "assistant_delta", "complete"],+ )+ assert.deepEqual(events[1], { type: "assistant_delta", delta: "Running bash." })+ assert.deepEqual(events[5], { type: "assistant_delta", delta: "Bash finished." })+})++test("normalizes timeout and truncation results", async () => {+ const agent = new BrowserBashAgent(async () => ({ role: "assistant", content: "", tool_calls: [] }))+ const truncated = await agent.executeBash("one", { command: "printf 123456", max_output_chars: 4 })+ assert.deepEqual(truncated, { stdout: "1234", stderr: "", exit_code: 0, timed_out: false, truncated: true })++ const maximum = await agent.executeBash("one", {+ command: `printf ${"x".repeat(100_001)}`,+ max_output_chars: 100_001,+ })+ assert.equal(maximum.stdout.length + maximum.stderr.length, 100_000)+ assert.equal(maximum.truncated, true)++ const timedOut = await agent.executeBash("one", { command: "sleep 2", timeout_ms: 250 })+ assert.equal(timedOut.exit_code, 124)+ assert.equal(timedOut.timed_out, true)+})++test("caller cancellation aborts bash execution and stops the tool loop", async () => {+ let requests = 0+ const controller = new AbortController()+ const events: AgentEvent[] = []+ const agent = new BrowserBashAgent(async () => {+ requests += 1+ return {+ role: "assistant",+ content: "",+ tool_calls: [+ { id: "call-cancel", type: "function", function: { name: "bash", arguments: '{"command":"sleep 2"}' } },+ ],+ }+ })++ const run = agent.run(+ "conversation-cancel",+ [{ role: "user", content: "Run it" }],+ event => {+ events.push(event)+ if (event.type === "tool_start") {+ controller.abort()+ }+ },+ controller.signal,+ )++ await assert.rejects(run, { name: "AbortError" })+ assert.equal(requests, 1)+ assert.deepEqual(events.map(event => event.type), ["generation_start", "tool_start"])+})++test("batches multiple bash tool results into one follow-up turn", async () => {+ const requests: Parameters<TurnClient>[1][] = []+ const responses: AssistantMessage[] = [+ {+ role: "assistant",+ content: "",+ tool_calls: [+ { id: "call-left", type: "function", function: { name: "bash", arguments: '{"command":"printf left"}' } },+ { id: "call-right", type: "function", function: { name: "bash", arguments: '{"command":"printf right"}' } },+ ],+ },+ { role: "assistant", content: "Both commands completed.", tool_calls: [] },+ ]+ const client: TurnClient = async (_id, messages) => {+ requests.push(messages)+ return responses.shift()!+ }+ const events: AgentEvent[] = []+ const agent = new BrowserBashAgent(client)++ await agent.run("conversation-batch", [{ role: "user", content: "Run both commands" }], event => events.push(event))++ assert.equal(requests.length, 2)+ assert.deepEqual(requests[1], [+ {+ role: "tool",+ tool_call_id: "call-left",+ content: JSON.stringify({ stdout: "left", stderr: "", exit_code: 0, timed_out: false, truncated: false }),+ },+ {+ role: "tool",+ tool_call_id: "call-right",+ content: JSON.stringify({ stdout: "right", stderr: "", exit_code: 0, timed_out: false, truncated: false }),+ },+ ])+ assert.deepEqual(+ events.map(event => event.type),+ ["generation_start", "tool_start", "tool_start", "tool_result", "tool_result", "generation_start", "complete"],+ )+ assert.deepEqual(+ events+ .filter((event): event is Extract<AgentEvent, { type: "tool_start" }> => event.type === "tool_start")+ .map(event => event.toolCall.id),+ ["call-left", "call-right"],+ )+ assert.deepEqual(+ events+ .filter((event): event is Extract<AgentEvent, { type: "tool_result" }> => event.type === "tool_result")+ .map(event => ({ id: event.toolCall.id, result: event.result }))+ .sort((left, right) => left.id.localeCompare(right.id)),+ [+ { id: "call-left", result: { stdout: "left", stderr: "", exit_code: 0, timed_out: false, truncated: false } },+ { id: "call-right", result: { stdout: "right", stderr: "", exit_code: 0, timed_out: false, truncated: false } },+ ],+ )+})++test("rejects mixed tool batches before bash side effects", async () => {+ const events: AgentEvent[] = []+ const agent = new BrowserBashAgent(async () => ({+ role: "assistant",+ content: "",+ tool_calls: [+ {+ id: "call-create-file",+ type: "function",+ function: { name: "bash", arguments: '{"command":"touch should-not-exist"}' },+ },+ { id: "call-unsupported", type: "function", function: { name: "other", arguments: "{}" } },+ ],+ }))++ await assert.rejects(+ agent.run("conversation-mixed", [{ role: "user", content: "Run the tools" }], event => events.push(event)),+ { message: "Unsupported tool: other" },+ )++ assert.deepEqual(events.map(event => event.type), ["generation_start"])+ assert.notEqual((await agent.executeBash("conversation-mixed", { command: "test -e should-not-exist" })).exit_code, 0)+})diff --git a/libs/fleet/backend/auth/authz_chat.rego b/libs/fleet/backend/auth/authz_chat.regonew file mode 100644index 0000000000..f37b49d2b5--- /dev/null+++ b/libs/fleet/backend/auth/authz_chat.rego@@ -0,0 +1,23 @@+# Browser-local Bash chat. The backend stores history and proxies LiteLLM, but+# the tool itself runs in the authenticated SPA. Keep service-account and+# per-key credentials off this browser surface.+package authz_chat++import data.authz++default allow = false++allow {+ input.route == "/api/chat/conversations"+ input.user.azp == "cyclops-cs-spa"+}++allow {+ input.route == "/api/chat/conversations/{id}"+ input.user.azp == "cyclops-cs-spa"+}++allow {+ input.route == "/api/chat/conversations/{id}/turns"+ input.user.azp == "cyclops-cs-spa"+}diff --git a/libs/fleet/backend/auth/authz_chat_test.rego b/libs/fleet/backend/auth/authz_chat_test.regonew file mode 100644index 0000000000..6db484a72b--- /dev/null+++ b/libs/fleet/backend/auth/authz_chat_test.rego@@ -0,0 +1,35 @@+package authz_chat_test++import rego.v1++import data.authz_base+import data.authz_chat++route_allow if {+ authz_base.allow+ authz_chat.allow+}++chat_request(route, azp, sub) := {+ "route": route,+ "method": "GET",+ "path": route,+ "params": {},+ "user": {"sub": sub, "azp": azp, "namespace": "", "email": "[email protected]"},+}++test_spa_chat_routes_allowed if {+ every route in [+ "/api/chat/conversations",+ "/api/chat/conversations/{id}",+ "/api/chat/conversations/{id}/turns",+ ] {+ route_allow with input as chat_request(route, "cyclops-cs-spa", "user-123")+ }+}++test_non_spa_chat_routes_denied if {+ every azp in ["cua-cli", "ukey-user", "key-pool"] {+ not route_allow with input as chat_request("/api/chat/conversations", azp, "user-123")+ }+}diff --git a/libs/fleet/backend/auth/middlewares.go b/libs/fleet/backend/auth/middlewares.goindex 40ae16b243..7285439cb3 100644--- a/libs/fleet/backend/auth/middlewares.go+++ b/libs/fleet/backend/auth/middlewares.go@@ -56,6 +56,7 @@ var surfacePolicySources = map[string]struct {"authz-base": {"authz_base.rego", authzBasePolicy},"authz-keys": {"authz_keys.rego", authzKeysPolicy},"authz-config": {"authz_config.rego", authzConfigPolicy},+ "authz-chat": {"authz_chat.rego", authzChatPolicy},"authz-billing": {"authz_billing.rego", authzBillingPolicy},"authz-namespaces": {"authz_namespaces.rego", authzNamespacesPolicy},"authz-github-trust": {"authz_github_trust.rego", authzGitHubTrustPolicy},@@ -75,6 +76,9 @@ var authzKeysPolicy string//go:embed authz_config.regovar authzConfigPolicy string+//go:embed authz_chat.rego+var authzChatPolicy string+//go:embed authz_billing.regovar authzBillingPolicy stringdiff --git a/libs/fleet/backend/auth/policy_characterization_test.go b/libs/fleet/backend/auth/policy_characterization_test.goindex 83c87affe3..e866a14bd2 100644--- a/libs/fleet/backend/auth/policy_characterization_test.go+++ b/libs/fleet/backend/auth/policy_characterization_test.go@@ -159,6 +159,7 @@ func characterizationCases() map[string][]routeCase {}simple("/api/config", "/api/config")simple("/api/state/query", "/api/state/query")+ simple("/api/chat/conversations", "/api/chat/conversations")simple("/api/billing/summary", "/api/billing/summary")simple("/api/billing/setup-session", "/api/billing/setup-session")simple("/api/billing/portal-session", "/api/billing/portal-session")@@ -175,8 +176,14 @@ func characterizationCases() map[string][]routeCase {}}}withID("/api/keys/{id}", "/api/keys")+ withID("/api/chat/conversations/{id}", "/api/chat/conversations")withID("/api/user-keys/{id}", "/api/user-keys")withID("/api/github-trust-policies/{id}", "/api/github-trust-policies")+ cases["/api/chat/conversations/{id}/turns"] = []routeCase{{+ name: "id",+ params: map[string]string{"id": "id-1"},+ path: "/api/chat/conversations/id-1/turns",+ }}// /api/namespaces/{name} needs all three fact answers, and only on GET: the// ownership conjunct binds to that one method, and DELETE sharing the routediff --git a/libs/fleet/backend/auth/policy_routes.go b/libs/fleet/backend/auth/policy_routes.goindex 5ecc843f91..3aeb09b56c 100644--- a/libs/fleet/backend/auth/policy_routes.go+++ b/libs/fleet/backend/auth/policy_routes.go@@ -68,6 +68,11 @@ func ConfigRoutePolicy() Node {return All(BasePolicy(), surfaceLeaf("authz-config", "data.authz_config.allow"))}+// ChatRoutePolicy guards browser-local Bash conversation routes.+func ChatRoutePolicy() Node {+ return All(BasePolicy(), surfaceLeaf("authz-chat", "data.authz_chat.allow"))+}+// BillingRoutePolicy guards the Stripe-hosted billing browser routes. Its module// matches a prefix rather than three literals, so a billing route added to// main.go and bound here is covered without a policy change.@@ -224,6 +229,7 @@ type surfacePolicy struct {var surfacePolicies = map[string]surfacePolicy{"keys": {tree: KeysRoutePolicy},"config": {tree: ConfigRoutePolicy},+ "chat": {tree: ChatRoutePolicy},"billing": {tree: BillingRoutePolicy},"namespaces": {tree: NamespacesRoutePolicy},"github-trust": {tree: GitHubTrustRoutePolicy},@@ -248,6 +254,10 @@ var routeSurfaces = map[string]string{"/api/config": "config","/api/state/query": "state-query",+ "/api/chat/conversations": "chat",+ "/api/chat/conversations/{id}": "chat",+ "/api/chat/conversations/{id}/turns": "chat",+"/api/billing/summary": "billing","/api/billing/setup-session": "billing","/api/billing/portal-session": "billing",diff --git a/libs/fleet/backend/auth/testdata/chat-route-plan.txt b/libs/fleet/backend/auth/testdata/chat-route-plan.txtnew file mode 100644index 0000000000..8c0e271fc2--- /dev/null+++ b/libs/fleet/backend/auth/testdata/chat-route-plan.txt@@ -0,0 +1,3 @@+All+ Leaf query=data.authz_base.allow source=registered:authz-base+ Leaf query=data.authz_chat.allow source=multi["registered:authz","registered:authz-chat"]diff --git a/libs/fleet/backend/auth/testdata/route-authorization-table.txt b/libs/fleet/backend/auth/testdata/route-authorization-table.txtindex 41ad947db2..2970a96e2f 100644--- a/libs/fleet/backend/auth/testdata/route-authorization-table.txt+++ b/libs/fleet/backend/auth/testdata/route-authorization-table.txt@@ -163,6 +163,171 @@/api/billing/summary | plain | QUERY | spa = allow/api/billing/summary | plain | QUERY | user-key = deny/api/billing/summary | plain | QUERY | user-key-verified = deny+/api/chat/conversations | plain | DELETE | admin-spa = allow+/api/chat/conversations | plain | DELETE | cua-cli = deny+/api/chat/conversations | plain | DELETE | dcr-client = deny+/api/chat/conversations | plain | DELETE | empty-sub = deny+/api/chat/conversations | plain | DELETE | github-oidc = deny+/api/chat/conversations | plain | DELETE | oauth2-proxy = deny+/api/chat/conversations | plain | DELETE | per-key-other-ns = deny+/api/chat/conversations | plain | DELETE | per-key-owned-ns = deny+/api/chat/conversations | plain | DELETE | spa = allow+/api/chat/conversations | plain | DELETE | user-key = deny+/api/chat/conversations | plain | DELETE | user-key-verified = deny+/api/chat/conversations | plain | GET | admin-spa = allow+/api/chat/conversations | plain | GET | cua-cli = deny+/api/chat/conversations | plain | GET | dcr-client = deny+/api/chat/conversations | plain | GET | empty-sub = deny+/api/chat/conversations | plain | GET | github-oidc = deny+/api/chat/conversations | plain | GET | oauth2-proxy = deny+/api/chat/conversations | plain | GET | per-key-other-ns = deny+/api/chat/conversations | plain | GET | per-key-owned-ns = deny+/api/chat/conversations | plain | GET | spa = allow+/api/chat/conversations | plain | GET | user-key = deny+/api/chat/conversations | plain | GET | user-key-verified = deny+/api/chat/conversations | plain | PATCH | admin-spa = allow+/api/chat/conversations | plain | PATCH | cua-cli = deny+/api/chat/conversations | plain | PATCH | dcr-client = deny+/api/chat/conversations | plain | PATCH | empty-sub = deny+/api/chat/conversations | plain | PATCH | github-oidc = deny+/api/chat/conversations | plain | PATCH | oauth2-proxy = deny+/api/chat/conversations | plain | PATCH | per-key-other-ns = deny+/api/chat/conversations | plain | PATCH | per-key-owned-ns = deny+/api/chat/conversations | plain | PATCH | spa = allow+/api/chat/conversations | plain | PATCH | user-key = deny+/api/chat/conversations | plain | PATCH | user-key-verified = deny+/api/chat/conversations | plain | POST | admin-spa = allow+/api/chat/conversations | plain | POST | cua-cli = deny+/api/chat/conversations | plain | POST | dcr-client = deny+/api/chat/conversations | plain | POST | empty-sub = deny+/api/chat/conversations | plain | POST | github-oidc = deny+/api/chat/conversations | plain | POST | oauth2-proxy = deny+/api/chat/conversations | plain | POST | per-key-other-ns = deny+/api/chat/conversations | plain | POST | per-key-owned-ns = deny+/api/chat/conversations | plain | POST | spa = allow+/api/chat/conversations | plain | POST | user-key = deny+/api/chat/conversations | plain | POST | user-key-verified = deny+/api/chat/conversations | plain | QUERY | admin-spa = allow+/api/chat/conversations | plain | QUERY | cua-cli = deny+/api/chat/conversations | plain | QUERY | dcr-client = deny+/api/chat/conversations | plain | QUERY | empty-sub = deny+/api/chat/conversations | plain | QUERY | github-oidc = deny+/api/chat/conversations | plain | QUERY | oauth2-proxy = deny+/api/chat/conversations | plain | QUERY | per-key-other-ns = deny+/api/chat/conversations | plain | QUERY | per-key-owned-ns = deny+/api/chat/conversations | plain | QUERY | spa = allow+/api/chat/conversations | plain | QUERY | user-key = deny+/api/chat/conversations | plain | QUERY | user-key-verified = deny+/api/chat/conversations/{id} | id | DELETE | admin-spa = allow+/api/chat/conversations/{id} | id | DELETE | cua-cli = deny+/api/chat/conversations/{id} | id | DELETE | dcr-client = deny+/api/chat/conversations/{id} | id | DELETE | empty-sub = deny+/api/chat/conversations/{id} | id | DELETE | github-oidc = deny+/api/chat/conversations/{id} | id | DELETE | oauth2-proxy = deny+/api/chat/conversations/{id} | id | DELETE | per-key-other-ns = deny+/api/chat/conversations/{id} | id | DELETE | per-key-owned-ns = deny+/api/chat/conversations/{id} | id | DELETE | spa = allow+/api/chat/conversations/{id} | id | DELETE | user-key = deny+/api/chat/conversations/{id} | id | DELETE | user-key-verified = deny+/api/chat/conversations/{id} | id | GET | admin-spa = allow+/api/chat/conversations/{id} | id | GET | cua-cli = deny+/api/chat/conversations/{id} | id | GET | dcr-client = deny+/api/chat/conversations/{id} | id | GET | empty-sub = deny+/api/chat/conversations/{id} | id | GET | github-oidc = deny+/api/chat/conversations/{id} | id | GET | oauth2-proxy = deny+/api/chat/conversations/{id} | id | GET | per-key-other-ns = deny+/api/chat/conversations/{id} | id | GET | per-key-owned-ns = deny+/api/chat/conversations/{id} | id | GET | spa = allow+/api/chat/conversations/{id} | id | GET | user-key = deny+/api/chat/conversations/{id} | id | GET | user-key-verified = deny+/api/chat/conversations/{id} | id | PATCH | admin-spa = allow+/api/chat/conversations/{id} | id | PATCH | cua-cli = deny+/api/chat/conversations/{id} | id | PATCH | dcr-client = deny+/api/chat/conversations/{id} | id | PATCH | empty-sub = deny+/api/chat/conversations/{id} | id | PATCH | github-oidc = deny+/api/chat/conversations/{id} | id | PATCH | oauth2-proxy = deny+/api/chat/conversations/{id} | id | PATCH | per-key-other-ns = deny+/api/chat/conversations/{id} | id | PATCH | per-key-owned-ns = deny+/api/chat/conversations/{id} | id | PATCH | spa = allow+/api/chat/conversations/{id} | id | PATCH | user-key = deny+/api/chat/conversations/{id} | id | PATCH | user-key-verified = deny+/api/chat/conversations/{id} | id | POST | admin-spa = allow+/api/chat/conversations/{id} | id | POST | cua-cli = deny+/api/chat/conversations/{id} | id | POST | dcr-client = deny+/api/chat/conversations/{id} | id | POST | empty-sub = deny+/api/chat/conversations/{id} | id | POST | github-oidc = deny+/api/chat/conversations/{id} | id | POST | oauth2-proxy = deny+/api/chat/conversations/{id} | id | POST | per-key-other-ns = deny+/api/chat/conversations/{id} | id | POST | per-key-owned-ns = deny+/api/chat/conversations/{id} | id | POST | spa = allow+/api/chat/conversations/{id} | id | POST | user-key = deny+/api/chat/conversations/{id} | id | POST | user-key-verified = deny+/api/chat/conversations/{id} | id | QUERY | admin-spa = allow+/api/chat/conversations/{id} | id | QUERY | cua-cli = deny+/api/chat/conversations/{id} | id | QUERY | dcr-client = deny+/api/chat/conversations/{id} | id | QUERY | empty-sub = deny+/api/chat/conversations/{id} | id | QUERY | github-oidc = deny+/api/chat/conversations/{id} | id | QUERY | oauth2-proxy = deny+/api/chat/conversations/{id} | id | QUERY | per-key-other-ns = deny+/api/chat/conversations/{id} | id | QUERY | per-key-owned-ns = deny+/api/chat/conversations/{id} | id | QUERY | spa = allow+/api/chat/conversations/{id} | id | QUERY | user-key = deny+/api/chat/conversations/{id} | id | QUERY | user-key-verified = deny+/api/chat/conversations/{id}/turns | id | DELETE | admin-spa = allow+/api/chat/conversations/{id}/turns | id | DELETE | cua-cli = deny+/api/chat/conversations/{id}/turns | id | DELETE | dcr-client = deny+/api/chat/conversations/{id}/turns | id | DELETE | empty-sub = deny+/api/chat/conversations/{id}/turns | id | DELETE | github-oidc = deny+/api/chat/conversations/{id}/turns | id | DELETE | oauth2-proxy = deny+/api/chat/conversations/{id}/turns | id | DELETE | per-key-other-ns = deny+/api/chat/conversations/{id}/turns | id | DELETE | per-key-owned-ns = deny+/api/chat/conversations/{id}/turns | id | DELETE | spa = allow+/api/chat/conversations/{id}/turns | id | DELETE | user-key = deny+/api/chat/conversations/{id}/turns | id | DELETE | user-key-verified = deny+/api/chat/conversations/{id}/turns | id | GET | admin-spa = allow+/api/chat/conversations/{id}/turns | id | GET | cua-cli = deny+/api/chat/conversations/{id}/turns | id | GET | dcr-client = deny+/api/chat/conversations/{id}/turns | id | GET | empty-sub = deny+/api/chat/conversations/{id}/turns | id | GET | github-oidc = deny+/api/chat/conversations/{id}/turns | id | GET | oauth2-proxy = deny+/api/chat/conversations/{id}/turns | id | GET | per-key-other-ns = deny+/api/chat/conversations/{id}/turns | id | GET | per-key-owned-ns = deny+/api/chat/conversations/{id}/turns | id | GET | spa = allow+/api/chat/conversations/{id}/turns | id | GET | user-key = deny+/api/chat/conversations/{id}/turns | id | GET | user-key-verified = deny+/api/chat/conversations/{id}/turns | id | PATCH | admin-spa = allow+/api/chat/conversations/{id}/turns | id | PATCH | cua-cli = deny+/api/chat/conversations/{id}/turns | id | PATCH | dcr-client = deny+/api/chat/conversations/{id}/turns | id | PATCH | empty-sub = deny+/api/chat/conversations/{id}/turns | id | PATCH | github-oidc = deny+/api/chat/conversations/{id}/turns | id | PATCH | oauth2-proxy = deny+/api/chat/conversations/{id}/turns | id | PATCH | per-key-other-ns = deny+/api/chat/conversations/{id}/turns | id | PATCH | per-key-owned-ns = deny+/api/chat/conversations/{id}/turns | id | PATCH | spa = allow+/api/chat/conversations/{id}/turns | id | PATCH | user-key = deny+/api/chat/conversations/{id}/turns | id | PATCH | user-key-verified = deny+/api/chat/conversations/{id}/turns | id | POST | admin-spa = allow+/api/chat/conversations/{id}/turns | id | POST | cua-cli = deny+/api/chat/conversations/{id}/turns | id | POST | dcr-client = deny+/api/chat/conversations/{id}/turns | id | POST | empty-sub = deny+/api/chat/conversations/{id}/turns | id | POST | github-oidc = deny+/api/chat/conversations/{id}/turns | id | POST | oauth2-proxy = deny+/api/chat/conversations/{id}/turns | id | POST | per-key-other-ns = deny+/api/chat/conversations/{id}/turns | id | POST | per-key-owned-ns = deny+/api/chat/conversations/{id}/turns | id | POST | spa = allow+/api/chat/conversations/{id}/turns | id | POST | user-key = deny+/api/chat/conversations/{id}/turns | id | POST | user-key-verified = deny+/api/chat/conversations/{id}/turns | id | QUERY | admin-spa = allow+/api/chat/conversations/{id}/turns | id | QUERY | cua-cli = deny+/api/chat/conversations/{id}/turns | id | QUERY | dcr-client = deny+/api/chat/conversations/{id}/turns | id | QUERY | empty-sub = deny+/api/chat/conversations/{id}/turns | id | QUERY | github-oidc = deny+/api/chat/conversations/{id}/turns | id | QUERY | oauth2-proxy = deny+/api/chat/conversations/{id}/turns | id | QUERY | per-key-other-ns = deny+/api/chat/conversations/{id}/turns | id | QUERY | per-key-owned-ns = deny+/api/chat/conversations/{id}/turns | id | QUERY | spa = allow+/api/chat/conversations/{id}/turns | id | QUERY | user-key = deny+/api/chat/conversations/{id}/turns | id | QUERY | user-key-verified = deny/api/config | plain | DELETE | admin-spa = allow/api/config | plain | DELETE | cua-cli = allow/api/config | plain | DELETE | dcr-client = denydiff --git a/libs/fleet/backend/chat/litellm.go b/libs/fleet/backend/chat/litellm.gonew file mode 100644index 0000000000..1c86a652d5--- /dev/null+++ b/libs/fleet/backend/chat/litellm.go@@ -0,0 +1,343 @@+package chat++import (+ "bufio"+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "io"+ "net/http"+ "sort"+ "strings"+ "time"+)++const (+ bashToolDescription = "Execute a command in a temporary, isolated in-browser virtual filesystem. Network and host filesystem access are unavailable."+ liteLLMResponseMaxBytes = 128 << 10+)++// ModelClient produces one assistant response while streaming content deltas.+type ModelClient interface {+ Complete(ctx context.Context, messages []Message, onDelta func(string) error) (Message, error)+}++type LiteLLMClient struct {+ BaseURL string+ APIKey string+ Model string+ HTTPClient *http.Client+}++func NewLiteLLMClient(baseURL, apiKey, model string) *LiteLLMClient {+ return &LiteLLMClient{+ BaseURL: baseURL,+ APIKey: apiKey,+ Model: model,+ HTTPClient: http.DefaultClient,+ }+}++type liteLLMRequest struct {+ Model string `json:"model"`+ Stream bool `json:"stream"`+ Messages []liteLLMMessage `json:"messages"`+ Tools []liteLLMTool `json:"tools"`+}++type liteLLMMessage struct {+ Role Role `json:"role"`+ Content string `json:"content"`+ ToolCallID string `json:"tool_call_id,omitempty"`+ ToolCalls []ToolCall `json:"tool_calls,omitempty"`+}++type liteLLMTool struct {+ Type string `json:"type"`+ Function liteLLMToolFunction `json:"function"`+}++type liteLLMToolFunction struct {+ Name string `json:"name"`+ Description string `json:"description"`+ Parameters liteLLMToolParameters `json:"parameters"`+}++type liteLLMToolParameters struct {+ Type string `json:"type"`+ AdditionalProperties bool `json:"additionalProperties"`+ Properties map[string]liteLLMToolProperty `json:"properties"`+ Required []string `json:"required"`+}++type liteLLMToolProperty struct {+ Type string `json:"type"`+ Minimum *int `json:"minimum,omitempty"`+ Maximum *int `json:"maximum,omitempty"`+}++type liteLLMChunk struct {+ Choices []liteLLMChoice `json:"choices"`+}++type liteLLMChoice struct {+ Delta *liteLLMDelta `json:"delta"`+}++type liteLLMDelta struct {+ Content string `json:"content"`+ ToolCalls []liteLLMToolCallDelta `json:"tool_calls"`+}++type liteLLMToolCallDelta struct {+ Index int `json:"index"`+ ID string `json:"id"`+ Type string `json:"type"`+ Function liteLLMFunctionDelta `json:"function"`+}++type liteLLMFunctionDelta struct {+ Name string `json:"name"`+ Arguments string `json:"arguments"`+}++func (client *LiteLLMClient) Complete(ctx context.Context, messages []Message, onDelta func(string) error) (Message, error) {+ requestBody, err := json.Marshal(liteLLMRequest{+ Model: client.Model,+ Stream: true,+ Messages: liteLLMMessages(messages),+ Tools: []liteLLMTool{bashTool()},+ })+ if err != nil {+ return Message{}, fmt.Errorf("marshal LiteLLM request: %w", err)+ }++ request, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(client.BaseURL, "/")+"/chat/completions", strings.NewReader(string(requestBody)))+ if err != nil {+ return Message{}, fmt.Errorf("create LiteLLM request: %w", err)+ }+ request.Header.Set("Content-Type", "application/json")+ if client.APIKey != "" {+ request.Header.Set("Authorization", "Bearer "+client.APIKey)+ }++ httpClient := client.HTTPClient+ if httpClient == nil {+ httpClient = http.DefaultClient+ }+ response, err := httpClient.Do(request)+ if err != nil {+ if ctx.Err() != nil {+ return Message{}, ctx.Err()+ }+ return Message{}, fmt.Errorf("send LiteLLM request: %w", err)+ }+ defer response.Body.Close()++ if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {+ return Message{}, liteLLMResponseError(response)+ }++ var content strings.Builder+ toolCalls := make(map[int]ToolCall)+ done := false+ reader := bufio.NewReader(response.Body)+ for {+ data, err := readSSEData(reader)+ if err != nil {+ if errors.Is(err, io.EOF) {+ break+ }+ if ctx.Err() != nil {+ return Message{}, ctx.Err()+ }+ return Message{}, fmt.Errorf("read LiteLLM stream: %w", err)+ }+ if err := ctx.Err(); err != nil {+ return Message{}, err+ }+ if strings.TrimSpace(data) == "[DONE]" {+ done = true+ break+ }++ var chunk liteLLMChunk+ if err := json.Unmarshal([]byte(data), &chunk); err != nil {+ return Message{}, fmt.Errorf("parse SSE chunk: %w", err)+ }+ if len(chunk.Choices) != 1 || chunk.Choices[0].Delta == nil {+ return Message{}, errors.New("unsupported LiteLLM SSE response shape")+ }+ if err := ctx.Err(); err != nil {+ return Message{}, err+ }++ delta := chunk.Choices[0].Delta+ if delta.Content != "" {+ if content.Len()+len(delta.Content) > liteLLMResponseMaxBytes {+ return Message{}, errors.New("LiteLLM response exceeds size limit")+ }+ if onDelta != nil {+ if err := onDelta(delta.Content); err != nil {+ return Message{}, fmt.Errorf("handle content delta: %w", err)+ }+ if err := ctx.Err(); err != nil {+ return Message{}, err+ }+ }+ content.WriteString(delta.Content)+ }+ for _, toolCallDelta := range delta.ToolCalls {+ if toolCallDelta.Index < 0 {+ return Message{}, errors.New("unsupported LiteLLM tool call index")+ }+ toolCall := toolCalls[toolCallDelta.Index]+ if toolCallDelta.ID != "" {+ toolCall.ID = toolCallDelta.ID+ }+ if toolCallDelta.Type != "" {+ toolCall.Type = toolCallDelta.Type+ }+ if toolCallDelta.Function.Name != "" {+ toolCall.Function.Name = toolCallDelta.Function.Name+ }+ toolCall.Function.Arguments += toolCallDelta.Function.Arguments+ toolCalls[toolCallDelta.Index] = toolCall+ if content.Len()+toolCallsSize(toolCalls) > liteLLMResponseMaxBytes {+ return Message{}, errors.New("LiteLLM response exceeds size limit")+ }+ }+ }+ if !done {+ return Message{}, errors.New("LiteLLM stream ended without [DONE]")+ }++ id, err := newUUID()+ if err != nil {+ return Message{}, fmt.Errorf("generate assistant message ID: %w", err)+ }+ return Message{+ ID: id,+ Role: RoleAssistant,+ Content: content.String(),+ ToolCalls: orderedToolCalls(toolCalls),+ CreatedAt: time.Now().UTC(),+ }, nil+}++func toolCallsSize(toolCalls map[int]ToolCall) int {+ total := 0+ for _, call := range toolCalls {+ total += len(call.ID) + len(call.Type) + len(call.Function.Name) + len(call.Function.Arguments)+ }+ return total+}++func liteLLMMessages(messages []Message) []liteLLMMessage {+ mapped := make([]liteLLMMessage, 0, len(messages))+ for _, message := range messages {+ switch message.Role {+ case RoleUser, RoleAssistant, RoleTool:+ mapped = append(mapped, liteLLMMessage{+ Role: message.Role,+ Content: message.Content,+ ToolCallID: message.ToolCallID,+ ToolCalls: message.ToolCalls,+ })+ }+ }+ return mapped+}++func bashTool() liteLLMTool {+ timeoutMinimum, timeoutMaximum := 250, 60000+ outputMinimum, outputMaximum := 256, 100000+ return liteLLMTool{+ Type: "function",+ Function: liteLLMToolFunction{+ Name: "bash",+ Description: bashToolDescription,+ Parameters: liteLLMToolParameters{+ Type: "object",+ AdditionalProperties: false,+ Properties: map[string]liteLLMToolProperty{+ "command": {Type: "string"},+ "timeout_ms": {Type: "integer", Minimum: &timeoutMinimum, Maximum: &timeoutMaximum},+ "max_output_chars": {Type: "integer", Minimum: &outputMinimum, Maximum: &outputMaximum},+ },+ Required: []string{"command"},+ },+ },+ }+}++func readSSEData(reader *bufio.Reader) (string, error) {+ var dataLines []string+ for {+ line, err := reader.ReadString('\n')+ if len(line) > 0 {+ line = strings.TrimSuffix(line, "\n")+ line = strings.TrimSuffix(line, "\r")+ if line == "" {+ if len(dataLines) > 0 {+ return strings.Join(dataLines, "\n"), nil+ }+ } else if strings.HasPrefix(line, "data:") {+ data := strings.TrimPrefix(line, "data:")+ dataLines = append(dataLines, strings.TrimPrefix(data, " "))+ }+ }+ if err != nil {+ if errors.Is(err, io.EOF) && len(dataLines) > 0 {+ return strings.Join(dataLines, "\n"), nil+ }+ return "", err+ }+ }+}++func orderedToolCalls(toolCalls map[int]ToolCall) []ToolCall {+ if len(toolCalls) == 0 {+ return nil+ }+ indexes := make([]int, 0, len(toolCalls))+ for index := range toolCalls {+ indexes = append(indexes, index)+ }+ sort.Ints(indexes)+ ordered := make([]ToolCall, 0, len(indexes))+ for _, index := range indexes {+ ordered = append(ordered, toolCalls[index])+ }+ return ordered+}++func liteLLMResponseError(response *http.Response) error {+ body, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))+ if err != nil {+ return fmt.Errorf("read LiteLLM error response: %w", err)+ }++ message := strings.TrimSpace(string(body))+ var payload struct {+ Error json.RawMessage `json:"error"`+ }+ if json.Unmarshal(body, &payload) == nil && len(payload.Error) > 0 {+ var detail struct {+ Message string `json:"message"`+ }+ if json.Unmarshal(payload.Error, &detail) == nil && detail.Message != "" {+ message = detail.Message+ } else {+ var errorString string+ if json.Unmarshal(payload.Error, &errorString) == nil && errorString != "" {+ message = errorString+ }+ }+ }+ if message == "" {+ message = response.Status+ }+ return fmt.Errorf("LiteLLM request failed: status %d: %s", response.StatusCode, message)+}diff --git a/libs/fleet/backend/chat/litellm_test.go b/libs/fleet/backend/chat/litellm_test.gonew file mode 100644index 0000000000..0a074d87a8--- /dev/null+++ b/libs/fleet/backend/chat/litellm_test.go@@ -0,0 +1,265 @@+package chat++import (+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"+)++func TestLiteLLMCompleteStreamsContentAndRequest(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ if request.Method != http.MethodPost {+ t.Errorf("method = %s, want POST", request.Method)+ }+ if request.URL.Path != "/v1/chat/completions" {+ t.Errorf("path = %s, want /v1/chat/completions", request.URL.Path)+ }+ if authorization := request.Header.Get("Authorization"); authorization != "Bearer test-key" {+ t.Errorf("Authorization = %q, want bearer token", authorization)+ }++ var body struct {+ Model string `json:"model"`+ Stream bool `json:"stream"`+ Messages []struct {+ Role string `json:"role"`+ } `json:"messages"`+ Tools []struct {+ Type string `json:"type"`+ Function struct {+ Name string `json:"name"`+ Description string `json:"description"`+ Parameters struct {+ Type string `json:"type"`+ AdditionalProperties bool `json:"additionalProperties"`+ Properties map[string]struct {+ Type string `json:"type"`+ Minimum *int `json:"minimum"`+ Maximum *int `json:"maximum"`+ } `json:"properties"`+ Required []string `json:"required"`+ } `json:"parameters"`+ } `json:"function"`+ } `json:"tools"`+ }+ if err := json.NewDecoder(request.Body).Decode(&body); err != nil {+ t.Fatal(err)+ }+ if body.Model != "test-model" || !body.Stream {+ t.Errorf("model/stream = %q/%t, want test-model/true", body.Model, body.Stream)+ }+ for _, message := range body.Messages {+ if message.Role == "system" {+ t.Fatal("request included a system-role message")+ }+ }+ if len(body.Tools) != 1 {+ t.Fatalf("tool count = %d, want 1", len(body.Tools))+ }+ tool := body.Tools[0]+ if tool.Type != "function" || tool.Function.Name != "bash" {+ t.Fatalf("tool = %#v, want bash function", tool)+ }+ if tool.Function.Description != "Execute a command in a temporary, isolated in-browser virtual filesystem. Network and host filesystem access are unavailable." {+ t.Errorf("description = %q", tool.Function.Description)+ }+ parameters := tool.Function.Parameters+ if parameters.Type != "object" || parameters.AdditionalProperties {+ t.Errorf("parameters object/additionalProperties = %q/%t", parameters.Type, parameters.AdditionalProperties)+ }+ if got := parameters.Required; len(got) != 1 || got[0] != "command" {+ t.Errorf("required = %#v, want [command]", got)+ }+ if parameters.Properties["command"].Type != "string" || parameters.Properties["timeout_ms"].Minimum == nil || *parameters.Properties["timeout_ms"].Minimum != 250 || parameters.Properties["timeout_ms"].Maximum == nil || *parameters.Properties["timeout_ms"].Maximum != 60000 || parameters.Properties["max_output_chars"].Minimum == nil || *parameters.Properties["max_output_chars"].Minimum != 256 || parameters.Properties["max_output_chars"].Maximum == nil || *parameters.Properties["max_output_chars"].Maximum != 100000 {+ t.Errorf("unexpected bash tool parameters: %#v", parameters)+ }++ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"content\":\"Hello \"}}]}\n\n")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"content\":\"world\"}}]}\n\n")+ fmt.Fprint(writer, "data: [DONE]\n\n")+ }))+ defer server.Close()++ client := NewLiteLLMClient(server.URL+"/v1", "test-key", "test-model")+ var deltas []string+ message, err := client.Complete(context.Background(), []Message{+ {Role: Role("system"), Content: "must not be sent"},+ {Role: RoleUser, Content: "Say hello"},+ }, func(delta string) error {+ deltas = append(deltas, delta)+ return nil+ })+ if err != nil {+ t.Fatal(err)+ }+ if message.Role != RoleAssistant || message.Content != "Hello world" {+ t.Fatalf("message = %#v, want assembled assistant content", message)+ }+ if message.ID == "" || message.CreatedAt.IsZero() {+ t.Fatalf("message was not stamped: %#v", message)+ }+ if got := strings.Join(deltas, ""); got != "Hello world" {+ t.Fatalf("deltas = %#v, want Hello world", deltas)+ }+}++func TestLiteLLMCompleteAssemblesIndexedToolCallsAcrossLargeFrames(t *testing.T) {+ largeArguments := strings.Repeat("x", 70_000)+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call-1\",\"type\":\"function\",\"function\":{\"name\":\"bash\",\"arguments\":\"{\\\"command\\\":\\\"p\"}}]}}]}\n\n")+ fmt.Fprintf(writer, "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":%q}}]}}]}\n\n", largeArguments+`wd"}`)+ fmt.Fprint(writer, "data: [DONE]\n\n")+ }))+ defer server.Close()++ message, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(context.Background(), []Message{{Role: RoleUser, Content: "where am I?"}}, nil)+ if err != nil {+ t.Fatal(err)+ }+ if len(message.ToolCalls) != 1 {+ t.Fatalf("tool calls = %#v, want one", message.ToolCalls)+ }+ wantArguments := `{"command":"p` + largeArguments + `wd"}`+ want := ToolCall{ID: "call-1", Type: "function", Function: ToolFunction{Name: "bash", Arguments: wantArguments}}+ if got := message.ToolCalls[0]; got != want {+ t.Fatalf("tool call = %#v, want %#v", got, want)+ }+}++func TestLiteLLMCompleteReturnsNonSuccessJSONError(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "application/json")+ writer.WriteHeader(http.StatusTooManyRequests)+ fmt.Fprint(writer, `{"error":{"message":"rate limited"}}`)+ }))+ defer server.Close()++ _, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(context.Background(), nil, nil)+ if err == nil || !strings.Contains(err.Error(), "429") || !strings.Contains(err.Error(), "rate limited") {+ t.Fatalf("error = %v, want status and JSON message", err)+ }+}++func TestLiteLLMCompleteRejectsMalformedSSE(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {not json}\n\n")+ }))+ defer server.Close()++ _, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(context.Background(), nil, nil)+ if err == nil || !strings.Contains(err.Error(), "parse SSE chunk") {+ t.Fatalf("error = %v, want malformed SSE error", err)+ }+}++func TestLiteLLMCompleteRejectsMissingDone(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"content\":\"incomplete\"}}]}\n\n")+ }))+ defer server.Close()++ _, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(context.Background(), nil, nil)+ if err == nil || !strings.Contains(err.Error(), "[DONE]") {+ t.Fatalf("error = %v, want missing [DONE] error", err)+ }+}++func TestLiteLLMCompleteReturnsCallbackError(t *testing.T) {+ callbackError := errors.New("client disconnected")+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n")+ fmt.Fprint(writer, "data: [DONE]\n\n")+ }))+ defer server.Close()++ _, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(context.Background(), nil, func(string) error {+ return callbackError+ })+ if !errors.Is(err, callbackError) {+ t.Fatalf("error = %v, want callback error", err)+ }+}++func TestLiteLLMCompleteReturnsContextCancellation(t *testing.T) {+ requestStarted := make(chan struct{})+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ writer.WriteHeader(http.StatusOK)+ writer.(http.Flusher).Flush()+ close(requestStarted)+ <-request.Context().Done()+ }))+ defer server.Close()++ requestContext, cancel := context.WithCancel(context.Background())+ defer cancel()+ errorsChannel := make(chan error, 1)+ go func() {+ _, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(requestContext, nil, nil)+ errorsChannel <- err+ }()++ select {+ case <-requestStarted:+ cancel()+ case <-time.After(time.Second):+ t.Fatal("request did not reach test server")+ }+ select {+ case err := <-errorsChannel:+ if !errors.Is(err, context.Canceled) {+ t.Fatalf("error = %v, want context cancellation", err)+ }+ case <-time.After(time.Second):+ t.Fatal("Complete did not return after context cancellation")+ }+}++func TestLiteLLMCompleteReturnsCancellationFromSuccessfulDeltaCallback(t *testing.T) {+ requestContext, cancel := context.WithCancel(context.Background())+ defer cancel()++ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprint(writer, "data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n")+ fmt.Fprint(writer, "data: [DONE]\n\n")+ }))+ defer server.Close()++ message, err := NewLiteLLMClient(server.URL, "", "test-model").Complete(requestContext, nil, func(string) error {+ cancel()+ return nil+ })+ if !errors.Is(err, context.Canceled) {+ t.Fatalf("error = %v, want context cancellation", err)+ }+ if message.ID != "" || message.Content != "" || message.Role != "" {+ t.Fatalf("message = %#v, want zero message after cancellation", message)+ }+}++func TestLiteLLMCompleteRejectsOversizedAssistantOutput(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ writer.Header().Set("Content-Type", "text/event-stream")+ fmt.Fprintf(writer, "data: {\"choices\":[{\"delta\":{\"content\":%q}}]}\n\n", strings.Repeat("x", (128<<10)+1))+ fmt.Fprint(writer, "data: [DONE]\n\n")+ }))+ defer server.Close()++ client := NewLiteLLMClient(server.URL, "", "test-model")+ _, err := client.Complete(context.Background(), []Message{{Role: RoleUser, Content: "hello"}}, nil)+ if err == nil || !strings.Contains(err.Error(), "response exceeds") {+ t.Fatalf("error = %v, want response size error", err)+ }+}diff --git a/libs/fleet/backend/chat/store.go b/libs/fleet/backend/chat/store.gonew file mode 100644index 0000000000..46b3baa0c4--- /dev/null+++ b/libs/fleet/backend/chat/store.go@@ -0,0 +1,207 @@+package chat++import (+ "context"+ "crypto/rand"+ "errors"+ "fmt"+ "sort"+ "strings"+ "sync"+ "time"+)++var (+ ErrConversationNotFound = errors.New("conversation not found")+ ErrConversationLimit = errors.New("conversation storage limit reached")+)++const (+ memoryConversationMaxPerOwner = 100+ memoryConversationMaxBytes = 64 << 20+)++type ConversationStore interface {+ Create(ctx context.Context, ownerID string) (*Conversation, error)+ List(ctx context.Context, ownerID string) ([]ConversationSummary, error)+ Get(ctx context.Context, ownerID, conversationID string) (*Conversation, error)+ Append(ctx context.Context, ownerID, conversationID string, messages ...Message) error+}++type conversationRecord struct {+ OwnerID string+ Conversation+}++type MemoryConversationStore struct {+ mu sync.RWMutex+ conversations map[string]*conversationRecord+ ownerConversations map[string]int+ maxPerOwner int+ maxBytes int+ totalBytes int+}++func NewMemoryConversationStore() *MemoryConversationStore {+ return newMemoryConversationStore(memoryConversationMaxPerOwner, memoryConversationMaxBytes)+}++func newMemoryConversationStore(maxPerOwner, maxBytes int) *MemoryConversationStore {+ return &MemoryConversationStore{+ conversations: make(map[string]*conversationRecord),+ ownerConversations: make(map[string]int),+ maxPerOwner: maxPerOwner,+ maxBytes: maxBytes,+ }+}++func (store *MemoryConversationStore) Create(_ context.Context, ownerID string) (*Conversation, error) {+ store.mu.Lock()+ defer store.mu.Unlock()++ if store.ownerConversations[ownerID] >= store.maxPerOwner {+ return nil, ErrConversationLimit+ }+ id, err := newUUID()+ if err != nil {+ return nil, fmt.Errorf("generate conversation ID: %w", err)+ }+ now := time.Now().UTC()+ record := &conversationRecord{+ OwnerID: ownerID,+ Conversation: Conversation{+ ID: id,+ CreatedAt: now,+ UpdatedAt: now,+ },+ }+ store.conversations[id] = record+ store.ownerConversations[ownerID]++++ return cloneConversation(record.Conversation), nil+}++func (store *MemoryConversationStore) List(_ context.Context, ownerID string) ([]ConversationSummary, error) {+ store.mu.RLock()+ summaries := make([]ConversationSummary, 0)+ for _, record := range store.conversations {+ if record.OwnerID != ownerID {+ continue+ }+ summaries = append(summaries, ConversationSummary{+ ID: record.ID,+ Title: record.Title,+ CreatedAt: record.CreatedAt,+ UpdatedAt: record.UpdatedAt,+ })+ }+ store.mu.RUnlock()++ sort.Slice(summaries, func(left, right int) bool {+ return summaries[left].UpdatedAt.After(summaries[right].UpdatedAt)+ })+ return summaries, nil+}++func (store *MemoryConversationStore) Get(_ context.Context, ownerID, conversationID string) (*Conversation, error) {+ store.mu.RLock()+ record, ok := store.conversations[conversationID]+ if !ok || record.OwnerID != ownerID {+ store.mu.RUnlock()+ return nil, ErrConversationNotFound+ }+ conversation := cloneConversation(record.Conversation)+ store.mu.RUnlock()++ return conversation, nil+}++func (store *MemoryConversationStore) Append(_ context.Context, ownerID, conversationID string, messages ...Message) error {+ store.mu.Lock()+ defer store.mu.Unlock()++ record, ok := store.conversations[conversationID]+ if !ok || record.OwnerID != ownerID {+ return ErrConversationNotFound+ }+ if len(messages) == 0 {+ return nil+ }++ now := time.Now().UTC()+ pending := make([]Message, len(messages))+ addedBytes := 0+ for index, message := range messages {+ if message.ID == "" {+ id, err := newUUID()+ if err != nil {+ return fmt.Errorf("generate message ID: %w", err)+ }+ message.ID = id+ }+ if message.CreatedAt.IsZero() {+ message.CreatedAt = now+ }+ pending[index] = cloneMessage(message)+ addedBytes += messageSize(message)+ }+ if store.totalBytes+addedBytes > store.maxBytes {+ return ErrConversationLimit+ }+ record.Messages = append(record.Messages, pending...)+ store.totalBytes += addedBytes+ if record.Title == "" {+ record.Title = titleFromFirstUserMessage(record.Messages)+ }+ record.UpdatedAt = now++ return nil+}++func messageSize(message Message) int {+ total := len(message.ID) + len(message.Role) + len(message.Content) + len(message.ToolCallID)+ for _, call := range message.ToolCalls {+ total += len(call.ID) + len(call.Type) + len(call.Function.Name) + len(call.Function.Arguments)+ }+ return total+}++func newUUID() (string, error) {+ bytes := make([]byte, 16)+ if _, err := rand.Read(bytes); err != nil {+ return "", err+ }+ bytes[6] = bytes[6]&0x0f | 0x40+ bytes[8] = bytes[8]&0x3f | 0x80+ return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", bytes[0:4], bytes[4:6], bytes[6:8], bytes[8:10], bytes[10:16]), nil+}++func titleFromFirstUserMessage(messages []Message) string {+ for _, message := range messages {+ if message.Role != RoleUser {+ continue+ }+ title := strings.TrimSpace(message.Content)+ runes := []rune(title)+ if len(runes) > 80 {+ return string(runes[:80])+ }+ return title+ }+ return ""+}++func cloneConversation(conversation Conversation) *Conversation {+ cloned := conversation+ cloned.Messages = make([]Message, len(conversation.Messages))+ for index, message := range conversation.Messages {+ cloned.Messages[index] = cloneMessage(message)+ }+ return &cloned+}++func cloneMessage(message Message) Message {+ cloned := message+ cloned.ToolCalls = append([]ToolCall(nil), message.ToolCalls...)+ return cloned+}diff --git a/libs/fleet/backend/chat/store_test.go b/libs/fleet/backend/chat/store_test.gonew file mode 100644index 0000000000..9f0b0933ef--- /dev/null+++ b/libs/fleet/backend/chat/store_test.go@@ -0,0 +1,237 @@+package chat++import (+ "context"+ "errors"+ "fmt"+ "strings"+ "sync"+ "testing"+)++func TestMemoryStoreTitlesAndOrdersConversations(t *testing.T) {+ store := NewMemoryConversationStore()+ first, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ second, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ if err := store.Append(context.Background(), "owner-a", first.ID, Message{Role: RoleUser, Content: " First useful question "}); err != nil {+ t.Fatal(err)+ }+ if err := store.Append(context.Background(), "owner-a", second.ID, Message{Role: RoleUser, Content: "Newest question"}); err != nil {+ t.Fatal(err)+ }++ got, err := store.List(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ if len(got) != 2 || got[0].ID != second.ID || got[1].Title != "First useful question" {+ t.Fatalf("unexpected summaries: %#v", got)+ }+}++func TestMemoryStoreHidesOtherOwners(t *testing.T) {+ store := NewMemoryConversationStore()+ conversation, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ if _, err := store.Get(context.Background(), "owner-b", conversation.ID); !errors.Is(err, ErrConversationNotFound) {+ t.Fatalf("Get error = %v, want ErrConversationNotFound", err)+ }+ if err := store.Append(context.Background(), "owner-b", conversation.ID, Message{Role: RoleUser, Content: "no"}); !errors.Is(err, ErrConversationNotFound) {+ t.Fatalf("Append error = %v, want ErrConversationNotFound", err)+ }+}++func TestMemoryStoreReturnsDeepCopies(t *testing.T) {+ store := NewMemoryConversationStore()+ conversation, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ message := Message{+ Role: RoleAssistant,+ Content: "original",+ ToolCalls: []ToolCall{{+ ID: "call-1",+ Type: "function",+ Function: ToolFunction{+ Name: "run_bash",+ Arguments: `{"command":"pwd"}`,+ },+ }},+ }+ if err := store.Append(context.Background(), "owner-a", conversation.ID, message); err != nil {+ t.Fatal(err)+ }++ got, err := store.Get(context.Background(), "owner-a", conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ got.Title = "mutated"+ got.Messages[0].Content = "mutated"+ got.Messages[0].ToolCalls[0].Function.Name = "mutated"++ again, err := store.Get(context.Background(), "owner-a", conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if again.Title != "" || again.Messages[0].Content != "original" || again.Messages[0].ToolCalls[0].Function.Name != "run_bash" {+ t.Fatalf("store leaked returned mutation: %#v", again)+ }+}++func TestMemoryStoreConcurrentAppend(t *testing.T) {+ store := NewMemoryConversationStore()+ conversation, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }++ const writers = 25+ var waitGroup sync.WaitGroup+ waitGroup.Add(writers)+ for index := range writers {+ go func() {+ defer waitGroup.Done()+ if err := store.Append(context.Background(), "owner-a", conversation.ID, Message{Role: RoleUser, Content: fmt.Sprintf("message-%d", index)}); err != nil {+ t.Errorf("Append() error = %v", err)+ }+ }()+ }+ waitGroup.Wait()++ got, err := store.Get(context.Background(), "owner-a", conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if len(got.Messages) != writers {+ t.Fatalf("message count = %d, want %d", len(got.Messages), writers)+ }+}++func TestMemoryStoreCreateDoesNotRaceWithDiscoveryAndAppend(t *testing.T) {+ const (+ creators = 4+ conversationsPerCreator = 1_000+ )++ store := newMemoryConversationStore(creators*conversationsPerCreator, memoryConversationMaxBytes)+ ctx := context.Background()+ done := make(chan struct{})+ var discoveryWaitGroup sync.WaitGroup+ discoveryWaitGroup.Add(1)+ go func() {+ defer discoveryWaitGroup.Done()+ seen := make(map[string]struct{})+ for {+ select {+ case <-done:+ return+ default:+ }++ summaries, err := store.List(ctx, "owner-a")+ if err != nil {+ t.Errorf("List() error = %v", err)+ return+ }+ for _, summary := range summaries {+ if _, ok := seen[summary.ID]; ok {+ continue+ }+ seen[summary.ID] = struct{}{}+ if err := store.Append(ctx, "owner-a", summary.ID, Message{Role: RoleUser, Content: "discovered"}); err != nil {+ t.Errorf("Append() error = %v", err)+ return+ }+ }+ }+ }()++ var createWaitGroup sync.WaitGroup+ createWaitGroup.Add(creators)+ for range creators {+ go func() {+ defer createWaitGroup.Done()+ for range conversationsPerCreator {+ if _, err := store.Create(ctx, "owner-a"); err != nil {+ t.Errorf("Create() error = %v", err)+ return+ }+ }+ }()+ }+ createWaitGroup.Wait()+ close(done)+ discoveryWaitGroup.Wait()+}++func TestMemoryStoreStampsMessagesAndCapsTitle(t *testing.T) {+ store := NewMemoryConversationStore()+ conversation, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ content := " " + strings.Repeat("a", 81) + " "+ if err := store.Append(context.Background(), "owner-a", conversation.ID, Message{Role: RoleUser, Content: content}); err != nil {+ t.Fatal(err)+ }++ got, err := store.Get(context.Background(), "owner-a", conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if got.Title != content[2:82] {+ t.Fatalf("title = %q, want 80-character prefix", got.Title)+ }+ if got.Messages[0].ID == "" {+ t.Fatal("message ID was not stamped")+ }+ if got.Messages[0].CreatedAt.IsZero() {+ t.Fatal("message CreatedAt was not stamped")+ }+ if !got.UpdatedAt.After(got.CreatedAt) && !got.UpdatedAt.Equal(got.CreatedAt) {+ t.Fatalf("UpdatedAt = %v, CreatedAt = %v", got.UpdatedAt, got.CreatedAt)+ }+}++func TestMemoryConversationStoreLimitsConversationsPerOwner(t *testing.T) {+ store := newMemoryConversationStore(2, 1<<20)+ for index := 0; index < 2; index++ {+ if _, err := store.Create(context.Background(), "owner-a"); err != nil {+ t.Fatalf("create %d: %v", index, err)+ }+ }+ if _, err := store.Create(context.Background(), "owner-a"); !errors.Is(err, ErrConversationLimit) {+ t.Fatalf("error = %v, want ErrConversationLimit", err)+ }+ if _, err := store.Create(context.Background(), "owner-b"); err != nil {+ t.Fatalf("other owner create: %v", err)+ }+}++func TestMemoryConversationStoreLimitsAggregateBytes(t *testing.T) {+ store := newMemoryConversationStore(10, 1024)+ conversation, err := store.Create(context.Background(), "owner-a")+ if err != nil {+ t.Fatal(err)+ }+ if err := store.Append(context.Background(), "owner-a", conversation.ID, Message{Role: RoleUser, Content: strings.Repeat("x", 2048)}); !errors.Is(err, ErrConversationLimit) {+ t.Fatalf("error = %v, want ErrConversationLimit", err)+ }+ stored, err := store.Get(context.Background(), "owner-a", conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if len(stored.Messages) != 0 {+ t.Fatalf("oversized append mutated conversation: %#v", stored.Messages)+ }+}diff --git a/libs/fleet/backend/chat/types.go b/libs/fleet/backend/chat/types.gonew file mode 100644index 0000000000..d28c32c367--- /dev/null+++ b/libs/fleet/backend/chat/types.go@@ -0,0 +1,73 @@+package chat++import (+ "encoding/json"+ "time"+)++type Role string++const (+ RoleUser Role = "user"+ RoleAssistant Role = "assistant"+ RoleTool Role = "tool"+)++type ToolFunction struct {+ Name string `json:"name"`+ Arguments string `json:"arguments"`+}++type ToolCall struct {+ ID string `json:"id"`+ Type string `json:"type"`+ Function ToolFunction `json:"function"`+}++type Message struct {+ ID string `json:"id,omitempty"`+ Role Role `json:"role"`+ Content string `json:"content"`+ ToolCallID string `json:"tool_call_id,omitempty"`+ ToolCalls []ToolCall `json:"tool_calls,omitempty"`+ CreatedAt time.Time `json:"created_at,omitempty"`+}++type Conversation struct {+ ID string `json:"id"`+ Title string `json:"title"`+ Messages []Message `json:"messages"`+ CreatedAt time.Time `json:"created_at"`+ UpdatedAt time.Time `json:"updated_at"`+}++type ConversationSummary struct {+ ID string `json:"id"`+ Title string `json:"title"`+ CreatedAt time.Time `json:"created_at"`+ UpdatedAt time.Time `json:"updated_at"`+}++type messageJSON struct {+ ID string `json:"id,omitempty"`+ Role Role `json:"role"`+ Content string `json:"content"`+ ToolCallID string `json:"tool_call_id,omitempty"`+ ToolCalls []ToolCall `json:"tool_calls,omitempty"`+ CreatedAt *time.Time `json:"created_at,omitempty"`+}++func (message Message) MarshalJSON() ([]byte, error) {+ var createdAt *time.Time+ if !message.CreatedAt.IsZero() {+ createdAt = &message.CreatedAt+ }+ return json.Marshal(messageJSON{+ ID: message.ID,+ Role: message.Role,+ Content: message.Content,+ ToolCallID: message.ToolCallID,+ ToolCalls: message.ToolCalls,+ CreatedAt: createdAt,+ })+}diff --git a/libs/fleet/backend/config/config.go b/libs/fleet/backend/config/config.goindex 7e93ab1811..a1b4d325b8 100644--- a/libs/fleet/backend/config/config.go+++ b/libs/fleet/backend/config/config.go@@ -27,6 +27,7 @@ type Configuration struct {Gateway GatewayConfigurationDatabase DatabaseConfigurationStripe StripeConfiguration+ Chat ChatConfigurationMetrics MetricsConfigurationTelemetry TelemetryConfiguration}@@ -97,6 +98,13 @@ type DatabaseConfiguration struct {StateQueryTenantPassword string // STATE_QUERY_TENANT_PASSWORD — shared tenant query login password}+type ChatConfiguration struct {+ Enabled bool+ BaseURL string+ APIKey string+ Model string+}+type MetricsConfiguration struct {Addr string // METRICS_ADDR — Prometheus listen addr}@@ -146,6 +154,10 @@ var specs = []flagSpec{{"stripe.checkout-success-url", "stripe-checkout-success-url", "STRIPE_CHECKOUT_SUCCESS_URL", "", "Stripe Checkout success redirect URL"},{"stripe.checkout-cancel-url", "stripe-checkout-cancel-url", "STRIPE_CHECKOUT_CANCEL_URL", "", "Stripe Checkout cancel redirect URL"},{"stripe.portal-return-url", "stripe-portal-return-url", "STRIPE_PORTAL_RETURN_URL", "", "Stripe Billing Portal return URL"},+ {"chat.enabled", "chat-enabled", "CYCLOPS_CS_CHAT_ENABLED", "false", "enable browser bash chat"},+ {"chat.base-url", "litellm-base-url", "LITELLM_BASE_URL", "", "LiteLLM OpenAI-compatible base URL"},+ {"chat.api-key", "litellm-api-key", "LITELLM_API_KEY", "", "LiteLLM virtual key"},+ {"chat.model", "litellm-model", "LITELLM_MODEL", "large", "LiteLLM model alias"},{"metrics.addr", "metrics-addr", "METRICS_ADDR", ":9091", "Prometheus metrics listen address"},{"telemetry.endpoint", "otel-endpoint", "OTEL_EXPORTER_OTLP_ENDPOINT", "https://otel.cua.ai", "OTLP HTTP traces endpoint"},{"telemetry.protocol", "otel-protocol", "OTEL_EXPORTER_OTLP_PROTOCOL", "http/protobuf", "OTLP exporter protocol"},@@ -238,6 +250,12 @@ func LoadConfig() (*Configuration, error) {CheckoutCancelURL: viper.GetString("stripe.checkout-cancel-url"),PortalReturnURL: viper.GetString("stripe.portal-return-url"),},+ Chat: ChatConfiguration{+ Enabled: viper.GetBool("chat.enabled"),+ BaseURL: viper.GetString("chat.base-url"),+ APIKey: viper.GetString("chat.api-key"),+ Model: viper.GetString("chat.model"),+ },Metrics: MetricsConfiguration{Addr: viper.GetString("metrics.addr")},Telemetry: TelemetryConfiguration{Endpoint: viper.GetString("telemetry.endpoint"),@@ -251,5 +269,8 @@ func LoadConfig() (*Configuration, error) {if cfg.Keycloak.AdminClientSecret == "" {return nil, fmt.Errorf("KC_ADMIN_CLIENT_SECRET is required")}+ if cfg.Chat.Enabled && (cfg.Chat.BaseURL == "" || cfg.Chat.APIKey == "") {+ return nil, fmt.Errorf("chat.enabled requires LITELLM_BASE_URL and LITELLM_API_KEY")+ }return cfg, nil}diff --git a/libs/fleet/backend/config/config_test.go b/libs/fleet/backend/config/config_test.goindex 100401476e..bc833bc909 100644--- a/libs/fleet/backend/config/config_test.go+++ b/libs/fleet/backend/config/config_test.go@@ -3,6 +3,7 @@ package configimport ("os""slices"+ "strings""testing""github.com/spf13/pflag"@@ -181,3 +182,54 @@ func TestLoadConfig_StateDatabaseURLs(t *testing.T) {t.Fatalf("Database.StateQueryTenantPassword = %q, want %q", got, want)}}+++func loadChatTestConfig(t *testing.T) (*Configuration, error) {+ t.Helper()+ viper.Reset()+ t.Cleanup(viper.Reset)+ t.Setenv("KC_ADMIN_CLIENT_SECRET", "secret")+ RegisterFlags(pflag.NewFlagSet("chat-test", pflag.ContinueOnError))+ return LoadConfig()+}++func TestLoadConfig_ChatDisabledDefaults(t *testing.T) {+ cfg, err := loadChatTestConfig(t)+ if err != nil {+ t.Fatalf("LoadConfig() error = %v", err)+ }+ if cfg.Chat.Enabled || cfg.Chat.BaseURL != "" || cfg.Chat.APIKey != "" || cfg.Chat.Model != "large" {+ t.Fatalf("Chat = %#v, want disabled defaults", cfg.Chat)+ }+}++func TestLoadConfig_ChatEnabledWithCredentials(t *testing.T) {+ t.Setenv("CYCLOPS_CS_CHAT_ENABLED", "true")+ t.Setenv("LITELLM_BASE_URL", "https://litellm.example/v1")+ t.Setenv("LITELLM_API_KEY", "secret")+ t.Setenv("LITELLM_MODEL", "browser-bash")+ cfg, err := loadChatTestConfig(t)+ if err != nil {+ t.Fatalf("LoadConfig() error = %v", err)+ }+ if !cfg.Chat.Enabled || cfg.Chat.BaseURL != "https://litellm.example/v1" || cfg.Chat.APIKey != "secret" || cfg.Chat.Model != "browser-bash" {+ t.Fatalf("Chat = %#v, want enabled configuration", cfg.Chat)+ }+}++func TestLoadConfig_ChatEnabledRequiresCredentials(t *testing.T) {+ for name, env := range map[string]map[string]string{+ "missing base URL": {"CYCLOPS_CS_CHAT_ENABLED": "true", "LITELLM_API_KEY": "secret"},+ "missing API key": {"CYCLOPS_CS_CHAT_ENABLED": "true", "LITELLM_BASE_URL": "https://litellm.example/v1"},+ } {+ t.Run(name, func(t *testing.T) {+ for key, value := range env {+ t.Setenv(key, value)+ }+ _, err := loadChatTestConfig(t)+ if err == nil || !strings.Contains(err.Error(), "chat") {+ t.Fatalf("LoadConfig() error = %v, want chat credential error", err)+ }+ })+ }+}diff --git a/libs/fleet/backend/docs/docs.go b/libs/fleet/backend/docs/docs.goindex 0775bec6b2..233d8aea58 100644--- a/libs/fleet/backend/docs/docs.go+++ b/libs/fleet/backend/docs/docs.go@@ -251,6 +251,217 @@ const docTemplate = `{}}},+ "/api/chat/conversations": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "List the calling user's chat conversations",+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.ConversationSummary"+ }+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ },+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Create a chat conversation",+ "responses": {+ "201": {+ "description": "Created",+ "schema": {+ "$ref": "#/definitions/chat.Conversation"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "413": {+ "description": "Request Entity Too Large",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },+ "/api/chat/conversations/{id}": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Get a chat conversation",+ "parameters": [+ {+ "type": "string",+ "description": "Conversation ID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "$ref": "#/definitions/chat.Conversation"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },+ "/api/chat/conversations/{id}/turns": {+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/x-ndjson"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Send a chat turn and stream the assistant response",+ "parameters": [+ {+ "type": "string",+ "description": "Conversation ID",+ "name": "id",+ "in": "path",+ "required": true+ },+ {+ "description": "User message or tool results",+ "name": "body",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/handlers.TurnRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "$ref": "#/definitions/handlers.turnEvent"+ }+ },+ "400": {+ "description": "Bad Request",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },"/api/config": {"get": {"security": [@@ -995,6 +1206,110 @@ const docTemplate = `{}}},+ "chat.Conversation": {+ "type": "object",+ "properties": {+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "messages": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.Message"+ }+ },+ "title": {+ "type": "string"+ },+ "updated_at": {+ "type": "string"+ }+ }+ },+ "chat.ConversationSummary": {+ "type": "object",+ "properties": {+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "title": {+ "type": "string"+ },+ "updated_at": {+ "type": "string"+ }+ }+ },+ "chat.Message": {+ "type": "object",+ "properties": {+ "content": {+ "type": "string"+ },+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "role": {+ "$ref": "#/definitions/chat.Role"+ },+ "tool_call_id": {+ "type": "string"+ },+ "tool_calls": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.ToolCall"+ }+ }+ }+ },+ "chat.Role": {+ "type": "string",+ "enum": [+ "user",+ "assistant",+ "tool"+ ],+ "x-enum-varnames": [+ "RoleUser",+ "RoleAssistant",+ "RoleTool"+ ]+ },+ "chat.ToolCall": {+ "type": "object",+ "properties": {+ "function": {+ "$ref": "#/definitions/chat.ToolFunction"+ },+ "id": {+ "type": "string"+ },+ "type": {+ "type": "string"+ }+ }+ },+ "chat.ToolFunction": {+ "type": "object",+ "properties": {+ "arguments": {+ "type": "string"+ },+ "name": {+ "type": "string"+ }+ }+ },"handlers.BillingSessionResponse": {"type": "object","properties": {@@ -1012,6 +1327,9 @@ const docTemplate = `{},"billing": {"type": "boolean"+ },+ "chat": {+ "type": "boolean"}}},@@ -1157,6 +1475,17 @@ const docTemplate = `{}}},+ "handlers.TurnRequest": {+ "type": "object",+ "properties": {+ "messages": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.Message"+ }+ }+ }+ },"handlers.UserKeyResponse": {"type": "object","properties": {@@ -1177,6 +1506,20 @@ const docTemplate = `{}}},+ "handlers.turnEvent": {+ "type": "object",+ "properties": {+ "delta": {+ "type": "string"+ },+ "message": {+ "$ref": "#/definitions/chat.Message"+ },+ "type": {+ "type": "string"+ }+ }+ },"keycloak.KeyClient": {"type": "object","properties": {diff --git a/libs/fleet/backend/docs/swagger.json b/libs/fleet/backend/docs/swagger.jsonindex 1c62e97fb6..2a10998170 100644--- a/libs/fleet/backend/docs/swagger.json+++ b/libs/fleet/backend/docs/swagger.json@@ -244,6 +244,217 @@}}},+ "/api/chat/conversations": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "List the calling user's chat conversations",+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.ConversationSummary"+ }+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ },+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Create a chat conversation",+ "responses": {+ "201": {+ "description": "Created",+ "schema": {+ "$ref": "#/definitions/chat.Conversation"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "413": {+ "description": "Request Entity Too Large",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },+ "/api/chat/conversations/{id}": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Get a chat conversation",+ "parameters": [+ {+ "type": "string",+ "description": "Conversation ID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "$ref": "#/definitions/chat.Conversation"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },+ "/api/chat/conversations/{id}/turns": {+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/x-ndjson"+ ],+ "tags": [+ "chat"+ ],+ "summary": "Send a chat turn and stream the assistant response",+ "parameters": [+ {+ "type": "string",+ "description": "Conversation ID",+ "name": "id",+ "in": "path",+ "required": true+ },+ {+ "description": "User message or tool results",+ "name": "body",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/handlers.TurnRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "$ref": "#/definitions/handlers.turnEvent"+ }+ },+ "400": {+ "description": "Bad Request",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "401": {+ "description": "Unauthorized",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "404": {+ "description": "Not Found",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ },+ "503": {+ "description": "Service Unavailable",+ "schema": {+ "$ref": "#/definitions/handlers.ErrorResponse"+ }+ }+ }+ }+ },"/api/config": {"get": {"security": [@@ -988,6 +1199,110 @@}}},+ "chat.Conversation": {+ "type": "object",+ "properties": {+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "messages": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.Message"+ }+ },+ "title": {+ "type": "string"+ },+ "updated_at": {+ "type": "string"+ }+ }+ },+ "chat.ConversationSummary": {+ "type": "object",+ "properties": {+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "title": {+ "type": "string"+ },+ "updated_at": {+ "type": "string"+ }+ }+ },+ "chat.Message": {+ "type": "object",+ "properties": {+ "content": {+ "type": "string"+ },+ "created_at": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "role": {+ "$ref": "#/definitions/chat.Role"+ },+ "tool_call_id": {+ "type": "string"+ },+ "tool_calls": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.ToolCall"+ }+ }+ }+ },+ "chat.Role": {+ "type": "string",+ "enum": [+ "user",+ "assistant",+ "tool"+ ],+ "x-enum-varnames": [+ "RoleUser",+ "RoleAssistant",+ "RoleTool"+ ]+ },+ "chat.ToolCall": {+ "type": "object",+ "properties": {+ "function": {+ "$ref": "#/definitions/chat.ToolFunction"+ },+ "id": {+ "type": "string"+ },+ "type": {+ "type": "string"+ }+ }+ },+ "chat.ToolFunction": {+ "type": "object",+ "properties": {+ "arguments": {+ "type": "string"+ },+ "name": {+ "type": "string"+ }+ }+ },"handlers.BillingSessionResponse": {"type": "object","properties": {@@ -1005,6 +1320,9 @@},"billing": {"type": "boolean"+ },+ "chat": {+ "type": "boolean"}}},@@ -1150,6 +1468,17 @@}}},+ "handlers.TurnRequest": {+ "type": "object",+ "properties": {+ "messages": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/chat.Message"+ }+ }+ }+ },"handlers.UserKeyResponse": {"type": "object","properties": {@@ -1170,6 +1499,20 @@}}},+ "handlers.turnEvent": {+ "type": "object",+ "properties": {+ "delta": {+ "type": "string"+ },+ "message": {+ "$ref": "#/definitions/chat.Message"+ },+ "type": {+ "type": "string"+ }+ }+ },"keycloak.KeyClient": {"type": "object","properties": {diff --git a/libs/fleet/backend/docs/swagger.yaml b/libs/fleet/backend/docs/swagger.yamlindex 5b73fc72cf..b9420f6e5d 100644--- a/libs/fleet/backend/docs/swagger.yaml+++ b/libs/fleet/backend/docs/swagger.yaml@@ -23,6 +23,75 @@ definitions:- card- payment_method_presenttype: object+ chat.Conversation:+ properties:+ created_at:+ type: string+ id:+ type: string+ messages:+ items:+ $ref: '#/definitions/chat.Message'+ type: array+ title:+ type: string+ updated_at:+ type: string+ type: object+ chat.ConversationSummary:+ properties:+ created_at:+ type: string+ id:+ type: string+ title:+ type: string+ updated_at:+ type: string+ type: object+ chat.Message:+ properties:+ content:+ type: string+ created_at:+ type: string+ id:+ type: string+ role:+ $ref: '#/definitions/chat.Role'+ tool_call_id:+ type: string+ tool_calls:+ items:+ $ref: '#/definitions/chat.ToolCall'+ type: array+ type: object+ chat.Role:+ enum:+ - user+ - assistant+ - tool+ type: string+ x-enum-varnames:+ - RoleUser+ - RoleAssistant+ - RoleTool+ chat.ToolCall:+ properties:+ function:+ $ref: '#/definitions/chat.ToolFunction'+ id:+ type: string+ type:+ type: string+ type: object+ chat.ToolFunction:+ properties:+ arguments:+ type: string+ name:+ type: string+ type: objecthandlers.BillingSessionResponse:properties:url:@@ -39,6 +108,8 @@ definitions:type: booleanbilling:type: boolean+ chat:+ type: booleantype: objecthandlers.CreateKeyRequest:properties:@@ -133,6 +204,13 @@ definitions:status:type: stringtype: object+ handlers.TurnRequest:+ properties:+ messages:+ items:+ $ref: '#/definitions/chat.Message'+ type: array+ type: objecthandlers.UserKeyResponse:properties:client_id:@@ -146,6 +224,15 @@ definitions:type: stringtype: arraytype: object+ handlers.turnEvent:+ properties:+ delta:+ type: string+ message:+ $ref: '#/definitions/chat.Message'+ type:+ type: string+ type: objectkeycloak.KeyClient:properties:client_id:@@ -323,6 +410,139 @@ paths:summary: Receive Stripe webhooktags:- billing+ /api/chat/conversations:+ get:+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ items:+ $ref: '#/definitions/chat.ConversationSummary'+ type: array+ "401":+ description: Unauthorized+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "404":+ description: Not Found+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "503":+ description: Service Unavailable+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ security:+ - BearerAuth: []+ summary: List the calling user's chat conversations+ tags:+ - chat+ post:+ produces:+ - application/json+ responses:+ "201":+ description: Created+ schema:+ $ref: '#/definitions/chat.Conversation'+ "401":+ description: Unauthorized+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "404":+ description: Not Found+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "413":+ description: Request Entity Too Large+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "503":+ description: Service Unavailable+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ security:+ - BearerAuth: []+ summary: Create a chat conversation+ tags:+ - chat+ /api/chat/conversations/{id}:+ get:+ parameters:+ - description: Conversation ID+ in: path+ name: id+ required: true+ type: string+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ $ref: '#/definitions/chat.Conversation'+ "401":+ description: Unauthorized+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "404":+ description: Not Found+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "503":+ description: Service Unavailable+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ security:+ - BearerAuth: []+ summary: Get a chat conversation+ tags:+ - chat+ /api/chat/conversations/{id}/turns:+ post:+ consumes:+ - application/json+ parameters:+ - description: Conversation ID+ in: path+ name: id+ required: true+ type: string+ - description: User message or tool results+ in: body+ name: body+ required: true+ schema:+ $ref: '#/definitions/handlers.TurnRequest'+ produces:+ - application/x-ndjson+ responses:+ "200":+ description: OK+ schema:+ $ref: '#/definitions/handlers.turnEvent'+ "400":+ description: Bad Request+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "401":+ description: Unauthorized+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "404":+ description: Not Found+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ "503":+ description: Service Unavailable+ schema:+ $ref: '#/definitions/handlers.ErrorResponse'+ security:+ - BearerAuth: []+ summary: Send a chat turn and stream the assistant response+ tags:+ - chat/api/config:get:description: Returns OPA-evaluated feature flags for the authenticated SPA user.diff --git a/libs/fleet/backend/handlers/chat.go b/libs/fleet/backend/handlers/chat.gonew file mode 100644index 0000000000..ca77a4606a--- /dev/null+++ b/libs/fleet/backend/handlers/chat.go@@ -0,0 +1,446 @@+package handlers++import (+ "bytes"+ "encoding/json"+ "errors"+ "io"+ "log/slog"+ "net/http"+ "strings"+ "time"++ "cyclops-cs-backend/auth"+ "cyclops-cs-backend/chat"+)++const (+ chatTurnBodyMaxBytes = 256 << 10+ chatMessageMaxBytes = 128 << 10+ chatHistoryMaxBytes = 1 << 20+ chatHistoryMaxCount = 256+)++var errChatTurnTooLarge = errors.New("chat turn is too large")++type TurnRequest struct {+ Messages []chat.Message `json:"messages"`+}++type turnEvent struct {+ Type string `json:"type"`+ Delta string `json:"delta,omitempty"`+ Message *chat.Message `json:"message,omitempty"`+}++func (h Handlers) chatUser(w http.ResponseWriter, r *http.Request) *auth.User {+ if !h.ChatEnabled {+ writeErr(w, http.StatusNotFound, "chat is disabled")+ return nil+ }+ user := currentUser(r)+ if user == nil || user.ID == "" {+ writeErr(w, http.StatusUnauthorized, "missing user")+ return nil+ }+ if h.Conversations == nil {+ writeErr(w, http.StatusServiceUnavailable, "chat is not configured")+ return nil+ }+ return user+}++// CreateConversation godoc+//+// @Summary Create a chat conversation+// @Tags chat+// @Produce json+// @Success 201 {object} chat.Conversation+// @Failure 401 {object} ErrorResponse+// @Failure 404 {object} ErrorResponse+// @Failure 413 {object} ErrorResponse+// @Failure 503 {object} ErrorResponse+// @Security BearerAuth+// @Router /api/chat/conversations [post]+func (h Handlers) CreateConversation(w http.ResponseWriter, r *http.Request) {+ user := h.chatUser(w, r)+ if user == nil {+ return+ }+ conversation, err := h.Conversations.Create(r.Context(), user.ID)+ if errors.Is(err, chat.ErrConversationLimit) {+ writeErr(w, http.StatusTooManyRequests, "conversation limit reached")+ return+ }+ if err != nil {+ slog.ErrorContext(r.Context(), "create chat conversation", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to create conversation")+ return+ }+ writeJSON(w, http.StatusCreated, conversation)+}++// ListConversations godoc+//+// @Summary List the calling user's chat conversations+// @Tags chat+// @Produce json+// @Success 200 {array} chat.ConversationSummary+// @Failure 401 {object} ErrorResponse+// @Failure 404 {object} ErrorResponse+// @Failure 503 {object} ErrorResponse+// @Security BearerAuth+// @Router /api/chat/conversations [get]+func (h Handlers) ListConversations(w http.ResponseWriter, r *http.Request) {+ user := h.chatUser(w, r)+ if user == nil {+ return+ }+ conversations, err := h.Conversations.List(r.Context(), user.ID)+ if err != nil {+ slog.ErrorContext(r.Context(), "list chat conversations", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to list conversations")+ return+ }+ writeJSON(w, http.StatusOK, conversations)+}++// GetConversation godoc+//+// @Summary Get a chat conversation+// @Tags chat+// @Produce json+// @Param id path string true "Conversation ID"+// @Success 200 {object} chat.Conversation+// @Failure 401 {object} ErrorResponse+// @Failure 404 {object} ErrorResponse+// @Failure 503 {object} ErrorResponse+// @Security BearerAuth+// @Router /api/chat/conversations/{id} [get]+func (h Handlers) GetConversation(w http.ResponseWriter, r *http.Request) {+ user := h.chatUser(w, r)+ if user == nil {+ return+ }+ conversation, err := h.Conversations.Get(r.Context(), user.ID, chatConversationID(r))+ if errors.Is(err, chat.ErrConversationNotFound) {+ writeErr(w, http.StatusNotFound, "conversation not found")+ return+ }+ if err != nil {+ slog.ErrorContext(r.Context(), "get chat conversation", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to get conversation")+ return+ }+ writeJSON(w, http.StatusOK, conversation)+}++// CreateTurn godoc+//+// @Summary Send a chat turn and stream the assistant response+// @Tags chat+// @Accept json+// @Produce application/x-ndjson+// @Param id path string true "Conversation ID"+// @Param body body TurnRequest true "User message or tool results"+// @Success 200 {object} turnEvent+// @Failure 400 {object} ErrorResponse+// @Failure 401 {object} ErrorResponse+// @Failure 404 {object} ErrorResponse+// @Failure 503 {object} ErrorResponse+// @Security BearerAuth+// @Router /api/chat/conversations/{id}/turns [post]+func (h Handlers) CreateTurn(w http.ResponseWriter, r *http.Request) {+ user := h.chatUser(w, r)+ if user == nil {+ return+ }+ if h.Model == nil {+ writeErr(w, http.StatusServiceUnavailable, "chat is not configured")+ return+ }++ r.Body = http.MaxBytesReader(w, r.Body, chatTurnBodyMaxBytes)+ request, err := decodeTurnRequest(r.Body)+ if err != nil {+ var maxErr *http.MaxBytesError+ if errors.As(err, &maxErr) {+ writeErr(w, http.StatusRequestEntityTooLarge, "chat request body is too large")+ } else {+ writeErr(w, http.StatusBadRequest, "invalid body")+ }+ return+ }++ conversationID := chatConversationID(r)+ unlock := h.lockConversation(conversationID)+ defer unlock()+ conversation, err := h.Conversations.Get(r.Context(), user.ID, conversationID)+ if errors.Is(err, chat.ErrConversationNotFound) {+ writeErr(w, http.StatusNotFound, "conversation not found")+ return+ }+ if err != nil {+ slog.ErrorContext(r.Context(), "get chat conversation for turn", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to get conversation")+ return+ }+ request.Messages = recoverAbandonedToolCalls(conversation.Messages, request.Messages)+ if err := validateTurn(conversation.Messages, request.Messages); err != nil {+ if errors.Is(err, errChatTurnTooLarge) {+ writeErr(w, http.StatusRequestEntityTooLarge, err.Error())+ } else {+ writeErr(w, http.StatusBadRequest, err.Error())+ }+ return+ }+ if len(request.Messages) > 0 {+ if err := h.Conversations.Append(r.Context(), user.ID, conversationID, request.Messages...); err != nil {+ if errors.Is(err, chat.ErrConversationLimit) {+ writeErr(w, http.StatusRequestEntityTooLarge, "conversation storage limit reached")+ return+ }+ if errors.Is(err, chat.ErrConversationNotFound) {+ writeErr(w, http.StatusNotFound, "conversation not found")+ return+ }+ slog.ErrorContext(r.Context(), "append chat input", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to append chat input")+ return+ }+ conversation, err = h.Conversations.Get(r.Context(), user.ID, conversationID)+ if err != nil {+ slog.ErrorContext(r.Context(), "reload chat conversation", "err", err, "user", user.ID)+ writeErr(w, http.StatusInternalServerError, "failed to load conversation")+ return+ }+ }++ w.Header().Set("Content-Type", "application/x-ndjson")+ w.WriteHeader(http.StatusOK)+ flusher, _ := w.(http.Flusher)+ emit := func(event turnEvent) error {+ if err := json.NewEncoder(w).Encode(event); err != nil {+ return err+ }+ if flusher != nil {+ flusher.Flush()+ }+ return nil+ }+ message, err := h.Model.Complete(r.Context(), conversation.Messages, func(delta string) error {+ return emit(turnEvent{Type: "content_delta", Delta: delta})+ })+ if err != nil {+ slog.WarnContext(r.Context(), "complete chat turn", "err", err, "user", user.ID)+ return+ }+ message.Role = chat.RoleAssistant+ message.ID = ""+ message.CreatedAt = time.Time{}+ if err := h.Conversations.Append(r.Context(), user.ID, conversationID, message); err != nil {+ if errors.Is(err, chat.ErrConversationLimit) {+ slog.WarnContext(r.Context(), "chat response exceeded storage limit", "user", user.ID)+ return+ }+ slog.ErrorContext(r.Context(), "append chat response", "err", err, "user", user.ID)+ return+ }+ _ = emit(turnEvent{Type: "assistant", Message: &message})+}++func recoverAbandonedToolCalls(history, messages []chat.Message) []chat.Message {+ outstanding := outstandingToolCalls(history)+ if len(outstanding) == 0 || (len(messages) > 0 && messages[0].Role == chat.RoleTool) {+ return messages+ }+ if len(messages) > 1 || (len(messages) == 1 && messages[0].Role != chat.RoleUser) {+ return messages+ }++ recovered := make([]chat.Message, 0, len(outstanding)+len(messages))+ for _, call := range history[len(history)-1].ToolCalls {+ result, _ := json.Marshal(bashToolResult{+ Stdout: pointer(""),+ Stderr: pointer("tool call abandoned before completion"),+ ExitCode: pointer(1),+ TimedOut: pointer(false),+ Truncated: pointer(false),+ })+ recovered = append(recovered, chat.Message{Role: chat.RoleTool, ToolCallID: call.ID, Content: string(result)})+ }+ return append(recovered, messages...)+}++func pointer[T any](value T) *T {+ return &value+}++func chatHistorySize(messages []chat.Message) int {+ total := 0+ for _, message := range messages {+ total += len(message.Content) + len(message.ToolCallID)+ for _, call := range message.ToolCalls {+ total += len(call.ID) + len(call.Type) + len(call.Function.Name) + len(call.Function.Arguments)+ }+ }+ return total+}++func validateTurn(history, messages []chat.Message) error {+ if len(messages) > 32 || len(history)+len(messages)+1 > chatHistoryMaxCount {+ return errChatTurnTooLarge+ }+ if chatHistorySize(history)+chatHistorySize(messages) > chatHistoryMaxBytes-chatMessageMaxBytes {+ return errChatTurnTooLarge+ }+ for _, message := range messages {+ if len(message.Content) > chatMessageMaxBytes {+ return errChatTurnTooLarge+ }+ if message.ID != "" || !message.CreatedAt.IsZero() || message.Role == chat.RoleAssistant || message.Role == "" {+ return errors.New("invalid client message")+ }+ if message.Role == chat.RoleUser {+ if message.ToolCallID != "" || len(message.ToolCalls) != 0 || strings.TrimSpace(message.Content) == "" {+ return errors.New("invalid user message")+ }+ continue+ }+ if message.Role != chat.RoleTool || message.ToolCallID == "" || len(message.ToolCalls) != 0 {+ return errors.New("invalid tool message")+ }+ if err := validateBashToolResult(message.Content); err != nil {+ return errors.New("invalid tool result")+ }+ }++ if len(messages) == 0 {+ if len(history) == 0 || (history[len(history)-1].Role != chat.RoleUser && history[len(history)-1].Role != chat.RoleTool) {+ return errors.New("empty retry is not allowed")+ }+ return nil+ }++ outstanding := outstandingToolCalls(history)+ if len(outstanding) == 0 {+ if len(messages) != 1 || messages[0].Role != chat.RoleUser {+ return errors.New("expected exactly one user message")+ }+ return nil+ }+ toolMessages := messages+ if len(messages) == len(outstanding)+1 && messages[len(messages)-1].Role == chat.RoleUser {+ toolMessages = messages[:len(messages)-1]+ }+ if len(toolMessages) != len(outstanding) {+ return errors.New("tool results must match outstanding tool calls")+ }+ seen := make(map[string]struct{}, len(toolMessages))+ for _, message := range toolMessages {+ if message.Role != chat.RoleTool {+ return errors.New("tool results must match outstanding tool calls")+ }+ if _, ok := outstanding[message.ToolCallID]; !ok {+ return errors.New("tool result does not match an outstanding tool call")+ }+ if _, duplicate := seen[message.ToolCallID]; duplicate {+ return errors.New("duplicate tool result")+ }+ seen[message.ToolCallID] = struct{}{}+ }+ return nil+}++func outstandingToolCalls(history []chat.Message) map[string]struct{} {+ if len(history) == 0 || history[len(history)-1].Role != chat.RoleAssistant {+ return nil+ }+ calls := history[len(history)-1].ToolCalls+ if len(calls) == 0 {+ return nil+ }+ outstanding := make(map[string]struct{}, len(calls))+ for _, call := range calls {+ outstanding[call.ID] = struct{}{}+ }+ return outstanding+}++func chatConversationID(r *http.Request) string {+ if id := r.PathValue("id"); id != "" {+ return id+ }+ const prefix = "/api/chat/conversations/"+ path := strings.TrimPrefix(r.URL.Path, prefix)+ return strings.TrimSuffix(path, "/turns")+}++func decodeTurnRequest(body io.Reader) (TurnRequest, error) {+ var raw struct {+ Messages *json.RawMessage `json:"messages"`+ }+ decoder := json.NewDecoder(body)+ decoder.DisallowUnknownFields()+ if err := decoder.Decode(&raw); err != nil {+ return TurnRequest{}, err+ }+ if err := decoder.Decode(&struct{}{}); err != io.EOF {+ return TurnRequest{}, errors.New("multiple JSON values")+ }++ if raw.Messages == nil {+ return TurnRequest{}, errors.New("messages is required")+ }+ var rawMessages []json.RawMessage+ if err := json.Unmarshal(*raw.Messages, &rawMessages); err != nil || rawMessages == nil {+ return TurnRequest{}, errors.New("messages must be an array")+ }++ request := TurnRequest{Messages: make([]chat.Message, 0, len(rawMessages))}+ for _, rawMessage := range rawMessages {+ var fields map[string]json.RawMessage+ if err := json.Unmarshal(rawMessage, &fields); err != nil {+ return TurnRequest{}, err+ }+ if _, ok := fields["id"]; ok {+ return TurnRequest{}, errors.New("client message id is not allowed")+ }+ if _, ok := fields["created_at"]; ok {+ return TurnRequest{}, errors.New("client message timestamp is not allowed")+ }++ var message chat.Message+ messageDecoder := json.NewDecoder(bytes.NewReader(rawMessage))+ messageDecoder.DisallowUnknownFields()+ if err := messageDecoder.Decode(&message); err != nil {+ return TurnRequest{}, err+ }+ request.Messages = append(request.Messages, message)+ }+ return request, nil+}++type bashToolResult struct {+ Stdout *string `json:"stdout"`+ Stderr *string `json:"stderr"`+ ExitCode *int `json:"exit_code"`+ TimedOut *bool `json:"timed_out"`+ Truncated *bool `json:"truncated"`+}++func validateBashToolResult(content string) error {+ var result bashToolResult+ decoder := json.NewDecoder(strings.NewReader(content))+ decoder.DisallowUnknownFields()+ if err := decoder.Decode(&result); err != nil {+ return err+ }+ if err := decoder.Decode(&struct{}{}); err != io.EOF {+ return errors.New("trailing JSON")+ }+ if result.Stdout == nil || result.Stderr == nil || result.ExitCode == nil || result.TimedOut == nil || result.Truncated == nil {+ return errors.New("missing BashToolResult field")+ }+ return nil+}diff --git a/libs/fleet/backend/handlers/chat_locks.go b/libs/fleet/backend/handlers/chat_locks.gonew file mode 100644index 0000000000..b36cab300a--- /dev/null+++ b/libs/fleet/backend/handlers/chat_locks.go@@ -0,0 +1,48 @@+package handlers++import "sync"++type conversationLock struct {+ mu sync.Mutex+ refs int+}++type conversationLockRegistry struct {+ mu sync.Mutex+ locks map[string]*conversationLock+}++func newConversationLockRegistry() *conversationLockRegistry {+ return &conversationLockRegistry{locks: make(map[string]*conversationLock)}+}++func (registry *conversationLockRegistry) lock(conversationID string) func() {+ registry.mu.Lock()+ entry := registry.locks[conversationID]+ if entry == nil {+ entry = &conversationLock{}+ registry.locks[conversationID] = entry+ }+ entry.refs+++ registry.mu.Unlock()++ entry.mu.Lock()+ return func() {+ entry.mu.Unlock()+ registry.mu.Lock()+ entry.refs--+ if entry.refs == 0 && registry.locks[conversationID] == entry {+ delete(registry.locks, conversationID)+ }+ registry.mu.Unlock()+ }+}++var fallbackConversationLocks = newConversationLockRegistry()++func (h Handlers) lockConversation(conversationID string) func() {+ if h.chatLocks == nil {+ return fallbackConversationLocks.lock(conversationID)+ }+ return h.chatLocks.lock(conversationID)+}diff --git a/libs/fleet/backend/handlers/chat_test.go b/libs/fleet/backend/handlers/chat_test.gonew file mode 100644index 0000000000..8fb0a58134--- /dev/null+++ b/libs/fleet/backend/handlers/chat_test.go@@ -0,0 +1,520 @@+package handlers++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync"+ "testing"+ "time"++ "cyclops-cs-backend/auth"+ "cyclops-cs-backend/chat"+)++type fakeModel struct {+ responses []chat.Message+ histories [][]chat.Message+}++var alice = &auth.User{ID: "user-alice", AZP: "cyclops-cs-spa"}++func newReq(method, target, body string, user *auth.User) *http.Request {+ request := httptest.NewRequest(method, target, strings.NewReader(body))+ parts := strings.Split(strings.Trim(target, "/"), "/")+ if len(parts) >= 4 && parts[0] == "api" && parts[1] == "chat" && parts[2] == "conversations" {+ request.SetPathValue("id", parts[3])+ }+ if user != nil {+ request = withUser(request, user)+ }+ return request+}++func (f *fakeModel) Complete(_ context.Context, messages []chat.Message, onDelta func(string) error) (chat.Message, error) {+ f.histories = append(f.histories, append([]chat.Message(nil), messages...))+ response := f.responses[0]+ f.responses = f.responses[1:]+ if response.Content != "" {+ _ = onDelta(response.Content)+ }+ return response, nil+}++func newChatHandlers(responses ...chat.Message) (Handlers, *chat.MemoryConversationStore, *fakeModel) {+ store := chat.NewMemoryConversationStore()+ model := &fakeModel{responses: responses}+ return Handlers{ChatEnabled: true, Conversations: store, Model: model, chatLocks: newConversationLockRegistry()}, store, model+}++func createChatConversation(t *testing.T, h Handlers, user *auth.User) *chat.Conversation {+ t.Helper()+ w := httptest.NewRecorder()+ h.CreateConversation(w, newReq(http.MethodPost, "/api/chat/conversations", "", user))+ if w.Code != http.StatusCreated {+ t.Fatalf("create status = %d, want 201; body = %s", w.Code, w.Body.String())+ }+ var conversation chat.Conversation+ if err := json.Unmarshal(w.Body.Bytes(), &conversation); err != nil {+ t.Fatalf("decode conversation: %v", err)+ }+ return &conversation+}++func TestChatConversationsCreateListGetOwnership(t *testing.T) {+ h, _, _ := newChatHandlers()+ conversation := createChatConversation(t, h, alice)+ w := httptest.NewRecorder()+ h.ListConversations(w, newReq(http.MethodGet, "/api/chat/conversations", "", alice))+ if w.Code != http.StatusOK {+ t.Fatalf("list status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ var summaries []chat.ConversationSummary+ if err := json.Unmarshal(w.Body.Bytes(), &summaries); err != nil {+ t.Fatalf("decode summaries: %v", err)+ }+ if len(summaries) != 1 || summaries[0].ID != conversation.ID {+ t.Fatalf("summaries = %#v", summaries)+ }+ w = httptest.NewRecorder()+ h.GetConversation(w, newReq(http.MethodGet, "/api/chat/conversations/"+conversation.ID, "", alice))+ if w.Code != http.StatusOK {+ t.Fatalf("get status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ w = httptest.NewRecorder()+ h.GetConversation(w, newReq(http.MethodGet, "/api/chat/conversations/"+conversation.ID, "", &auth.User{ID: "user-bob"}))+ if w.Code != http.StatusNotFound {+ t.Fatalf("cross-owner get status = %d, want 404; body = %s", w.Code, w.Body.String())+ }+ w = httptest.NewRecorder()+ h.GetConversation(w, newReq(http.MethodGet, "/api/chat/conversations/missing", "", alice))+ if w.Code != http.StatusNotFound {+ t.Fatalf("missing get status = %d, want 404; body = %s", w.Code, w.Body.String())+ }+}++func TestChatRequiresEnabledFeatureAndUser(t *testing.T) {+ w := httptest.NewRecorder()+ Handlers{}.ListConversations(w, newReq(http.MethodGet, "/api/chat/conversations", "", alice))+ if w.Code != http.StatusNotFound {+ t.Fatalf("disabled status = %d, want 404", w.Code)+ }+ h, _, _ := newChatHandlers()+ for _, user := range []*auth.User{nil, &auth.User{}} {+ w = httptest.NewRecorder()+ h.ListConversations(w, newReq(http.MethodGet, "/api/chat/conversations", "", user))+ if w.Code != http.StatusUnauthorized {+ t.Fatalf("user %#v status = %d, want 401", user, w.Code)+ }+ }+}++func TestChatTurnRejectsInvalidClientMessages(t *testing.T) {+ cases := map[string]string{+ "assistant": `{"messages":[{"role":"assistant","content":"no"}]}`,+ "client id": `{"messages":[{"id":"client-id","role":"user","content":"hello"}]}`,+ "client timestamp": `{"messages":[{"role":"user","content":"hello","created_at":"2026-01-01T00:00:00Z"}]}`,+ "user tool call": `{"messages":[{"role":"user","content":"hello","tool_calls":[{"id":"call-1"}]}]}`,+ "empty client id": `{"messages":[{"id":"","role":"user","content":"hello"}]}`,+ "tool missing call id": `{"messages":[{"role":"tool","content":"output"}]}`,+ "zero client timestamp": `{"messages":[{"role":"user","content":"hello","created_at":"0001-01-01T00:00:00Z"}]}`,+ "tool has tool calls": `{"messages":[{"role":"tool","tool_call_id":"call-1","tool_calls":[{"id":"call-1"}]}]}`,+ "multiple user messages": `{"messages":[{"role":"user","content":"one"},{"role":"user","content":"two"}]}`,+ }+ for name, body := range cases {+ t.Run(name, func(t *testing.T) {+ h, _, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+ })+ }+}++func TestChatTurnStreamsAndPersistsMessages(t *testing.T) {+ h, store, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "hello"})+ conversation := createChatConversation(t, h, alice)+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"hi"}]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if got, want := w.Header().Get("Content-Type"), "application/x-ndjson"; got != want {+ t.Fatalf("Content-Type = %q, want %q", got, want)+ }+ if got, want := w.Body.String(), "{\"type\":\"content_delta\",\"delta\":\"hello\"}\n{\"type\":\"assistant\",\"message\":{\"role\":\"assistant\",\"content\":\"hello\"}}\n"; got != want {+ t.Fatalf("stream = %q, want %q", got, want)+ }+ stored, err := store.Get(context.Background(), alice.ID, conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if len(stored.Messages) != 2 || stored.Messages[0].Role != chat.RoleUser || stored.Messages[0].Content != "hi" || stored.Messages[1].Role != chat.RoleAssistant || stored.Messages[1].Content != "hello" {+ t.Fatalf("stored messages = %#v", stored.Messages)+ }+}++func TestChatTurnAbandonsOutstandingToolCallsBeforeUserMessage(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "continued"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleAssistant, ToolCalls: []chat.ToolCall{{ID: "call-1", Type: "function", Function: chat.ToolFunction{Name: "run_bash", Arguments: `{"command":"pwd"}`}}}}); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"skip tools"}]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 1 || len(model.histories[0]) != 3 || model.histories[0][1].Role != chat.RoleTool || model.histories[0][2].Content != "skip tools" {+ t.Fatalf("model history = %#v", model.histories)+ }+}++func TestChatTurnRequiresExactToolResultsAndSendsCompleteHistory(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "complete"})+ conversation := createChatConversation(t, h, alice)+ toolCalls := []chat.ToolCall{{ID: "call-1", Type: "function", Function: chat.ToolFunction{Name: "run_bash", Arguments: `{"command":"pwd"}`}}, {ID: "call-2", Type: "function", Function: chat.ToolFunction{Name: "run_bash", Arguments: `{"command":"ls"}`}}}+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleAssistant, ToolCalls: toolCalls}); err != nil {+ t.Fatal(err)+ }+ for name, body := range map[string]string{+ "missing": `{"messages":[{"role":"tool","tool_call_id":"call-1","content":"/tmp"}]}`,+ "duplicate": `{"messages":[{"role":"tool","tool_call_id":"call-1","content":"/tmp"},{"role":"tool","tool_call_id":"call-1","content":"/tmp"}]}`,+ "extra": `{"messages":[{"role":"tool","tool_call_id":"call-1","content":"/tmp"},{"role":"tool","tool_call_id":"extra","content":"no"}]}`,+ "mixed user": `{"messages":[{"role":"tool","tool_call_id":"call-1","content":"/tmp"},{"role":"user","content":"no"}]}`,+ } {+ t.Run(name, func(t *testing.T) {+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+ })+ }+ w := httptest.NewRecorder()+ body := fmt.Sprintf(`{"messages":[{"role":"tool","tool_call_id":"call-1","content":%q},{"role":"tool","tool_call_id":"call-2","content":%q}]}`, validBashToolResult, validBashToolResult)+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 1 || len(model.histories[0]) != 3 {+ t.Fatalf("model histories = %#v", model.histories)+ }+ if got := model.histories[0][1:]; got[0].ToolCallID != "call-1" || got[1].ToolCallID != "call-2" {+ t.Fatalf("model tool history = %#v", got)+ }+}++func TestChatTurnAllowsEmptyRetryOnlyAfterUserOrTool(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "retry user"}, chat.Message{Role: chat.RoleAssistant, Content: "retry tool"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleUser, Content: "retry"}); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("user retry status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ conversation = createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleTool, ToolCallID: "call-1", Content: "retry"}); err != nil {+ t.Fatal(err)+ }+ w = httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("tool retry status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ conversation = createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleAssistant, Content: "already answered"}); err != nil {+ t.Fatal(err)+ }+ w = httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[]}`, alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("assistant retry status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 2 {+ t.Fatalf("model calls = %d, want 2", len(model.histories))+ }+}++func TestChatTurnRejectsMalformedJSON(t *testing.T) {+ h, _, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", strings.Repeat("{", 1), alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+}++func TestChatTurnRequiresMessagesArray(t *testing.T) {+ for name, body := range map[string]string{+ "missing": `{}`,+ "null": `{"messages":null}`,+ } {+ t.Run(name, func(t *testing.T) {+ h, store, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleUser, Content: "retry"}); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+ })+ }+}++const validBashToolResult = `{"stdout":"/tmp\n","stderr":"","exit_code":0,"timed_out":false,"truncated":false}`++func toolResultTurnBody(toolCallID, content string) string {+ return fmt.Sprintf(`{"messages":[{"role":"tool","tool_call_id":%q,"content":%q}]}`, toolCallID, content)+}++func TestChatTurnRejectsMalformedBashToolResults(t *testing.T) {+ cases := map[string]string{+ "non-JSON": "output",+ "missing field": `{"stdout":"","stderr":"","exit_code":0,"timed_out":false}`,+ "wrong string": `{"stdout":1,"stderr":"","exit_code":0,"timed_out":false,"truncated":false}`,+ "wrong integer": `{"stdout":"","stderr":"","exit_code":"0","timed_out":false,"truncated":false}`,+ "wrong boolean": `{"stdout":"","stderr":"","exit_code":0,"timed_out":"false","truncated":false}`,+ "unknown field": `{"stdout":"","stderr":"","exit_code":0,"timed_out":false,"truncated":false,"extra":true}`,+ "trailing JSON": validBashToolResult + ` {}`,+ }+ for name, content := range cases {+ t.Run(name, func(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleAssistant, ToolCalls: []chat.ToolCall{{ID: "call-1"}}}); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", toolResultTurnBody("call-1", content), alice))+ if w.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want 400; body = %s", w.Code, w.Body.String())+ }+ stored, err := store.Get(context.Background(), alice.ID, conversation.ID)+ if err != nil {+ t.Fatal(err)+ }+ if len(stored.Messages) != 1 || len(model.histories) != 0 {+ t.Fatalf("malformed tool result persisted or reached model: messages=%#v histories=%#v", stored.Messages, model.histories)+ }+ })+ }+}++func TestChatTurnAcceptsValidBashToolResult(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "complete"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{Role: chat.RoleAssistant, ToolCalls: []chat.ToolCall{{ID: "call-1"}}}); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", toolResultTurnBody("call-1", validBashToolResult), alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 1 || len(model.histories[0]) != 2 {+ t.Fatalf("model histories = %#v", model.histories)+ }+}++type blockingSequentialModel struct {+ mu sync.Mutex+ histories [][]chat.Message+ calls int+ firstStarted chan struct{}+ secondStarted chan struct{}+ releaseFirst chan struct{}+}++func (m *blockingSequentialModel) Complete(_ context.Context, messages []chat.Message, _ func(string) error) (chat.Message, error) {+ m.mu.Lock()+ m.calls+++ call := m.calls+ m.histories = append(m.histories, append([]chat.Message(nil), messages...))+ m.mu.Unlock()++ if call == 1 {+ close(m.firstStarted)+ <-m.releaseFirst+ } else if call == 2 {+ close(m.secondStarted)+ }+ return chat.Message{Role: chat.RoleAssistant, Content: fmt.Sprintf("assistant-%d", call)}, nil+}++func TestChatTurnSerializesConcurrentTurnsPerConversation(t *testing.T) {+ store := chat.NewMemoryConversationStore()+ model := &blockingSequentialModel{+ firstStarted: make(chan struct{}),+ secondStarted: make(chan struct{}),+ releaseFirst: make(chan struct{}),+ }+ h := Handlers{ChatEnabled: true, Conversations: store, Model: model}+ conversation := createChatConversation(t, h, alice)++ statuses := make(chan int, 2)+ go func() {+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"first"}]}`, alice))+ statuses <- w.Code+ }()+ <-model.firstStarted+ go func() {+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"second"}]}`, alice))+ statuses <- w.Code+ }()++ select {+ case <-model.secondStarted:+ close(model.releaseFirst)+ <-statuses+ <-statuses+ t.Fatal("second turn reached the model before the first turn completed")+ case <-time.After(100 * time.Millisecond):+ }+ close(model.releaseFirst)+ if first, second := <-statuses, <-statuses; first != http.StatusOK || second != http.StatusOK {+ t.Fatalf("statuses = %d, %d; want 200, 200", first, second)+ }++ model.mu.Lock()+ histories := append([][]chat.Message(nil), model.histories...)+ model.mu.Unlock()+ if len(histories) != 2 || len(histories[1]) != 3 {+ t.Fatalf("histories = %#v", histories)+ }+ if histories[1][0].Content != "first" || histories[1][1].Role != chat.RoleAssistant || histories[1][1].Content != "assistant-1" || histories[1][2].Content != "second" {+ t.Fatalf("second model history = %#v", histories[1])+ }+}++func TestChatTurnRecoversAbandonedToolCallsBeforeNewPrompt(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "recovered"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{+ Role: chat.RoleAssistant,+ ToolCalls: []chat.ToolCall{{ID: "call-1", Type: "function", Function: chat.ToolFunction{Name: "bash", Arguments: `{"command":"sleep 60"}`}}},+ }); err != nil {+ t.Fatal(err)+ }++ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"continue without it"}]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 1 || len(model.histories[0]) != 3 {+ t.Fatalf("model history = %#v", model.histories)+ }+ if model.histories[0][1].Role != chat.RoleTool || model.histories[0][1].ToolCallID != "call-1" || !strings.Contains(model.histories[0][1].Content, "abandoned") {+ t.Fatalf("synthetic tool result = %#v", model.histories[0][1])+ }+ if model.histories[0][2].Role != chat.RoleUser || model.histories[0][2].Content != "continue without it" {+ t.Fatalf("new prompt = %#v", model.histories[0][2])+ }+}++func TestChatTurnRetriesAbandonedToolCalls(t *testing.T) {+ h, store, model := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "recovered"})+ conversation := createChatConversation(t, h, alice)+ if err := store.Append(context.Background(), alice.ID, conversation.ID, chat.Message{+ Role: chat.RoleAssistant,+ ToolCalls: []chat.ToolCall{{ID: "call-1", Type: "function", Function: chat.ToolFunction{Name: "bash", Arguments: `{"command":"bad"}`}}},+ }); err != nil {+ t.Fatal(err)+ }++ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[]}`, alice))+ if w.Code != http.StatusOK {+ t.Fatalf("status = %d, want 200; body = %s", w.Code, w.Body.String())+ }+ if len(model.histories) != 1 || len(model.histories[0]) != 2 || model.histories[0][1].Role != chat.RoleTool {+ t.Fatalf("model history = %#v", model.histories)+ }+}++func TestChatTurnRejectsOversizedBodyAndMessages(t *testing.T) {+ t.Run("body", func(t *testing.T) {+ h, _, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ body := `{"messages":[{"role":"user","content":"` + strings.Repeat("x", 300<<10) + `"}]}`+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusRequestEntityTooLarge {+ t.Fatalf("status = %d, want 413; body = %s", w.Code, w.Body.String())+ }+ })++ t.Run("message", func(t *testing.T) {+ h, _, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ body := `{"messages":[{"role":"user","content":"` + strings.Repeat("x", 140<<10) + `"}]}`+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", body, alice))+ if w.Code != http.StatusRequestEntityTooLarge {+ t.Fatalf("status = %d, want 413; body = %s", w.Code, w.Body.String())+ }+ })+}++func TestChatTurnRejectsConversationBeyondHistoryLimit(t *testing.T) {+ h, store, _ := newChatHandlers(chat.Message{Role: chat.RoleAssistant, Content: "unused"})+ conversation := createChatConversation(t, h, alice)+ messages := make([]chat.Message, 256)+ for index := range messages {+ messages[index] = chat.Message{Role: chat.RoleUser, Content: "message"}+ }+ if err := store.Append(context.Background(), alice.ID, conversation.ID, messages...); err != nil {+ t.Fatal(err)+ }+ w := httptest.NewRecorder()+ h.CreateTurn(w, newReq(http.MethodPost, "/api/chat/conversations/"+conversation.ID+"/turns", `{"messages":[{"role":"user","content":"one more"}]}`, alice))+ if w.Code != http.StatusRequestEntityTooLarge {+ t.Fatalf("status = %d, want 413; body = %s", w.Code, w.Body.String())+ }+}++func TestConversationLockRegistryEvictsReleasedLocks(t *testing.T) {+ registry := newConversationLockRegistry()+ for index := 0; index < 100; index++ {+ unlock := registry.lock(fmt.Sprintf("missing-%d", index))+ unlock()+ }+ registry.mu.Lock()+ defer registry.mu.Unlock()+ if len(registry.locks) != 0 {+ t.Fatalf("retained locks = %d, want 0", len(registry.locks))+ }+}++func TestCreateConversationReportsStoreLimit(t *testing.T) {+ store := chat.NewMemoryConversationStore()+ h := Handlers{ChatEnabled: true, Conversations: store, Model: &fakeModel{}}+ for index := 0; index < 100; index++ {+ w := httptest.NewRecorder()+ h.CreateConversation(w, newReq(http.MethodPost, "/api/chat/conversations", "", alice))+ if w.Code != http.StatusCreated {+ t.Fatalf("create %d status = %d; body = %s", index, w.Code, w.Body.String())+ }+ }+ w := httptest.NewRecorder()+ h.CreateConversation(w, newReq(http.MethodPost, "/api/chat/conversations", "", alice))+ if w.Code != http.StatusTooManyRequests {+ t.Fatalf("status = %d, want 429; body = %s", w.Code, w.Body.String())+ }+}diff --git a/libs/fleet/backend/handlers/config.go b/libs/fleet/backend/handlers/config.goindex a84212672c..2b8234234f 100644--- a/libs/fleet/backend/handlers/config.go+++ b/libs/fleet/backend/handlers/config.go@@ -16,6 +16,7 @@ type ConfigResponse struct {// server-side by authz.rego.Admin bool `json:"admin"`Billing bool `json:"billing"`+ Chat bool `json:"chat"`}// GetConfig returns per-user feature flags evaluated by OPA.@@ -46,5 +47,5 @@ func (h Handlers) GetConfig(w http.ResponseWriter, r *http.Request) {billingEnabled = false}- writeJSON(w, http.StatusOK, ConfigResponse{Admin: isAdmin, Billing: billingEnabled})+ writeJSON(w, http.StatusOK, ConfigResponse{Admin: isAdmin, Billing: billingEnabled, Chat: h.ChatEnabled})}diff --git a/libs/fleet/backend/handlers/handlers.go b/libs/fleet/backend/handlers/handlers.goindex 5608884fd6..eecb06abc3 100644--- a/libs/fleet/backend/handlers/handlers.go+++ b/libs/fleet/backend/handlers/handlers.go@@ -11,6 +11,7 @@ import ("regexp""cyclops-cs-backend/auth"+ "cyclops-cs-backend/chat""cyclops-cs-backend/config""cyclops-cs-backend/githubtrust""cyclops-cs-backend/keycloak"@@ -33,6 +34,11 @@ type Handlers struct {Readiness *Readiness+ ChatEnabled bool+ Conversations chat.ConversationStore+ Model chat.ModelClient+ chatLocks *conversationLockRegistry+// WorkloadAdmin manages per-tenant clients in the workloads realm so// OSGym pool VMs can obtain a tenant-scoped OIDC token. nil disables// the feature (CreateNamespace then skips OIDC credential provisioning).@@ -50,6 +56,8 @@ func New(admin *keycloak.Admin, cfg *config.Configuration) Handlers {AuthCfg: cfg.Auth,KC: cfg.Keycloak,Stripe: cfg.Stripe,+ ChatEnabled: cfg.Chat.Enabled,+ chatLocks: newConversationLockRegistry(),}}diff --git a/libs/fleet/backend/main.go b/libs/fleet/backend/main.goindex d202fa0447..aa37ea7cee 100644--- a/libs/fleet/backend/main.go+++ b/libs/fleet/backend/main.go@@ -30,6 +30,7 @@ import ("cyclops-cs-backend/auth""cyclops-cs-backend/billing"+ "cyclops-cs-backend/chat""cyclops-cs-backend/config""cyclops-cs-backend/database"_ "cyclops-cs-backend/docs" // generated by `swag init`@@ -131,6 +132,15 @@ func setupRouter(c handlers.Handlers) http.Handler {r.Handle("GET /api/config",withAuthenticatedMiddlewares("/api/config", c.GetConfig))+ r.Handle("POST /api/chat/conversations",+ withAuthenticatedMiddlewares("/api/chat/conversations", c.CreateConversation))+ r.Handle("GET /api/chat/conversations",+ withAuthenticatedMiddlewares("/api/chat/conversations", c.ListConversations))+ r.Handle("GET /api/chat/conversations/{id}",+ withAuthenticatedMiddlewares("/api/chat/conversations/{id}", c.GetConversation))+ r.Handle("POST /api/chat/conversations/{id}/turns",+ withAuthenticatedMiddlewares("/api/chat/conversations/{id}/turns", c.CreateTurn))+r.Handle("QUERY /api/state/query",withAuthenticatedMiddlewares("/api/state/query", c.QueryState))@@ -361,6 +371,12 @@ func run() error {slog.Info("github trust policies: disabled (database schema unavailable)")}+ if cfg.Chat.Enabled {+ h.Conversations = chat.NewMemoryConversationStore()+ h.Model = chat.NewLiteLLMClient(cfg.Chat.BaseURL, cfg.Chat.APIKey, cfg.Chat.Model)+ slog.Info("chat: enabled", "base_url", cfg.Chat.BaseURL, "model", cfg.Chat.Model)+ }+router := setupRouter(h)srv := &http.Server{Addr: cfg.WebServer.Addr, Handler: router}diff --git a/libs/fleet/backend/main_test.go b/libs/fleet/backend/main_test.goindex 637ed7da81..3cfd7f3a46 100644--- a/libs/fleet/backend/main_test.go+++ b/libs/fleet/backend/main_test.go@@ -427,3 +427,34 @@ func TestK8sRouteRejectsDisallowedPoolBeforeProxy(t *testing.T) {t.Fatal("disallowed pool request reached kubectl proxy")}}++func TestSwaggerIncludesChatRoutes(t *testing.T) {+ data, err := os.ReadFile("docs/swagger.json")+ if err != nil {+ t.Fatal(err)+ }+ var spec struct {+ Paths map[string]map[string]struct{} `json:"paths"`+ }+ if err := json.Unmarshal(data, &spec); err != nil {+ t.Fatalf("unmarshal swagger.json: %v", err)+ }+ for _, tc := range []struct{ path, method string }{+ {"/api/chat/conversations", "post"}, {"/api/chat/conversations", "get"},+ {"/api/chat/conversations/{id}", "get"}, {"/api/chat/conversations/{id}/turns", "post"},+ } {+ if _, ok := spec.Paths[tc.path][tc.method]; !ok {+ t.Fatalf("swagger.json missing %s %s", strings.ToUpper(tc.method), tc.path)+ }+ }+}++func TestNginxRoutesChatToBackend(t *testing.T) {+ data, err := os.ReadFile("../nginx.conf")+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(string(data), "|chat|") && !strings.Contains(string(data), "|chat)") {+ t.Fatal("nginx.conf backend matcher does not include chat")+ }+}diff --git a/libs/fleet/docs/browser-agent.md b/libs/fleet/docs/browser-agent.mdnew file mode 100644index 0000000000..e106b57980--- /dev/null+++ b/libs/fleet/docs/browser-agent.md@@ -0,0 +1,153 @@+# Browser bash chat++Cyclops includes an authenticated chat UI whose agent loop runs inside the+browser. The model may request a single `bash` function tool implemented with+`just-bash/browser`; the browser executes it in a temporary virtual filesystem+and returns the result to the backend for the next model turn.++The Go backend owns conversation history, authentication, authorization, and+LiteLLM access. The current conversation store is in memory, so history is lost+when the backend process restarts. The store interface is intended to support a+PostgreSQL implementation later.++## Security boundary++The bash runtime is browser-local and isolated:++- It cannot access the host filesystem.+- It cannot make network requests.+- Its virtual filesystem is temporary and exists only in browser memory.+- Each conversation receives a separate shell and virtual filesystem.+- Refreshing or closing the page discards the browser-local filesystem, while+ persisted transcript history remains available until the backend restarts.+- Tool-provided `timeout_ms` and `max_output_chars` values are clamped by the+ browser runtime before execution.+- Requests are capped at 256 KiB, individual messages at 128 KiB, retained+ conversations at 256 messages and 1 MiB of model context, and streamed model+ output at 128 KiB. The in-memory backend also caps each owner at 100+ conversations and the process-wide transcript store at 64 MiB.++There is no MCP integration, Playwright tool, browser automation, Chromium+process, or Node sidecar. The frontend does not receive LiteLLM credentials.++## Local development++Install dependencies and run the frontend:++```bash+cd cyclops-cs+corepack pnpm install+corepack pnpm dev+```++Run the Go backend with chat enabled in a separate terminal:++```bash+cd cyclops-cs/backend+CYCLOPS_CS_CHAT_ENABLED=true \+LITELLM_BASE_URL=http://localhost:4000/v1 \+LITELLM_MODEL=large \+LITELLM_API_KEY='<virtual-key>' \+go run .+```++Use an OpenAI-compatible LiteLLM endpoint and a restricted virtual key. Never+put `LITELLM_API_KEY` in Vite variables, frontend configuration, or browser+storage.++## Backend configuration++- `CYCLOPS_CS_CHAT_ENABLED` enables the Chat navigation item and API handlers.+- `LITELLM_BASE_URL` is the OpenAI-compatible API base URL, including `/v1`.+- `LITELLM_MODEL` selects the model alias and defaults to `large`.+- `LITELLM_API_KEY` is the backend-only LiteLLM virtual key.++When chat is enabled, both `LITELLM_BASE_URL` and `LITELLM_API_KEY` are+required.++## API routes++All routes require the existing Cyclops authentication and authorization+middleware:++- `POST /api/chat/conversations` creates a conversation.+- `GET /api/chat/conversations` lists the calling user's conversations.+- `GET /api/chat/conversations/{id}` loads one owned conversation.+- `POST /api/chat/conversations/{id}/turns` appends user or tool messages and+ streams the assistant response as server-sent events.++The backend stores user, assistant, tool-call, and tool-result messages. The+React UI keeps only transient rendering and run state; it reloads canonical+conversation history from the backend. If a browser run is stopped or rejects a+tool call after the assistant request is stored, the next retry or user prompt+records synthetic failed tool results before continuing, so the conversation is+not stranded.++## Preview environments++Chat is enabled only in the preview base at+`clusters/kopf-k3s/cyclops-cs-previews-base`. Each preview has a Flux+`GitRepository` pinned to the PR head SHA, so manifest and secret-wiring changes+are rendered from the same commit as the frontend/backend images. The backend+sidecar receives the four LiteLLM environment variables. The nginx/frontend+container receives none of them.++The `cyclops-cs` pull-request label is the trust gate for this backend secret.+Maintainers must apply it only to reviewed, same-repository PRs whose backend+code is trusted to receive the preview credential. Fork PRs are blocked from+publishing Cyclops images, and a base-branch `pull_request_target` workflow+automatically removes the label if it is applied to a fork PR. Remove the label+and revoke the credential if any enabled preview becomes untrusted.++An `ExternalSecret` named `cyclops-cs-litellm` reads property `api_key` from+AWS Secrets Manager path `kopf-k3s/cyclops-cs-browser-agent-litellm` and creates+a namespace-local Secret with the same name. Production manifests are not+changed by this preview configuration.++The stored value must be a dedicated LiteLLM virtual key restricted to model+alias `large`. Configure a strict spend budget and an expiry, or use a documented+short rotation interval if expiry is unavailable. Rotate the key on schedule+and revoke it immediately if an enabled preview is no longer trusted. Never use+a general-purpose or unrestricted gateway key for previews.++## Validation++Before adding preview wiring, the source-tree assertion was:++```bash+rg -n "CYCLOPS_CS_CHAT_ENABLED|LITELLM_BASE_URL|LITELLM_API_KEY|litellm-credentials.yaml" \+ clusters/kopf-k3s/cyclops-cs-previews-base+```++Expected baseline before wiring: no matches and exit status 1, proving the+preview chat configuration was not already present.++Validate the browser agent and UI:++```bash+cd cyclops-cs+corepack pnpm test:agent+corepack pnpm test:e2e -- agent-chat.spec.ts+corepack pnpm typecheck+corepack pnpm build+```++Verify the preview trust contract:++```bash+clusters/kopf-k3s/cyclops-cs-previews/tests/security-contract.sh+```++Render and inspect the preview manifests:++```bash+kubectl kustomize clusters/kopf-k3s/cyclops-cs-previews-base \+ > /tmp/cyclops-chat-preview.yaml+rg -n \+ "kind: ExternalSecret|CYCLOPS_CS_CHAT_ENABLED|LITELLM_BASE_URL|LITELLM_MODEL|LITELLM_API_KEY" \+ /tmp/cyclops-chat-preview.yaml+```++Confirm the rendered environment variables appear only on+`cyclops-cs-backend`, the ExternalSecret references the expected AWS path and+property, and no secret value is present in the output.diff --git a/libs/fleet/e2e/agent-chat.spec.ts b/libs/fleet/e2e/agent-chat.spec.tsnew file mode 100644index 0000000000..338ce54c0d--- /dev/null+++ b/libs/fleet/e2e/agent-chat.spec.ts@@ -0,0 +1,636 @@+import { expect, test } from "@playwright/test"++import { mockAuth, mockChatApi } from "./fixtures/mock-api"++test("shows chat history, transcript region, prompt shell, and authenticated history time", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page)++ await page.goto("/agent")++ await expect(page.getByRole("heading", { name: "Conversations" })).toBeVisible()+ await expect(page.getByText("Today")).toBeVisible()+ await expect(page.getByRole("region", { name: "Chat" })).toBeVisible()+ await expect(page.getByPlaceholder("Ask a question")).toBeVisible()+ await expect(page.locator(".agent-chat-history [title]").first()).toHaveAttribute(+ "title",+ /.+/,+ )+ expect(chat.authorizationHeaders.length).toBeGreaterThan(0)+ expect(chat.authorizationHeaders).toEqual(+ expect.arrayContaining([expect.stringMatching(/^Bearer /)]),+ )+})++test("keeps the prompt visible while conversation history loads", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, { holdList: true })++ await page.goto("/agent")++ await expect(page.getByTestId("conversation-skeleton")).toHaveCount(3)+ await expect(page.getByPlaceholder("Ask a question")).toBeVisible()+ chat.releaseList()+})++test("loads a selected conversation with message skeletons and accessible author times", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, { holdConversation: true })++ await page.goto("/agent")+ await page.getByRole("button", { name: "Example browser task" }).click()++ await expect(page.getByTestId("message-skeleton")).toHaveCount(2)+ await expect(page.getByPlaceholder("Ask a question")).toBeVisible()+ chat.releaseConversation()++ await expect(page.getByText("Open the example site.")).toBeVisible()+ await expect(page.getByText("The example site is ready.")).toBeVisible()+ await expect(page.getByLabel(/^You at /)).toBeVisible()+ await expect(page.getByLabel(/^Assistant at /)).toBeVisible()+})++test("does not redirect while chat feature configuration is pending", async ({ page }) => {+ const auth = await mockAuth(page, { admin: false, chat: true }, { holdConfig: true })+ await mockChatApi(page)++ await page.goto("/agent")+ await expect(page).toHaveURL(/\/agent$/)+ await expect(page.getByRole("heading", { name: "Conversations" })).toHaveCount(0)++ auth.releaseConfig()+ await expect(page.getByRole("heading", { name: "Conversations" })).toBeVisible()+})++test("manages mobile history modal focus, keyboard, inert background, and close restoration", async ({ page }) => {+ await page.setViewportSize({ width: 390, height: 844 })+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page)++ await page.goto("/agent")++ const trigger = page.getByRole("button", { name: "View conversations" })+ await expect(trigger).toBeVisible()+ await expect(page.getByRole("dialog", { name: "Conversations" })).toHaveCount(0)++ await trigger.focus()+ await trigger.press("Enter")+ const dialog = page.getByRole("dialog", { name: "Conversations" })+ const closeButton = dialog.getByRole("button", { name: "Close conversations" })+ await expect(dialog).toBeVisible()+ await expect(closeButton).toBeFocused()+ await expect(dialog.getByRole("heading", { name: "Conversations", exact: true })).toHaveCount(1)+ await expect(page.locator("#root")).toHaveAttribute("inert", "")+ const poolsNavigation = page.getByRole("link", { name: "Pools", exact: true }).first()+ await poolsNavigation.focus()+ await expect(poolsNavigation).not.toBeFocused()+ await expect(closeButton).toBeFocused()++ const lastFocusable = dialog.locator('button:not([disabled])').last()+ await closeButton.press("Shift+Tab")+ await expect(lastFocusable).toBeFocused()+ await lastFocusable.press("Tab")+ await expect(closeButton).toBeFocused()++ await page.keyboard.press("Escape")+ await expect(page.getByRole("dialog", { name: "Conversations" })).toHaveCount(0)+ await expect(trigger).toBeFocused()+ await expect(page.locator("#root")).not.toHaveAttribute("inert", "")++ await trigger.click()+ await page.getByTestId("conversation-history-backdrop").click({ position: { x: 380, y: 420 } })+ await expect(page.getByRole("dialog", { name: "Conversations" })).toHaveCount(0)+ await expect(trigger).toBeFocused()++ await trigger.click()+ await closeButton.click()+ await expect(page.getByRole("dialog", { name: "Conversations" })).toHaveCount(0)+ await expect(trigger).toBeFocused()+})++test("selects mobile history without horizontal page overflow", async ({ page }) => {+ await page.setViewportSize({ width: 390, height: 844 })+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page)++ await page.goto("/agent")+ await page.getByRole("button", { name: "View conversations" }).click()+ await page.getByRole("dialog", { name: "Conversations" }).getByRole("button", { name: "Example browser task" }).click()++ await expect(page.getByText("The example site is ready.")).toBeVisible()+ await expect(page.getByRole("dialog", { name: "Conversations" })).toHaveCount(0)+ await expect.poll(() => page.evaluate(() => ({+ body: document.body.scrollWidth <= document.body.clientWidth,+ document: document.documentElement.scrollWidth <= document.documentElement.clientWidth,+ }))).toEqual({ body: true, document: true })+})++test("returns focus to the prompt after keyboard submission completes", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [],+ turns: [{ events: [{ type: "content_delta", delta: "Keyboard complete." }, assistant("Keyboard complete.")] }],+ })++ await page.goto("/agent")+ const prompt = page.getByPlaceholder("Ask a question")+ await prompt.fill("Submit from keyboard")+ await prompt.press("Enter")++ await expect(page.getByText("Keyboard complete.", { exact: true })).toBeVisible()+ await expect(page.locator('[aria-live="polite"]').filter({ hasText: /^Latest assistant message available\.$/ })).toHaveCount(1)+ await expect(page.locator('[aria-live]').filter({ hasText: /Latest user message available/ })).toHaveCount(0)+ await expect(prompt).toBeEnabled()+ await expect(prompt).toBeFocused()+})++test("exposes chat states and controls by accessible role and unique name", async ({ page }) => {+ const now = new Date().toISOString()+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [{+ id: "accessible-chat",+ title: "Accessible chat",+ created_at: now,+ updated_at: now,+ messages: [+ { id: "user-one", role: "user", content: "First question", created_at: now },+ { id: "user-two", role: "user", content: "Second question", created_at: now },+ ],+ }],+ turns: [+ { hold: true, events: [assistant("", [bashCall("accessible-command", "printf accessible")])] },+ { error: { status: 500, message: "Accessible failure" } },+ ],+ })++ await page.goto("/agent")+ await page.getByRole("button", { name: "Accessible chat" }).click()+ const transcript = page.getByRole("region", { name: "Chat" })+ await expect(transcript).toBeVisible()+ const bubbleLabels = await transcript.locator("[aria-label]").evaluateAll(elements =>+ elements.map(element => element.getAttribute("aria-label")).filter(label => label?.startsWith("You at ")),+ )+ expect(new Set(bubbleLabels).size).toBe(bubbleLabels.length)++ const prompt = page.getByPlaceholder("Ask a question")+ await prompt.fill("Run accessible command")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.locator('[aria-live="polite"]').filter({ hasText: "Generating response" })).toHaveCount(1)+ await expect(transcript.locator(':scope > [role="status"]')).toHaveCount(0)+ await expect(page.getByRole("button", { name: "Stop generating" })).toBeVisible()+ chat.releaseTurn()+ await expect(page.getByRole("button", { name: "Command details" })).toBeVisible()+ await expect(page.getByRole("alert")).toContainText("Accessible failure")+ await expect(page.locator('[aria-live]').filter({ hasText: "Accessible failure" })).toHaveCount(0)+})++test("scrolls the newest message into view while keeping the composer fixed", async ({ page }) => {+ const now = new Date().toISOString()+ const messages = Array.from({ length: 24 }, (_, index) => ({+ id: `overflow-${index}`,+ role: index % 2 === 0 ? "user" as const : "assistant" as const,+ content: `Overflow message ${index + 1} with enough text to occupy transcript space.`,+ created_at: now,+ }))+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [{ id: "overflow-chat", title: "Overflow chat", created_at: now, updated_at: now, messages }],+ turns: [{ events: [{ type: "content_delta", delta: "Newest response." }, assistant("Newest response.")] }],+ })++ await page.goto("/agent")+ await page.getByRole("button", { name: "Overflow chat" }).click()+ const transcript = page.getByRole("region", { name: "Chat" })+ const composer = page.locator(".agent-chat-composer")+ const composerBefore = await composer.boundingBox()+ await transcript.evaluate(element => { element.scrollTop = 0 })++ await page.getByPlaceholder("Ask a question").fill("Show the newest response")+ await page.getByRole("button", { name: "Send message" }).click()++ await expect(page.getByText("Newest response.", { exact: true })).toBeInViewport()+ await expect.poll(() => transcript.evaluate(element => element.scrollTop)).toBeGreaterThan(0)+ const composerAfter = await composer.boundingBox()+ expect(composerBefore).not.toBeNull()+ expect(composerAfter).not.toBeNull()+ expect(composerAfter?.y).toBeCloseTo(composerBefore?.y ?? 0, 0)+})++test("parses fragmented unterminated NDJSON and rejects malformed final events", async ({ page }) => {+ await mockAuth(page)+ await page.goto("/pools")++ const result = await page.evaluate(async () => {+ const api = await import("/src/sdk/chat.ts")+ const originalFetch = window.fetch+ const encode = (value: string) => new TextEncoder().encode(value)+ const stream = (chunks: string[]) =>+ new ReadableStream<Uint8Array>({+ start(controller) {+ for (const chunk of chunks) controller.enqueue(encode(chunk))+ controller.close()+ },+ })++ try {+ window.fetch = async () =>+ new Response(+ stream([+ '{"type":"content_delta","delta":"Hel',+ 'lo"}\n{"type":"assistant","message":{"role":"assistant","content":"Complete"}}',+ ]),+ { status: 200 },+ )+ const deltas: string[] = []+ const complete = await api.streamTurn("conversation-1", [], delta => deltas.push(delta))++ window.fetch = async () =>+ new Response(+ stream([+ '{"type":"assistant","message":{"role":"assistant","content":"ok","tool_calls":{}}}',+ ]),+ { status: 200 },+ )+ let malformedError = ""+ try {+ await api.streamTurn("conversation-1", [], () => undefined)+ } catch (error) {+ malformedError = error instanceof Error ? error.name : String(error)+ }++ return { complete, deltas, malformedError }+ } finally {+ window.fetch = originalFetch+ }+ })++ expect(result.deltas).toEqual(["Hello"])+ expect(result.complete.content).toBe("Complete")+ expect(result.malformedError).toBe("ChatApiError")+})++test("hides chat navigation and redirects when the feature is disabled", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: false })++ await page.goto("/pools")+ await expect(page.getByRole("link", { name: "Chat" })).toHaveCount(0)++ await page.goto("/agent")+ await expect(page).toHaveURL(/\/pools$/)+})++test("disables skeleton shimmer when reduced motion is requested", async ({ page }) => {+ await page.emulateMedia({ reducedMotion: "reduce" })+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, { holdList: true })++ await page.goto("/agent")++ await expect(page.getByTestId("conversation-skeleton").first()).toBeVisible()+ await expect(page.getByTestId("conversation-skeleton").first()).toHaveCSS(+ "animation-name",+ "none",+ )+})++const bashCall = (id: string, command: string, options: Record<string, number> = {}) => ({+ id,+ type: "function" as const,+ function: { name: "bash", arguments: JSON.stringify({ command, ...options }) },+})++const assistant = (content: string, toolCalls: ReturnType<typeof bashCall>[] = []) => ({+ type: "assistant",+ message: { role: "assistant", content, tool_calls: toolCalls },+})++test("runs a browser bash tool loop and shows completed command details", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [],+ turns: [+ { events: [assistant("", [bashCall("bash-1", "printf hello > note.txt; cat note.txt")])] },+ { events: [{ type: "content_delta", delta: "The file contains hello." }, assistant("The file contains hello.")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Create and read note.txt")+ await page.getByRole("button", { name: "Send message" }).click()++ await expect(page.getByText("Running command")).toBeVisible()+ await expect(page.getByText("Command completed")).toBeVisible()+ await expect(page.getByText("The file contains hello.")).toBeVisible()+ await page.getByRole("button", { name: "Command details" }).click()+ await expect(page.getByText("printf hello > note.txt; cat note.txt")).toBeVisible()+ await expect(page.getByText("hello", { exact: true })).toBeVisible()+})++test("shows failed, timed out, and truncated bash results", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [],+ turns: [+ { events: [assistant("", [bashCall("failed", "false")])] },+ { events: [assistant("", [bashCall("timed", "sleep 1", { timeout_ms: 250 })])] },+ { events: [assistant("", [bashCall("truncated", "printf '%300s' x | tr ' ' x", { max_output_chars: 256 })])] },+ { events: [assistant("Done")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Exercise bash failures")+ await page.getByRole("button", { name: "Send message" }).click()++ await expect(page.getByText("Command failed")).toBeVisible()+ await expect(page.getByText("Command timed out")).toBeVisible()+ await page.getByRole("button", { name: "Command details" }).last().click()+ await expect(page.getByText("Output was truncated")).toBeVisible()+})++test("stops an active turn and restores the composer", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, { conversations: [], turns: [{ hold: true }] })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Wait forever")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByRole("button", { name: "Stop generating" })).toBeVisible()+ await page.getByRole("button", { name: "Stop generating" }).click()+ await expect(page.getByRole("button", { name: "Stop generating" })).toHaveCount(0)+ await expect(page.getByPlaceholder("Ask a question")).toBeEnabled()+ await expect(page.getByText("Generating a response")).toHaveCount(0)+})++test("shows an API error and retries without duplicating the user bubble", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [],+ turns: [+ { error: { status: 500, message: "Backend unavailable" } },+ { events: [{ type: "content_delta", delta: "Recovered." }, assistant("Recovered")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Try again")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByRole("alert")).toContainText("Backend unavailable")+ await page.getByRole("button", { name: "Retry" }).click()+ await expect(page.getByText("Recovered")).toBeVisible()+ await expect(page.getByText("Try again")).toHaveCount(1)+ expect(chat.turnRequests.map(request => request.messages)).toEqual([+ [{ role: "user", content: "Try again" }],+ [],+ ])+})++test("keeps streamed content in one assistant bubble", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [],+ turns: [{ events: [{ type: "content_delta", delta: "One " }, { type: "content_delta", delta: "bubble" }, assistant("One bubble")] }],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Stream")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("One bubble")).toBeVisible()+ await expect(page.getByLabel(/^Assistant at /)).toHaveCount(1)+})++test("reconstructs stored bash command steps from tool history", async ({ page }) => {+ const now = new Date().toISOString()+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [+ {+ id: "stored",+ title: "Stored command",+ created_at: now,+ updated_at: now,+ messages: [+ { id: "user", role: "user", content: "Read note", created_at: now },+ { id: "call", role: "assistant", content: "", tool_calls: [bashCall("stored-call", "cat note.txt")], created_at: now },+ { id: "result", role: "tool", tool_call_id: "stored-call", content: JSON.stringify({ stdout: "hello", stderr: "", exit_code: 0, timed_out: false, truncated: false }), created_at: now },+ { id: "answer", role: "assistant", content: "The note says hello.", created_at: now },+ ],+ },+ ],+ })++ await page.goto("/agent")+ await page.getByRole("button", { name: "Stored command" }).click()+ await expect(page.getByText("Command completed")).toBeVisible()+ await page.getByText("Command details").click()+ await expect(page.getByText("cat note.txt")).toBeVisible()+ await expect(page.getByText("hello", { exact: true })).toBeVisible()+ await expect(page.getByText("The note says hello.")).toBeVisible()+})++test("reconciles persisted turn history without duplicate transient entries", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, {+ conversations: [],+ turns: [+ { events: [assistant("", [bashCall("once", "printf hello")])] },+ { events: [{ type: "content_delta", delta: "Final once." }, assistant("Final once")] },+ ],+ })+ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Run once")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Final once", { exact: true })).toBeVisible()+ await expect(page.getByText("Run once", { exact: true })).toHaveCount(1)+ await expect(page.getByText("Command completed", { exact: true })).toHaveCount(1)+ await expect(page.getByText("Final once", { exact: true })).toHaveCount(1)+})++test("keeps successful transient output and refreshes without rerunning the model", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [],+ refreshError: { afterTurnRequests: 1, message: "Refresh unavailable" },+ turns: [{ events: [{ type: "content_delta", delta: "Completed." }, assistant("Completed")] }],+ })+ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Complete then refresh")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Completed")).toBeVisible()+ await expect(page.getByRole("alert")).toContainText("Refresh unavailable")+ await expect(page.getByRole("button", { name: "Refresh conversation" })).toBeVisible()+ await page.getByRole("button", { name: "Refresh conversation" }).click()+ await expect(page.getByRole("alert")).toHaveCount(0)+ expect(chat.turnRequests).toHaveLength(1)+})+++test("stops an open streamed response without showing generation retry", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ await mockChatApi(page, { conversations: [] })+ await page.addInitScript(() => {+ const originalFetch = window.fetch.bind(window)+ window.fetch = async (input, init) => {+ const url = typeof input === "string" ? input : input instanceof Request ? input.url : input.toString()+ if (!url.includes("/turns")) return originalFetch(input, init)+ ;(window as Window & { streamHeaders?: string }).streamHeaders = "x-stream-ready"+ const encoder = new TextEncoder()+ return new Response(new ReadableStream({+ start(controller) {+ controller.enqueue(encoder.encode('{"type":"content_delta","delta":"Streaming now"}\n'))+ init?.signal?.addEventListener("abort", () => controller.error(new DOMException("Aborted", "AbortError")), { once: true })+ },+ }), { status: 200, headers: { "X-Stream-Ready": "yes" } })+ }+ })+ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Stop streamed response")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Streaming now")).toBeVisible()+ await expect.poll(() => page.evaluate(() => (window as Window & { streamHeaders?: string }).streamHeaders)).toBe("x-stream-ready")+ await page.getByRole("button", { name: "Stop generating" }).click()+ await expect(page.getByRole("alert")).toHaveCount(0)+ await expect(page.getByPlaceholder("Ask a question")).toBeEnabled()+})++test("announces conversation loading, loaded, and no selected conversation", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, { holdConversation: true })+ await page.goto("/agent")+ await expect(page.locator('[aria-live]').filter({ hasText: "No conversation selected" })).toBeVisible()+ await page.getByRole("button", { name: "Example browser task" }).click()+ await expect(page.locator('[aria-live]').filter({ hasText: "Loading conversation" })).toBeVisible()+ chat.releaseConversation()+ await expect(page.locator('[aria-live]').filter({ hasText: "Conversation loaded" })).toBeVisible()+})+++test("locks submission until post-turn refresh reconciliation completes", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [],+ holdRefresh: true,+ turns: [+ { events: [{ type: "content_delta", delta: "First final." }, assistant("First final.")] },+ { events: [{ type: "content_delta", delta: "Second final." }, assistant("Second final.")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("First prompt")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("First final.", { exact: true })).toBeVisible()++ const prompt = page.getByPlaceholder("Ask a question")+ await prompt.fill("Second prompt")+ await expect(page.getByRole("button", { name: "Send message" })).toBeDisabled()+ await page.getByRole("button", { name: "Send message" }).click({ force: true })+ expect(chat.turnRequests).toHaveLength(1)++ chat.releaseRefresh()+ await expect(page.getByRole("button", { name: "Send message" })).toBeEnabled()+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Second final.", { exact: true })).toBeVisible()+ expect(chat.turnRequests).toHaveLength(2)+})+++test("serializes held refresh recovery before allowing another turn", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [],+ refreshError: { afterTurnRequests: 1, message: "Refresh unavailable" },+ holdRefresh: true,+ turns: [+ { events: [{ type: "content_delta", delta: "Recovered first." }, assistant("Recovered first.")] },+ { events: [{ type: "content_delta", delta: "Second after recovery." }, assistant("Second after recovery.")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("First recovery prompt")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByRole("button", { name: "Refresh conversation" })).toBeVisible()++ await page.getByRole("button", { name: "Refresh conversation" }).click()+ const prompt = page.getByPlaceholder("Ask a question")+ await prompt.fill("Blocked during recovery")+ await expect(page.getByRole("button", { name: "Send message" })).toBeDisabled()+ await expect(page.getByRole("button", { name: "Stop generating" })).toHaveCount(0)+ await page.getByRole("button", { name: "Send message" }).click({ force: true })+ expect(chat.turnRequests).toHaveLength(1)++ chat.releaseRefresh()+ await expect(page.getByRole("alert")).toHaveCount(0)+ await expect(page.getByText("Recovered first.", { exact: true })).toBeVisible()+ await expect(page.getByRole("button", { name: "Send message" })).toBeEnabled()+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Second after recovery.", { exact: true })).toBeVisible()+ expect(chat.turnRequests).toHaveLength(2)+})+++test("locks conversation selection until an active turn reconciles", async ({ page }) => {+ const now = new Date().toISOString()+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [+ { id: "conversation-a", title: "Conversation A", created_at: now, updated_at: now, messages: [{ id: "a-user", role: "user", content: "A history", created_at: now }] },+ { id: "conversation-b", title: "Conversation B", created_at: now, updated_at: now, messages: [{ id: "b-user", role: "user", content: "B only message", created_at: now }] },+ ],+ turns: [{ hold: true, events: [{ type: "content_delta", delta: "A final." }, assistant("A final.")] }],+ })++ await page.goto("/agent")+ await page.getByRole("button", { name: "Conversation A" }).click()+ await expect(page.getByText("A history")).toBeVisible()+ await page.getByPlaceholder("Ask a question").fill("Run in A")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByRole("button", { name: "Conversation B" })).toBeDisabled()+ await page.getByRole("button", { name: "Conversation B" }).click({ force: true })+ await expect(page.getByText("Run in A", { exact: true })).toBeVisible()+ await expect(page.getByText("B only message")).toHaveCount(0)++ chat.releaseTurn()+ await expect(page.getByText("A final.", { exact: true })).toBeVisible()+ await expect(page.getByRole("button", { name: "Conversation B" })).toBeEnabled()+ await page.getByRole("button", { name: "Conversation B" }).click()+ await expect(page.getByText("B only message")).toBeVisible()+ await expect(page.getByText("A final.", { exact: true })).toHaveCount(0)+})+++test("retries an initial conversation creation without stranding the lifecycle", async ({ page }) => {+ await mockAuth(page, { admin: false, chat: true })+ const chat = await mockChatApi(page, {+ conversations: [],+ createError: { message: "Conversation creation failed" },+ turns: [+ { events: [{ type: "content_delta", delta: "Created after retry." }, assistant("Created after retry.")] },+ { events: [{ type: "content_delta", delta: "Follow-up works." }, assistant("Follow-up works.")] },+ ],+ })++ await page.goto("/agent")+ await page.getByPlaceholder("Ask a question").fill("Create this conversation")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByRole("alert")).toContainText("Conversation creation failed")+ await expect(page.getByRole("button", { name: "Retry" })).toBeVisible()+ await expect(page.getByPlaceholder("Ask a question")).toBeEnabled()+ await expect(page.getByLabel(/^You at /).getByText("Create this conversation", { exact: true })).toHaveCount(0)+ expect(chat.createRequests).toBe(1)+ expect(chat.turnRequests).toHaveLength(0)++ await page.getByRole("button", { name: "Retry" }).click()+ await expect(page.getByText("Created after retry.", { exact: true })).toBeVisible()+ await expect(page.getByLabel(/^You at /).getByText("Create this conversation", { exact: true })).toHaveCount(1)+ expect(chat.createRequests).toBe(2)+ expect(chat.turnRequests).toHaveLength(1)+ expect(chat.turnRequests[0].messages).toEqual([{ role: "user", content: "Create this conversation" }])++ await page.getByPlaceholder("Ask a question").fill("Normal follow-up")+ await page.getByRole("button", { name: "Send message" }).click()+ await expect(page.getByText("Follow-up works.", { exact: true })).toBeVisible()+ expect(chat.turnRequests).toHaveLength(2)+})diff --git a/libs/fleet/e2e/fixtures/mock-api.ts b/libs/fleet/e2e/fixtures/mock-api.tsindex fc2d8a1c88..b786c368dd 100644--- a/libs/fleet/e2e/fixtures/mock-api.ts+++ b/libs/fleet/e2e/fixtures/mock-api.ts@@ -51,7 +51,27 @@ const FAKE_TOKEN =* with a stub class that resolves init() immediately as authenticated.* This avoids the real keycloak-js redirecting to the Keycloak login page.*/-export async function mockAuth(page: Page): Promise<void> {+export interface MockFeatureFlags {+ admin?: boolean+ billing?: boolean+ chat?: boolean+}++export interface MockAuthOptions {+ holdConfig?: boolean+}++export interface MockAuthControl {+ releaseConfig(): void+}++export async function mockAuth(+ page: Page,+ flags: MockFeatureFlags = {},+ options: MockAuthOptions = {},+): Promise<MockAuthControl> {+ const config = deferred()+ if (!options.holdConfig) config.resolve()// Intercept the Vite pre-bundled keycloak-js module. Vite serves// node_modules deps from /.vite/deps/ or /node_modules/.vite/deps/.// Replace the entire module with a stub Keycloak class.@@ -100,10 +120,24 @@ export async function mockAuth(page: Page): Promise<void> {})})+ await page.route("**/api/config", async route => {+ await config.promise+ await route.fulfill({+ contentType: "application/json",+ body: JSON.stringify({+ admin: flags.admin ?? false,+ billing: flags.billing ?? false,+ chat: flags.chat ?? false,+ }),+ })+ })+// Intercept any stray Keycloak endpoint requestsawait page.route("**/realms/cyclops-cs/**", (route) =>route.fulfill({ status: 200, contentType: "application/json", body: "{}" }),)++ return { releaseConfig: config.resolve }}// ---------------------------------------------------------------------------@@ -498,3 +532,235 @@ export async function mockClaimsApi(page: Page): Promise<void> {},)}+++// ---------------------------------------------------------------------------+// Chat API mocking+// ---------------------------------------------------------------------------++export interface MockChatMessage {+ id: string+ role: "user" | "assistant" | "tool"+ content: string+ created_at: string+ tool_call_id?: string+ tool_calls?: Array<{+ id: string+ type: "function"+ function: { name: string; arguments: string }+ }>+}++export interface MockChatConversation {+ id: string+ title: string+ created_at: string+ updated_at: string+ messages: MockChatMessage[]+}++export interface MockChatApiOptions {+ conversations?: MockChatConversation[]+ holdList?: boolean+ holdConversation?: boolean+ turns?: MockChatTurn[]+ refreshError?: { afterTurnRequests: number; message: string }+ holdRefresh?: boolean+ createError?: { message: string }+}++export interface MockChatApiControl {+ authorizationHeaders: string[]+ createRequests: number+ turnRequests: Array<{ conversationId: string; messages: Array<Record<string, unknown>> }>+ releaseList(): void+ releaseConversation(): void+ releaseRefresh(): void+ releaseTurn(): void+}++export interface MockChatTurn {+ events?: Array<Record<string, unknown>>+ error?: { status: number; message: string }+ hold?: boolean+}++function deferred(): { promise: Promise<void>; resolve: () => void } {+ let resolve = () => {}+ const promise = new Promise<void>(complete => {+ resolve = complete+ })+ return { promise, resolve }+}++function defaultChatConversations(): MockChatConversation[] {+ const now = new Date().toISOString()+ return [+ {+ id: "conversation-1",+ title: "Example browser task",+ created_at: now,+ updated_at: now,+ messages: [+ {+ id: "message-1",+ role: "user",+ content: "Open the example site.",+ created_at: now,+ },+ {+ id: "message-2",+ role: "assistant",+ content: "The example site is ready.",+ created_at: now,+ },+ ],+ },+ ]+}++export async function mockChatApi(+ page: Page,+ options: MockChatApiOptions = {},+): Promise<MockChatApiControl> {+ const conversations = options.conversations ?? defaultChatConversations()+ const authorizationHeaders: string[] = []+ const createRequests = { count: 0 }+ const turnRequests: Array<{ conversationId: string; messages: Array<Record<string, unknown>> }> = []+ const list = deferred()+ const conversation = deferred()+ const refresh = deferred()+ const turnGate = deferred()+ const turns = [...(options.turns ?? [])]+ let refreshFailuresRemaining = options.refreshError ? 1 : 0+ let createFailuresRemaining = options.createError ? 1 : 0++ if (!options.holdList) list.resolve()+ if (!options.holdConversation) conversation.resolve()+ if (!options.holdRefresh) refresh.resolve()+ if (!turns.some(item => item.hold)) turnGate.resolve()++ await page.route("**/api/chat/conversations", async route => {+ if (route.request().method() === "GET") {+ authorizationHeaders.push(route.request().headers().authorization ?? "")+ if (options.refreshError && turnRequests.length >= options.refreshError.afterTurnRequests && refreshFailuresRemaining > 0) {+ refreshFailuresRemaining -= 1+ await route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: options.refreshError.message }) })+ return+ }+ await list.promise+ if (options.holdRefresh && turnRequests.length > 0) await refresh.promise+ await route.fulfill({+ contentType: "application/json",+ body: JSON.stringify(+ conversations.map(({ messages: _messages, ...summary }) => summary),+ ),+ })+ return+ }++ if (route.request().method() === "POST") {+ createRequests.count += 1+ if (createFailuresRemaining > 0) {+ createFailuresRemaining -= 1+ await route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: options.createError!.message }) })+ return+ }+ const now = new Date().toISOString()+ const created: MockChatConversation = {+ id: `conversation-${conversations.length + 1}`,+ title: "New conversation",+ created_at: now,+ updated_at: now,+ messages: [],+ }+ conversations.unshift(created)+ await route.fulfill({+ status: 201,+ contentType: "application/json",+ body: JSON.stringify(created),+ })+ return+ }++ await route.continue()+ })++ await page.route("**/api/chat/conversations/*", async route => {+ if (route.request().method() !== "GET") {+ await route.continue()+ return+ }++ if (options.refreshError && turnRequests.length >= options.refreshError.afterTurnRequests && refreshFailuresRemaining > 0) {+ refreshFailuresRemaining -= 1+ await route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: options.refreshError.message }) })+ return+ }+ await conversation.promise+ if (options.holdRefresh && turnRequests.length > 0) await refresh.promise+ const id = new URL(route.request().url()).pathname.split("/").pop()+ const selected = conversations.find(item => item.id === id)+ if (!selected) {+ await route.fulfill({+ status: 404,+ contentType: "application/json",+ body: JSON.stringify({ error: "conversation not found" }),+ })+ return+ }+ await route.fulfill({ contentType: "application/json", body: JSON.stringify(selected) })+ })++ await page.route("**/api/chat/conversations/*/turns", async route => {+ if (route.request().method() !== "POST") {+ await route.continue()+ return+ }++ const url = new URL(route.request().url())+ const conversationId = url.pathname.split("/").slice(-2, -1)[0]+ const body = route.request().postDataJSON() as { messages?: Array<Record<string, unknown>> }+ turnRequests.push({ conversationId, messages: body.messages ?? [] })+ const now = new Date().toISOString()+ const selected = conversations.find(item => item.id === conversationId)+ if (selected) {+ for (const message of body.messages ?? []) {+ selected.messages.push({ id: `message-${selected.messages.length + 1}`, role: message.role as MockChatMessage["role"], content: String(message.content ?? ""), created_at: now, ...(typeof message.tool_call_id === "string" ? { tool_call_id: message.tool_call_id } : {}) })+ }+ selected.updated_at = now+ }+ const turn = turns.shift()+ if (!turn) {+ await route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: "No mock turn" }) })+ return+ }+ if (turn.hold) await turnGate.promise+ if (turn.error) {+ await route.fulfill({+ status: turn.error.status,+ contentType: "application/json",+ body: JSON.stringify({ error: turn.error.message }),+ })+ return+ }+ if (selected) {+ const final = [...(turn.events ?? [])].reverse().find(event => event.type === "assistant")?.message as Record<string, unknown> | undefined+ if (final) selected.messages.push({ id: `message-${selected.messages.length + 1}`, role: "assistant", content: String(final.content ?? ""), created_at: now, ...(Array.isArray(final.tool_calls) ? { tool_calls: final.tool_calls as MockChatMessage["tool_calls"] } : {}) })+ }+ await route.fulfill({+ contentType: "application/x-ndjson",+ body: (turn.events ?? []).map(event => JSON.stringify(event) + "\n").join(""),+ })+ })++ return {+ authorizationHeaders,+ get createRequests() { return createRequests.count },+ turnRequests,+ releaseList: list.resolve,+ releaseConversation: conversation.resolve,+ releaseRefresh: refresh.resolve,+ releaseTurn: turnGate.resolve,+ }+}diff --git a/libs/fleet/nginx.conf b/libs/fleet/nginx.confindex f19167db18..bcf77dcbb9 100644--- a/libs/fleet/nginx.conf+++ b/libs/fleet/nginx.conf@@ -148,7 +148,7 @@ server {proxy_set_header X-Forwarded-Proto $scheme;}- location ~ ^/api/(keys|user-keys|github-trust-policies|gateway|k8s|orch|swagger|batch|label|namespaces|config|billing|state)(/|$) {+ location ~ ^/api/(keys|user-keys|github-trust-policies|gateway|k8s|orch|swagger|batch|label|namespaces|config|chat|billing|state)(/|$) {proxy_pass ${CYCLOPS_CS_BACKEND};proxy_http_version 1.1;proxy_set_header Host $host;diff --git a/libs/fleet/package.json b/libs/fleet/package.jsonindex 6de3dbdf4a..5847dbbb53 100644--- a/libs/fleet/package.json+++ b/libs/fleet/package.json@@ -9,12 +9,13 @@"build": "npm run sdk:browser && npm run build:app","build:app": "tsc -b && vite build","preview": "vite preview",- "typecheck": "npm run sdk:browser && tsc -b --noEmit",+ "typecheck": "npm run sdk:browser && tsc -b --noEmit && tsc --noEmit --target ES2022 --module NodeNext --moduleResolution NodeNext --allowImportingTsExtensions --skipLibCheck agent.test.ts src/browser-agent.ts","lint": "biome check","lint:fix": "biome check --write","test:e2e": "npm run sdk:browser && playwright test","test:e2e:ui": "npm run sdk:browser && playwright test --ui",- "test:sdk-models": "rm -rf target/sdk-model-tests && tsc e2e/sdk-models.unit.ts src/sdk/status.ts --target ES2022 --module NodeNext --moduleResolution NodeNext --outDir target/sdk-model-tests --skipLibCheck && node target/sdk-model-tests/e2e/sdk-models.unit.js"+ "test:sdk-models": "rm -rf target/sdk-model-tests && tsc e2e/sdk-models.unit.ts src/sdk/status.ts --target ES2022 --module NodeNext --moduleResolution NodeNext --outDir target/sdk-model-tests --skipLibCheck && node target/sdk-model-tests/e2e/sdk-models.unit.js",+ "test:agent": "node --test --experimental-strip-types agent.test.ts"},"dependencies": {"@cloudscape-design/collection-hooks": "^1.0.93",@@ -26,7 +27,9 @@"keycloak-js": "^25.0.6","react": "^18.3.1","react-dom": "^18.3.1",- "react-router-dom": "^6.28.0"+ "react-router-dom": "^6.28.0",+ "@cloudscape-design/chat-components": "^1.0.157",+ "just-bash": "^3.2.0"},"devDependencies": {"@biomejs/biome": "^2.4.15",@@ -35,6 +38,7 @@"@types/react-dom": "^18.3.1","@vitejs/plugin-react": "^4.3.4","typescript": "^5.7.2",- "vite": "^5.4.11"+ "vite": "^5.4.11",+ "@types/node": "^22.19.17"}}diff --git a/libs/fleet/pnpm-lock.yaml b/libs/fleet/pnpm-lock.yamlindex 596e36af5e..ebfd1fb98c 100644--- a/libs/fleet/pnpm-lock.yaml+++ b/libs/fleet/pnpm-lock.yaml@@ -13,6 +13,9 @@ importers:.:dependencies:+ '@cloudscape-design/chat-components':+ specifier: ^1.0.157+ version: 1.0.159(@cloudscape-design/[email protected]([email protected]([email protected]))([email protected]))([email protected])'@cloudscape-design/collection-hooks':specifier: ^1.0.93version: 1.0.93([email protected])@@ -31,6 +34,9 @@ importers:ansi-to-html:specifier: ^0.7.2version: 0.7.2+ just-bash:+ specifier: ^3.2.0+ version: 3.2.0keycloak-js:specifier: ^25.0.6version: 25.0.6@@ -50,6 +56,9 @@ importers:'@playwright/test':specifier: ^1.60.0version: 1.60.0+ '@types/node':+ specifier: ^22.19.17+ version: 22.20.1'@types/react':specifier: ^18.3.12version: 18.3.28@@ -58,13 +67,13 @@ importers:version: 18.3.7(@types/[email protected])'@vitejs/plugin-react':specifier: ^4.3.4- version: 4.7.0([email protected])+ version: 4.7.0([email protected](@types/[email protected]))typescript:specifier: ^5.7.2version: 5.9.3vite:specifier: ^5.4.11- version: 5.4.21+ version: 5.4.21(@types/[email protected])packages:@@ -208,6 +217,15 @@ packages:cpu: [x64]os: [win32]+ '@borewit/[email protected]':+ resolution: {integrity: sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==}++ '@cloudscape-design/[email protected]':+ resolution: {integrity: sha512-c3VQhhe4tm0I0lcPVi/8IGVdlcAPI/Wcwi0byv/7QmbsjLlPPIHlAm8uzSt+BclrQLH0Q8FwTIM/nVCKWmKVyw==}+ peerDependencies:+ '@cloudscape-design/components': ^3+ react: '>=18.2.0'+'@cloudscape-design/[email protected]':resolution: {integrity: sha512-77khCT0cwxxEddRxfsvuZNlrlu/Qk2CNPm+tMsMTXoL1/n4mrDKQh/AA0sbnvCga7m4g9xS3kW27RfN1H9eu1Q==}peerDependencies:@@ -407,6 +425,21 @@ packages:'@formatjs/[email protected]':resolution: {integrity: sha512-XOMO2Hupl0wdd172Y06h6kLpBz6Dv+J4okPLl4LPtzbr8f66WbIoy4ev98EBuZ6ZK4h5ydTN6XneT4QVpD7cdA==}+ '@jitl/[email protected]':+ resolution: {integrity: sha512-v9T+GQpmk43VDJ7d72sf0Nexhk+ArvtUihW27dy7lqAl0zBObFKtSBBIm5RBjwIhE8VwsPPm9PNuvPvNqLWUEg==}++ '@jitl/[email protected]':+ resolution: {integrity: sha512-EX8zbXwGqCgAE764M+qvkHtyXDi/FUoMBea0JnES7vCM3P7a2+EOZOjGv85wtZ2sJhI1oJ+nekmqpOODFDY+hw==}++ '@jitl/[email protected]':+ resolution: {integrity: sha512-LeYWrPGC1uNCTBWvibo3ZLJj0CSVNYUXvJpXMCmuQ5Sap2cCACc3uvGvYV4homHHBAzfw5akoTqMMS4YFRtw+Q==}++ '@jitl/[email protected]':+ resolution: {integrity: sha512-3oSwPfja12ICz4aIblB58cuY8JlEq5Txt8Cut4VLo+LH47QN+mzCnSgnbB03hWzg1LBcc+VyyI9UOag7a1NF+Q==}++ '@jitl/[email protected]':+ resolution: {integrity: sha512-BKNDI/TPBfGlLNGYpLrhcDGXmIk4xHm4MRAisOBnOzpXVn9HZWsfmMAc9WMBrAHjvvds6HOikKeaOBKdPdpVrg==}+'@jridgewell/[email protected]':resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}@@ -426,6 +459,16 @@ packages:'@material/[email protected]':resolution: {integrity: sha512-ztmtTd6xwnuh2/xu+Vb01btgV8SQWYCaK56CkRK8gEkWe5TuDyBcYJ0wgkMRn+2VcE9KUmhvkz+N9GHrqw/C0g==}+ '@mixmark-io/[email protected]':+ resolution: {integrity: sha512-Y28PR25bHXUg88kCV7nivXrP2Nj2RueZ3/l/jdx6J9f8J4nsEGcgX0Qe6lt7Pa+J79+kPiJU3LguR6O/6zrLOw==}++ '@mongodb-js/[email protected]':+ resolution: {integrity: sha512-mQ2s0pYYiav+tzCDR05Zptem8Ey2v8s11lri5RKGhTtL4COVCvVCk5vtyRYNT+9L8qSfyOqqefF9UtnW8mC5jA==}+ engines: {node: '>= 20.19.0'}++ '@nodable/[email protected]':+ resolution: {integrity: sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==}+'@novnc/[email protected]':resolution: {integrity: sha512-ucEJOx4T2avIRCleodk7YobZj5O2Ga2AeLfQ69A/yjG9HHba2+PDgwSkN3FttrmG+70ZGx21sElNFouK13RzyA==}@@ -566,6 +609,13 @@ packages:cpu: [x64]os: [win32]+ '@tokenizer/[email protected]':+ resolution: {integrity: sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==}+ engines: {node: '>=18'}++ '@tokenizer/[email protected]':+ resolution: {integrity: sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==}+'@types/[email protected]':resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}@@ -581,6 +631,9 @@ packages:'@types/[email protected]':resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}+ '@types/[email protected]':+ resolution: {integrity: sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==}+'@types/[email protected]':resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}@@ -609,23 +662,50 @@ packages:engines: {node: '>=8.0.0'}hasBin: true+ resolution: {integrity: sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==}++ resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}+ engines: {node: 18 || 20 || >=22}++ resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}+resolution: {integrity: sha512-Ic44hnOtFIgravCunj1ifSoQPSUrkNiJuH9Mf6jr2jjoA74icqV8wU0KuadXeOR8zuIJMOoTv0GuQjZ9ZYNMeA==}engines: {node: '>=6.0.0'}hasBin: true+ resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}++ resolution: {integrity: sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==}+ engines: {node: 20 || >=22}+resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}hasBin: true+ resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}+resolution: {integrity: sha512-hVLMUZFgR4JJ6ACt1uEESvQN1/dBVqPAKY0hgrV70eN3391K6juAfTjKZLKvOMsx8PxA7gsY1/tLMMTcfFLLpw==}+ resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}+resolution: {integrity: sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==}engines: {node: '>=6'}+ resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==}+ engines: {node: '>= 6'}+resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}@@ -665,12 +745,31 @@ packages:resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}+ resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}+ engines: {node: '>=10'}++ resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}+ engines: {node: '>=4.0.0'}++ resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}+ engines: {node: '>=8'}++ resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}+ engines: {node: '>=0.3.1'}+resolution: {integrity: sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==}resolution: {integrity: sha512-kOrWphBi8TOZyiJZqsgqIle0lw+tzmnQK83pV9dZUd01Nm2POECSyFQMAuarzZdYqQW7FH9RaYOuaRo3h+bQ3w==}+ resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}+resolution: {integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==}@@ -683,9 +782,27 @@ packages:resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}engines: {node: '>=6'}+ resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}+ engines: {node: '>=6'}++ resolution: {integrity: sha512-F74cZEdCvuw9P41GAC3rod4X04jjWGM1JPEv/GWSqFTWLsdyMSBMBMlm9Hk3GLBgLBbdBNY8yee0pQh2RBVESQ==}++ resolution: {integrity: sha512-IEMIf7298kXuZSRFoGfMYrl7is8LpavODgbNz1cwIudv7KwVFnuU+UsMporfq6PD6aXSlawZlARiA3UywCTfMw==}+ hasBin: true+resolution: {integrity: sha512-483XLLxTVIwWK3QTrMGRqUfUpoOs/0hbQrl2oz4J0pAcm3A3bu84wxTFqGqkJzewCLdME38xJLJAxBABfQT8sQ==}+ resolution: {integrity: sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==}+ engines: {node: '>=20'}++ resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}+resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}@@ -700,9 +817,28 @@ packages:resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}engines: {node: '>=6.9.0'}+ resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}++ resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}++ resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}++ resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}++ resolution: {integrity: sha512-IBTdIkzZNOpqm7q3dRqJvMaldXjDHWkEDfrwGEQTs5eaQMWV+djAhR+wahyNNMAa+qpbDUhBMVt4ZKNwpPm7xQ==}+ engines: {node: ^20.17.0 || >=22.9.0}+resolution: {integrity: sha512-m3Ofv/X/tV8Y3tHXLohcuVuhWKo7BBq62cqY15etqmLxg2DZ34AGGgQDeR+SCta2+zICb1NX83af0GJmbQ1++g==}+ resolution: {integrity: sha512-2LdV822R+wmI86unXA93WCFpL6g+av8ynWk0nrHyJqGop5VoocYsSLFgN8jrfalT6iGeLNM4KXuVSsULP53kEA==}+resolution: {integrity: sha512-o6WSo/LUvY2uC4j7mO50a2ms7E/EAdbP0swigLV+nzHKTTaYnaLIWJ02VdXrsJX0vGedDESQnLsOekr94ryfjg==}@@ -719,6 +855,11 @@ packages:engines: {node: '>=6'}hasBin: true+ resolution: {integrity: sha512-hRTLLWBXCKuosjaNFJR7uPYBza+T2vjG3NdPBz4wxlctlnxwrbLjtLQf6RtSKmy/jzNJ6/URCtvxrXjy6yFGeQ==}+ engines: {node: '>=20.18.1'}+ hasBin: true+resolution: {integrity: sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==}engines: {node: '>=18'}@@ -733,10 +874,28 @@ packages:resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}+ resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}+ engines: {node: '>=10'}++ resolution: {integrity: sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==}+ engines: {node: 18 || 20 || >=22}++ resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}++ resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}+resolution: {integrity: sha512-3ZH4UWBGpAwCKdfjynLQpUDVZWMe6vRHwarIpMdGLUp89CVR9hjzgyWERtMyqx+fPEqQ/PsAxFwvwPxLFxW40A==}engines: {node: '>=12.13.0'}+ resolution: {integrity: sha512-t9VmxaqrmANnEOBhpSDI6HD192Ge48k8vmWqQQL7hSFEqHEYwZbbsu49+aKLWZeRvFs3j1pMhXOqqF4kPlvjkQ==}+ engines: {node: '>=18.0.0'}+resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}@@ -745,6 +904,26 @@ packages:engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}hasBin: true+ resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}++ resolution: {integrity: sha512-W5ZNO5KRPB5TkYmGVD9F6YqhsglXJzE6etpbmT+f6EQElhiX/UTG551cnsRGvLG3fyZEg9HwaDmNmj5nwJ4z9g==}+ engines: {node: '>=10'}++ resolution: {integrity: sha512-4eUQWVPCUUUiBjLnHS3cXWeC6ryoPUc0U3rP7IuzapoGbzMqd/r6KKO0clr0b+snQhsrueFEhCZDdK+LK7hxKg==}+ engines: {node: ^18 || ^20 || >= 21}++ resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}+ hasBin: true++ resolution: {integrity: sha512-s0KzNOWwOJJgPG6wxg6cKohnAl9Wk/oW1KrQaVzJBjQwVcUGPQCzpR46Ximygjqj/3KhOrtJXnYMp/xYAXp75g==}+ engines: {node: '>=16.0.0'}+ hasBin: true+resolution: {integrity: sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==}@@ -752,6 +931,16 @@ packages:resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}engines: {node: '>=0.10.0'}+ resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}++ resolution: {integrity: sha512-SwzWD9gl/ElwYLCI0nUja1mFJzjq2D8ziShfNBa7zCHzkOozeOGDwHWQ+tvCzEZcewecWZ5U7kUopDnG+DFYEQ==}++ resolution: {integrity: sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==}+ engines: {node: '>=14.0.0'}+resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}@@ -769,9 +958,32 @@ packages:resolution: {integrity: sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==}engines: {node: ^10 || ^12 || >=14}+ resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}+ engines: {node: '>=10'}+ deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.+ hasBin: true+resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}+ resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}++ resolution: {integrity: sha512-QFnPfjFey8EqknSrSxe1hZrf1/8z7/6s1QzGOmKo6++02r7QRRX7ZoyNaZh7JuVjWsVW87KnQrbZqnHkOAzUyg==}++ resolution: {integrity: sha512-So0Sqw869y/S2oE3Nuc0uT3Dhqgvsj8FSrwBdsuTosVsG8ME5/OcudU1GxsrIFdFABgy17GHnTVO9TYV/bLQcA==}+ engines: {node: '>=16.0.0'}++ resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}+ hasBin: true++ resolution: {integrity: sha512-s/I5zEAo79SUK0Qw4dpZKpiMwbQ6Gz0KU2NRr7eaO4x/p2g7Vvmn3hdeXDg8VsaUjfj/ora+e9oi27LX/C9+mw==}+resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}peerDependencies:@@ -810,36 +1022,114 @@ packages:resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}engines: {node: '>=0.10.0'}+ resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}+ engines: {node: '>= 6'}+resolution: {integrity: sha512-pAQK9HalE84QSm4Po3EmWIZPd3FnjkShVkiMlz1iligWYkWQ7wHYd1PF/T7QZ5TVSD6uSTon5gBVMSM4JfBV+A==}engines: {node: '>=18.0.0', npm: '>=8.0.0'}hasBin: true+ resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}+resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}+ resolution: {integrity: sha512-SMguiTnYrhpLdk3PwfzHeotrcwi8bNV4iemL9tx9poR/yeaMYwB9VzR1w7b57DuWpuqR8n6oZboi0hj3AxZxQg==}+ hasBin: true+resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}hasBin: true+ resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}+ engines: {node: '>=10'}+ hasBin: true++ resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}++ resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}++ resolution: {integrity: sha512-kCZr2V3ch9i00x8zXRhjUNVcjG9ijES5dDudkXvUVCT5QlJNQWElSJdZqyPemffHoLNUYwOcou0Fy+ojN0uHSQ==}+ engines: {node: '>= 18'}+resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}engines: {node: '>=0.10.0'}+ resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}++ resolution: {integrity: sha512-gcj8zBWU5cFsi9WUP+4bFNXAyF1iRpA3LLyS/DP5xlrNzGmPIizUeBggKa8DbDwdqaKwUcTEnChtd2grWo/x/A==}++ resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}++ resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}+ engines: {node: '>=0.10.0'}++ resolution: {integrity: sha512-M9eUSMT2dCB2cTNPG7UYj6KuK7RJR2SN2+yCV/fTW3xzTCS6EaGZ5pSMgDIjB7r8zSfTGk+dvvn9rTjpVS9Mwg==}++ resolution: {integrity: sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==}+ engines: {node: '>=18'}++ resolution: {integrity: sha512-OboTd8mmMhZDNPV+UjQcK9yKAatXu2aJ+r1w4im1Otd4M4fl2hwvdoXUxIYHFTHWK/3y3FarBP70v3vwmGlOxw==}++ resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}+ engines: {node: '>=6'}++ resolution: {integrity: sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==}+ engines: {node: '>=14.16'}+resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}+ resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}++ resolution: {integrity: sha512-I8yFsfRzmzK0WV1pNNOA4A7y4RDfFxPRxb3t+e3ui14qSGOxGtiSP6GjeX+Y6CHb7HYaFj7ECUD7VE5kQMZWGQ==}+ engines: {node: '>=18', npm: '>=9'}+resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}engines: {node: '>=14.17'}hasBin: true+ resolution: {integrity: sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==}+ engines: {node: '>=18'}++ resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}++ resolution: {integrity: sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==}+ engines: {node: '>=20.18.1'}+resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}hasBin: truepeerDependencies:browserslist: '>= 4.21.0'+ resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}+resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}engines: {node: ^18.0.0 || >=20.0.0}@@ -877,9 +1167,21 @@ packages:resolution: {integrity: sha512-HjYc14IQUwDcnGICuc8tVtqAd6EFpoAQMqgrqcNtWWZB+F1b7iTq44GzwM1qvnH4upFgbhJsaNHuK93NOFheSg==}+ resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}++ resolution: {integrity: sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==}+ engines: {node: '>=16.0.0'}+resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}+ resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}+ engines: {node: '>= 14.6'}+ hasBin: true+snapshots:'@babel/[email protected]':@@ -1031,6 +1333,16 @@ snapshots:'@biomejs/[email protected]':optional: true+ '@borewit/[email protected]': {}++ '@cloudscape-design/[email protected](@cloudscape-design/[email protected]([email protected]([email protected]))([email protected]))([email protected])':+ dependencies:+ '@cloudscape-design/component-toolkit': 1.0.0-beta.159([email protected])+ '@cloudscape-design/components': 3.0.1292([email protected]([email protected]))([email protected])+ '@cloudscape-design/test-utils-core': 1.0.81+ clsx: 1.2.1+ react: 18.3.1+'@cloudscape-design/[email protected]([email protected])':dependencies:'@cloudscape-design/component-toolkit': 1.0.0-beta.159([email protected])@@ -1197,6 +1509,24 @@ snapshots:dependencies:tslib: 2.8.1+ '@jitl/[email protected]': {}++ '@jitl/[email protected]':+ dependencies:+ '@jitl/quickjs-ffi-types': 0.32.0++ '@jitl/[email protected]':+ dependencies:+ '@jitl/quickjs-ffi-types': 0.32.0++ '@jitl/[email protected]':+ dependencies:+ '@jitl/quickjs-ffi-types': 0.32.0++ '@jitl/[email protected]':+ dependencies:+ '@jitl/quickjs-ffi-types': 0.32.0+'@jridgewell/[email protected]':dependencies:'@jridgewell/sourcemap-codec': 1.5.5@@ -1218,6 +1548,16 @@ snapshots:'@material/[email protected]': {}+ '@mixmark-io/[email protected]': {}++ '@mongodb-js/[email protected]':+ dependencies:+ node-addon-api: 8.9.1+ prebuild-install: 7.1.3+ optional: true++ '@nodable/[email protected]': {}+'@novnc/[email protected](patch_hash=c119c00d14c51f940f1ebed4fe41ad2fe1358c63e1095baa39d11d696b66dbff)': {}'@playwright/[email protected]':@@ -1303,6 +1643,15 @@ snapshots:'@rollup/[email protected]':optional: true+ '@tokenizer/[email protected]':+ dependencies:+ debug: 4.4.3+ token-types: 6.1.2+ transitivePeerDependencies:+ - supports-color++ '@tokenizer/[email protected]': {}+'@types/[email protected]':dependencies:'@babel/parser': 7.29.3@@ -1326,6 +1675,10 @@ snapshots:'@types/[email protected]': {}+ '@types/[email protected]':+ dependencies:+ undici-types: 6.21.0+'@types/[email protected]': {}'@types/[email protected](@types/[email protected])':@@ -1339,7 +1692,7 @@ snapshots:'@ubjs/[email protected]': {}- '@vitejs/[email protected]([email protected])':dependencies:'@babel/core': 7.29.0'@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/[email protected])@@ -1347,7 +1700,7 @@ snapshots:'@rolldown/pluginutils': 1.0.0-beta.27'@types/babel__core': 7.20.5react-refresh: 0.17.0- vite: 5.4.21+ vite: 5.4.21(@types/[email protected])transitivePeerDependencies:- supports-color@@ -1357,8 +1710,26 @@ snapshots:dependencies:entities: 2.2.0+ [email protected]: {}++ [email protected]: {}++ optional: true++ dependencies:+ buffer: 5.7.1+ inherits: 2.0.4+ readable-stream: 3.6.2+ optional: true++ dependencies:+ balanced-match: 4.0.4+dependencies:baseline-browser-mapping: 2.10.28@@ -1367,10 +1738,21 @@ snapshots:node-releases: 2.0.38update-browserslist-db: 1.2.3([email protected])+ dependencies:+ base64-js: 1.5.1+ ieee754: 1.2.1+ optional: true++ optional: true++ [email protected]: {}+@@ -1400,6 +1782,19 @@ snapshots:+ dependencies:+ mimic-response: 3.1.0+ optional: true++ optional: true++ optional: true++ [email protected]: {}+dependencies:'@babel/runtime': 7.29.2@@ -1407,6 +1802,11 @@ snapshots:+ dependencies:+ once: 1.4.0+ optional: true+@@ -1437,8 +1837,37 @@ snapshots:+ optional: true++ dependencies:+ path-expression-matcher: 1.6.2+ xml-naming: 0.3.0++ dependencies:+ '@nodable/entities': 3.0.0+ fast-xml-builder: 1.3.0+ is-unsafe: 2.0.0+ path-expression-matcher: 1.6.2+ strnum: 2.4.1+ xml-naming: 0.3.0++ dependencies:+ '@tokenizer/inflate': 0.4.1+ strtok3: 10.3.5+ token-types: 6.1.2+ uint8array-extras: 1.5.0+ transitivePeerDependencies:+ - supports-color++ optional: true+optional: true@@ -1447,6 +1876,19 @@ snapshots:+ optional: true++ [email protected]: {}++ optional: true++ optional: true++ [email protected]: {}+dependencies:'@formatjs/ecma402-abstract': 2.3.6@@ -1454,6 +1896,8 @@ snapshots:'@formatjs/icu-messageformat-parser': 2.11.4tslib: 2.8.1+ [email protected]: {}+@@ -1462,6 +1906,30 @@ snapshots:+ dependencies:+ diff: 8.0.4+ fast-xml-parser: 5.10.1+ file-type: 21.3.4+ ini: 6.0.0+ minimatch: 10.2.6+ modern-tar: 0.7.7+ papaparse: 5.5.4+ quickjs-emscripten: 0.32.0+ re2js: 1.3.3+ seek-bzip: 2.0.0+ smol-toml: 1.8.0+ sprintf-js: 1.1.3+ sql.js: 1.14.1+ turndown: 7.2.4+ undici: 7.29.0+ yaml: 2.9.0+ optionalDependencies:+ '@mongodb-js/zstd': 7.0.0+ node-liblzma: 2.2.0+ transitivePeerDependencies:+ - supports-color+@@ -1477,18 +1945,62 @@ snapshots:dependencies:yallist: 3.1.1+ optional: true++ dependencies:+ brace-expansion: 5.0.9++ optional: true++ optional: true+dependencies:'@babel/runtime': 7.29.2+ [email protected]: {}++ optional: true++ dependencies:+ semver: 7.8.5+ optional: true++ optional: true++ optional: true++ dependencies:+ node-addon-api: 8.9.1+ node-gyp-build: 4.8.4+ optional: true++ dependencies:+ wrappy: 1.0.2+ optional: true++ [email protected]: {}++ [email protected]: {}+@@ -1505,12 +2017,56 @@ snapshots:picocolors: 1.1.1source-map-js: 1.2.1+ dependencies:+ detect-libc: 2.1.2+ expand-template: 2.0.3+ github-from-package: 0.0.0+ minimist: 1.2.8+ mkdirp-classic: 0.5.3+ napi-build-utils: 2.0.0+ node-abi: 3.94.0+ pump: 3.0.4+ rc: 1.2.8+ simple-get: 4.0.1+ tar-fs: 2.1.5+ tunnel-agent: 0.6.0+ optional: true+dependencies:loose-envify: 1.4.0object-assign: 4.1.1react-is: 16.13.1+ dependencies:+ end-of-stream: 1.4.5+ once: 1.4.0+ optional: true++ dependencies:+ '@jitl/quickjs-ffi-types': 0.32.0++ dependencies:+ '@jitl/quickjs-wasmfile-debug-asyncify': 0.32.0+ '@jitl/quickjs-wasmfile-debug-sync': 0.32.0+ '@jitl/quickjs-wasmfile-release-asyncify': 0.32.0+ '@jitl/quickjs-wasmfile-release-sync': 0.32.0+ quickjs-emscripten-core: 0.32.0++ dependencies:+ deep-extend: 0.6.0+ ini: 1.3.8+ minimist: 1.2.8+ strip-json-comments: 2.0.1+ optional: true++ [email protected]: {}+dependencies:loose-envify: 1.4.0@@ -1548,6 +2104,13 @@ snapshots:dependencies:loose-envify: 1.4.0+ dependencies:+ inherits: 2.0.4+ string_decoder: 1.3.0+ util-deprecate: 1.0.2+ optional: true+dependencies:'@types/estree': 1.0.8@@ -1579,34 +2142,125 @@ snapshots:'@rollup/rollup-win32-x64-msvc': 4.60.3fsevents: 2.3.3+ optional: true+dependencies:loose-envify: 1.4.0+ dependencies:+ commander: 6.2.1++ optional: true++ optional: true++ dependencies:+ decompress-response: 6.0.0+ once: 1.4.0+ simple-concat: 1.0.1+ optional: true++ [email protected]: {}++ [email protected]: {}++ [email protected]: {}++ dependencies:+ safe-buffer: 5.2.1+ optional: true++ optional: true++ dependencies:+ anynum: 1.0.1++ dependencies:+ '@tokenizer/token': 0.3.0++ dependencies:+ chownr: 1.1.4+ mkdirp-classic: 0.5.3+ pump: 3.0.4+ tar-stream: 2.2.0+ optional: true++ dependencies:+ bl: 4.1.0+ end-of-stream: 1.4.5+ fs-constants: 1.0.0+ inherits: 2.0.4+ readable-stream: 3.6.2+ optional: true++ dependencies:+ '@borewit/text-codec': 0.2.2+ '@tokenizer/token': 0.3.0+ ieee754: 1.2.1++ dependencies:+ safe-buffer: 5.2.1+ optional: true++ dependencies:+ '@mixmark-io/domino': 2.2.0++ [email protected]: {}++ [email protected]: {}++ [email protected]: {}+dependencies:browserslist: 4.28.2escalade: 3.2.0picocolors: 1.1.1+ optional: true++ [email protected](@types/[email protected]):dependencies:esbuild: 0.21.5postcss: 8.5.14rollup: 4.60.3optionalDependencies:+ '@types/node': 22.20.1fsevents: 2.3.3+ optional: true++ [email protected]: {}+++ [email protected]: {}diff --git a/libs/fleet/src/App.tsx b/libs/fleet/src/App.tsxindex 0ca1904df5..5bee18e111 100644--- a/libs/fleet/src/App.tsx+++ b/libs/fleet/src/App.tsx@@ -21,7 +21,8 @@ import { PoolDetail } from "./pages/PoolDetail"import { PoolNew } from "./pages/PoolNew"import { UserApiKeys } from "./pages/UserApiKeys"import { Settings } from "./pages/Settings"-import { FeatureFlagProvider } from "./components/FeatureFlagContext"+import { AgentChat } from "./pages/AgentChat"+import { FeatureFlagProvider, useFeatureFlags } from "./components/FeatureFlagContext"import { FlashContext, type FlashMsg } from "./components/FlashContext"import { logout, userInfo } from "./auth/keycloak"@@ -80,6 +81,7 @@ function Shell() {const { stale } = useStaleCheck()const [staleDismissed, setStaleDismissed] = useState(false)const user = userInfo()+ const { chat } = useFeatureFlags()const pushFlash = useCallback((msg: FlashMsg) => {const id = crypto.randomUUID()const dismiss = () =>@@ -140,6 +142,7 @@ function Shell() {}}items={[{ type: "link", text: "Pools", href: "#/pools" },+ ...(chat ? [{ type: "link" as const, text: "Chat", href: "#/agent" }] : []),{ type: "link", text: "User API keys", href: "#/user-keys" },{ type: "link", text: "Settings", href: "#/settings" },]}@@ -194,6 +197,7 @@ export function App() {<Route path="/pools/:namespace/:name" element={<PoolDetail />} /><Route path="/user-keys" element={<UserApiKeys />} /><Route path="/settings" element={<Settings />} />+ <Route path="/agent" element={<ChatRoute />} /><Route path="/billing" element={<Navigate to="/settings" replace />} /><Routepath="/pools/:namespace/:poolName/claims/:claimName"@@ -217,3 +221,9 @@ function RedirectModule() {const path = window.location.pathname.replace(/^\/modules/, "/pools")return <Navigate to={path} replace />}++function ChatRoute() {+ const { chat, resolved } = useFeatureFlags()+ if (!resolved) return null+ return chat ? <AgentChat /> : <Navigate to="/pools" replace />+}diff --git a/libs/fleet/src/browser-agent.ts b/libs/fleet/src/browser-agent.tsnew file mode 100644index 0000000000..a6b0b553a0--- /dev/null+++ b/libs/fleet/src/browser-agent.ts@@ -0,0 +1,218 @@+import { Bash } from "just-bash/browser"++export const BASH_TIMEOUT = { min: 250, default: 10_000, max: 60_000 } as const+export const BASH_OUTPUT = { min: 256, default: 20_000, max: 100_000 } as const++export interface BashToolArguments {+ command: string+ timeout_ms?: number+ max_output_chars?: number+}++export interface NormalizedBashArguments {+ command: string+ timeout_ms: number+ max_output_chars: number+}++export interface BashToolResult {+ stdout: string+ stderr: string+ exit_code: number+ timed_out: boolean+ truncated: boolean+}++export interface ToolCall {+ id: string+ type: "function"+ function: { name: string; arguments: string }+}++export interface ClientMessage {+ role: "user" | "tool"+ content: string+ tool_call_id?: string+}++export interface AssistantMessage {+ role: "assistant"+ content: string+ tool_calls: ToolCall[]+}++export type TurnClient = (+ conversationID: string,+ messages: ClientMessage[],+ signal?: AbortSignal,+ onDelta?: (delta: string) => void,+) => Promise<AssistantMessage>++export type AgentEvent =+ | { type: "generation_start" }+ | { type: "assistant_delta"; delta: string }+ | { type: "tool_start"; toolCall: ToolCall; arguments: NormalizedBashArguments }+ | { type: "tool_result"; toolCall: ToolCall; arguments: NormalizedBashArguments; result: BashToolResult }+ | { type: "complete"; message: AssistantMessage }++export function normalizeBashArguments(input: BashToolArguments): NormalizedBashArguments {+ if (!input || typeof input.command !== "string" || input.command.trim() === "") {+ throw new Error("bash.command must be a non-empty string")+ }+ const clamp = (value: number | undefined, bounds: typeof BASH_TIMEOUT | typeof BASH_OUTPUT) =>+ Math.min(bounds.max, Math.max(bounds.min, Number.isFinite(value) ? Math.trunc(value!) : bounds.default))+ return {+ command: input.command,+ timeout_ms: clamp(input.timeout_ms, BASH_TIMEOUT),+ max_output_chars: clamp(input.max_output_chars, BASH_OUTPUT),+ }+}++function abortError(): DOMException {+ return new DOMException("The operation was aborted", "AbortError")+}++export function sanitizeError(error: unknown): string {+ const message = error instanceof Error ? error.message : "Bash execution failed"+ const sanitized = Array.from(message, character => {+ const codePoint = character.codePointAt(0) ?? 0+ return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f) ? " " : character+ })+ .join("")+ .trim()+ return sanitized || "Bash execution failed"+}++function capOutput(stdout: string, stderr: string, maxOutputChars: number): Pick<BashToolResult, "stdout" | "stderr" | "truncated"> {+ const truncated = stdout.length + stderr.length > maxOutputChars+ const cappedStdout = stdout.slice(0, maxOutputChars)+ const remaining = Math.max(0, maxOutputChars - cappedStdout.length)+ return { stdout: cappedStdout, stderr: stderr.slice(0, remaining), truncated }+}++export class BrowserBashAgent {+ private readonly shells = new Map<string, Bash>()+ private readonly client: TurnClient++ constructor(client: TurnClient) {+ this.client = client+ }++ async executeBash(conversationID: string, input: BashToolArguments, signal?: AbortSignal): Promise<BashToolResult> {+ const arguments_ = normalizeBashArguments(input)+ if (signal?.aborted) {+ throw abortError()+ }++ const timeoutController = new AbortController()+ const linkedController = new AbortController()+ let timedOut = false+ const abortLinked = () => linkedController.abort()+ const abortOnTimeout = () => {+ timedOut = true+ timeoutController.abort()+ linkedController.abort()+ }+ const timeout = setTimeout(abortOnTimeout, arguments_.timeout_ms)+ signal?.addEventListener("abort", abortLinked, { once: true })+ timeoutController.signal.addEventListener("abort", abortLinked, { once: true })++ try {+ const shell = this.getShell(conversationID)+ const result = await shell.exec(arguments_.command, { signal: linkedController.signal })+ if (signal?.aborted) {+ throw abortError()+ }+ if (timedOut) {+ return this.withOutputLimit({ stdout: result.stdout, stderr: result.stderr, exit_code: 124, timed_out: true }, input, arguments_)+ }+ return this.withOutputLimit(+ { stdout: result.stdout, stderr: result.stderr, exit_code: result.exitCode, timed_out: false },+ input,+ arguments_,+ )+ } catch (error) {+ if (signal?.aborted) {+ throw abortError()+ }+ if (timedOut) {+ return this.withOutputLimit({ stdout: "", stderr: "", exit_code: 124, timed_out: true }, input, arguments_)+ }+ return this.withOutputLimit({ stdout: "", stderr: sanitizeError(error), exit_code: 1, timed_out: false }, input, arguments_)+ } finally {+ clearTimeout(timeout)+ signal?.removeEventListener("abort", abortLinked)+ timeoutController.signal.removeEventListener("abort", abortLinked)+ }+ }++ async run(+ conversationID: string,+ messages: ClientMessage[],+ onEvent: (event: AgentEvent) => void,+ signal?: AbortSignal,+ ): Promise<void> {+ let turnMessages = messages+ for (;;) {+ if (signal?.aborted) {+ throw abortError()+ }+ onEvent({ type: "generation_start" })+ const message = await this.client(conversationID, turnMessages, signal, delta => {+ onEvent({ type: "assistant_delta", delta })+ })+ if (signal?.aborted) {+ throw abortError()+ }+ if (message.tool_calls.length === 0) {+ onEvent({ type: "complete", message })+ return+ }++ const calls = message.tool_calls.map(toolCall => {+ if (toolCall.function.name !== "bash") {+ throw new Error(`Unsupported tool: ${toolCall.function.name}`)+ }+ return {+ toolCall,+ arguments: normalizeBashArguments(JSON.parse(toolCall.function.arguments) as BashToolArguments),+ }+ })+ const results = await Promise.all(+ calls.map(async ({ toolCall, arguments: arguments_ }) => {+ onEvent({ type: "tool_start", toolCall, arguments: arguments_ })+ const result = await this.executeBash(conversationID, arguments_, signal)+ onEvent({ type: "tool_result", toolCall, arguments: arguments_, result })+ return { toolCall, result }+ }),+ )+ turnMessages = results.map(({ toolCall, result }) => ({+ role: "tool",+ tool_call_id: toolCall.id,+ content: JSON.stringify(result),+ }))+ }+ }++ private getShell(conversationID: string): Bash {+ let shell = this.shells.get(conversationID)+ if (!shell) {+ shell = new Bash({ executionLimitProfile: "hardened" })+ this.shells.set(conversationID, shell)+ }+ return shell+ }++ private withOutputLimit(+ result: Omit<BashToolResult, "truncated">,+ input: BashToolArguments,+ arguments_: NormalizedBashArguments,+ ): BashToolResult {+ const requestedOutputLimit = input.max_output_chars+ const maxOutputChars =+ Number.isFinite(requestedOutputLimit) && requestedOutputLimit! > 0+ ? Math.min(BASH_OUTPUT.max, Math.trunc(requestedOutputLimit!))+ : arguments_.max_output_chars+ return { ...result, ...capOutput(result.stdout, result.stderr, maxOutputChars) }+ }+}diff --git a/libs/fleet/src/components/FeatureFlagContext.tsx b/libs/fleet/src/components/FeatureFlagContext.tsxindex 0ae95a159c..4d9e86f973 100644--- a/libs/fleet/src/components/FeatureFlagContext.tsx+++ b/libs/fleet/src/components/FeatureFlagContext.tsx@@ -1,7 +1,7 @@import { createContext, useContext, useEffect, useState, type ReactNode } from "react"import { fetchFeatureFlags, type FeatureFlags } from "../sdk/featureFlags"-const DEFAULT_FLAGS: FeatureFlags = { admin: false, billing: false }+const DEFAULT_FLAGS: FeatureFlags = { admin: false, billing: false, chat: false }interface FeatureFlagContextValue extends FeatureFlags {resolved: booleandiff --git a/libs/fleet/src/node-zlib-browser.ts b/libs/fleet/src/node-zlib-browser.tsnew file mode 100644index 0000000000..4c29e9d17e--- /dev/null+++ b/libs/fleet/src/node-zlib-browser.ts@@ -0,0 +1,14 @@+const unsupportedMessage = "gzip commands are unsupported in the browser"++export const constants = {+ Z_BEST_COMPRESSION: 9,+ Z_BEST_SPEED: 1,+ Z_DEFAULT_COMPRESSION: -1,+} as const++function unsupported(_input: Uint8Array, _options?: unknown): never {+ throw new Error(unsupportedMessage)+}++export const gzipSync = unsupported+export const gunzipSync = unsupporteddiff --git a/libs/fleet/src/pages/AgentChat.css b/libs/fleet/src/pages/AgentChat.cssnew file mode 100644index 0000000000..422a938118--- /dev/null+++ b/libs/fleet/src/pages/AgentChat.css@@ -0,0 +1,163 @@+.agent-chat-page {+ display: grid;+ gap: 24px;+ grid-template-columns: minmax(230px, 300px) minmax(0, 1fr);+ height: calc(100vh - 160px);+ min-height: 560px;+}++.agent-chat-history {+ border-inline-end: 1px solid var(--color-border-divider-default, #d5dbdb);+ min-width: 0;+ overflow-y: auto;+ padding-inline-end: 20px;+}++.agent-chat-main {+ display: grid;+ grid-template-rows: minmax(0, 1fr) auto;+ min-height: 0;+ min-width: 0;+}++.agent-chat-transcript {+ min-height: 0;+ overflow-y: auto;+ padding: 8px 8px 128px;+}++.agent-chat-empty {+ display: grid;+ gap: 12px;+ margin: 72px auto;+ max-width: 520px;+ text-align: center;+}++.agent-chat-composer {+ background: var(--color-background-layout-main, #fff);+ border-top: 1px solid var(--color-border-divider-default, #d5dbdb);+ bottom: 0;+ padding: 16px 0 8px;+ position: sticky;+ z-index: 1;+}++.agent-chat-timestamp {+ color: var(--color-text-body-secondary, #5f6b7a);+ font-size: 0.75rem;+}++.agent-chat-skeleton {+ animation: agent-chat-shimmer 1.4s ease-in-out infinite;+ background: linear-gradient(+ 90deg,+ var(--color-background-layout-toggle-default, #eaeded) 25%,+ var(--color-background-layout-toggle-hover, #f2f3f3) 50%,+ var(--color-background-layout-toggle-default, #eaeded) 75%+ );+ background-size: 200% 100%;+ border-radius: 8px;+}++.agent-chat-skeleton--conversation {+ height: 48px;+ width: 100%;+}++.agent-chat-skeleton--message {+ height: 88px;+ max-width: 78%;+}++.agent-chat-skeleton--message:nth-child(even) {+ margin-inline-start: auto;+}++.agent-chat-mobile-history {+ display: none;+}++@keyframes agent-chat-shimmer {+ 0% {+ background-position: 100% 0;+ }+ 100% {+ background-position: -100% 0;+ }+}++@media (max-width: 700px) {+ .agent-chat-page {+ display: block;+ height: calc(100vh - 120px);+ min-height: 480px;+ }++ .agent-chat-history {+ display: none;+ }++ .agent-chat-mobile-history {+ display: block;+ padding-bottom: 12px;+ }++ .agent-chat-transcript {+ padding-inline: 0;+ }++ .agent-chat-empty {+ margin: 48px 16px;+ text-align: left;+ }++ .agent-chat-skeleton--message {+ max-width: 90%;+ }+}++.agent-chat-mobile-overlay {+ align-items: stretch;+ background: rgb(0 0 0 / 45%);+ display: flex;+ inset: 0;+ position: fixed;+ z-index: 1000;+}++.agent-chat-mobile-backdrop {+ background: transparent;+ border: 0;+ cursor: default;+ inset: 0;+ padding: 0;+ position: absolute;+}++.agent-chat-mobile-drawer {+ position: relative;+ z-index: 1;+ background: var(--color-background-layout-main, #fff);+ box-shadow: 2px 0 12px rgb(0 0 0 / 25%);+ max-width: min(360px, 92vw);+ min-width: min(320px, 92vw);+ overflow-y: auto;+}++@media (prefers-reduced-motion: reduce) {+ .agent-chat-skeleton {+ animation: none;+ }+}++.agent-chat-command {+ border-inline-start: 3px solid var(--color-border-status-info, #3184c2);+ margin-inline: 16px;+ padding: 8px 12px;+}++.agent-chat-prompt {+ flex: 1;+ min-width: 0;+}diff --git a/libs/fleet/src/pages/AgentChat.tsx b/libs/fleet/src/pages/AgentChat.tsxnew file mode 100644index 0000000000..39d1edefab--- /dev/null+++ b/libs/fleet/src/pages/AgentChat.tsx@@ -0,0 +1,558 @@+import { useEffect, useMemo, useRef, useState } from "react"+import { createPortal } from "react-dom"+import Avatar from "@cloudscape-design/chat-components/avatar"+import ChatBubble from "@cloudscape-design/chat-components/chat-bubble"+import Alert from "@cloudscape-design/components/alert"+import Box from "@cloudscape-design/components/box"+import Button, { type ButtonProps } from "@cloudscape-design/components/button"+import Drawer from "@cloudscape-design/components/drawer"+import ExpandableSection from "@cloudscape-design/components/expandable-section"+import Header from "@cloudscape-design/components/header"+import List from "@cloudscape-design/components/list"+import LiveRegion from "@cloudscape-design/components/live-region"+import PromptInput from "@cloudscape-design/components/prompt-input"+import SpaceBetween from "@cloudscape-design/components/space-between"+import StatusIndicator from "@cloudscape-design/components/status-indicator"+import {+ createConversation,+ getConversation,+ listConversations,+ streamTurn,+ type ChatMessage,+ type ChatToolCall,+ type Conversation,+ type ConversationSummary,+} from "../sdk/chat"+import {+ BrowserBashAgent,+ type BashToolResult,+ type ClientMessage,+ type NormalizedBashArguments,+ type ToolCall,+} from "../browser-agent"+import "./AgentChat.css"++export interface ConversationGroup {+ label: string+ conversations: ConversationSummary[]+}++interface CommandStep {+ id: string+ arguments: NormalizedBashArguments+ result?: BashToolResult+ running?: boolean+}++type TranscriptItem = { type: "message"; message: ChatMessage } | { type: "command"; command: CommandStep }++export function groupConversations(now: Date, summaries: ConversationSummary[]): ConversationGroup[] {+ const startOfToday = new Date(now)+ startOfToday.setHours(0, 0, 0, 0)+ const groups = new Map<string, ConversationSummary[]>()++ for (const summary of summaries) {+ const updatedAt = new Date(summary.updated_at)+ const startOfDate = new Date(updatedAt)+ startOfDate.setHours(0, 0, 0, 0)+ const daysAgo = Math.round((startOfToday.getTime() - startOfDate.getTime()) / 86_400_000)+ const label =+ daysAgo === 0+ ? "Today"+ : daysAgo === 1+ ? "Yesterday"+ : daysAgo >= 2 && daysAgo <= 7+ ? "Past 7 days"+ : updatedAt.toLocaleDateString(undefined, { year: "numeric", month: "long", day: "numeric" })+ const group = groups.get(label) ?? []+ group.push(summary)+ groups.set(label, group)+ }++ return [...groups].map(([label, conversations]) => ({ label, conversations }))+}++const MOBILE_HISTORY_QUERY = "(max-width: 700px)"+const GENERATION_LOADING_DELAY_MS = 300++function useMobileHistory(): boolean {+ const [mobile, setMobile] = useState(() => window.matchMedia(MOBILE_HISTORY_QUERY).matches)++ useEffect(() => {+ const mediaQuery = window.matchMedia(MOBILE_HISTORY_QUERY)+ const update = () => setMobile(mediaQuery.matches)+ update()+ mediaQuery.addEventListener("change", update)+ return () => mediaQuery.removeEventListener("change", update)+ }, [])++ return mobile+}++function Skeleton({ kind }: { kind: "conversation" | "message" }) {+ return <div aria-hidden="true" className={`agent-chat-skeleton agent-chat-skeleton--${kind}`} data-testid={`${kind}-skeleton`} />+}++function formatTime(timestamp?: string): { full: string; local: string } {+ if (!timestamp) return { full: "Unknown time", local: "Unknown time" }+ const date = new Date(timestamp)+ return { full: date.toLocaleString(), local: date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" }) }+}++function parseStoredResult(content: string): BashToolResult | undefined {+ try {+ const value = JSON.parse(content) as Partial<BashToolResult>+ if (+ typeof value.stdout !== "string" ||+ typeof value.stderr !== "string" ||+ typeof value.exit_code !== "number" ||+ typeof value.timed_out !== "boolean" ||+ typeof value.truncated !== "boolean"+ ) {+ return undefined+ }+ return value as BashToolResult+ } catch {+ return undefined+ }+}++function parseStoredCommand(toolCall: ChatToolCall, messages: ChatMessage[], index: number): CommandStep | undefined {+ if (toolCall.function.name !== "bash") return undefined+ try {+ const value = JSON.parse(toolCall.function.arguments) as NormalizedBashArguments+ if (typeof value.command !== "string" || !value.command.trim()) return undefined+ const toolMessage = messages.slice(index + 1).find(message => message.role === "tool" && message.tool_call_id === toolCall.id)+ return {+ id: toolCall.id,+ arguments: {+ command: value.command,+ timeout_ms: typeof value.timeout_ms === "number" ? value.timeout_ms : 10_000,+ max_output_chars: typeof value.max_output_chars === "number" ? value.max_output_chars : 20_000,+ },+ result: toolMessage ? parseStoredResult(toolMessage.content) : undefined,+ }+ } catch {+ return undefined+ }+}++function reconstructTranscript(messages: ChatMessage[]): TranscriptItem[] {+ return messages.flatMap((message, index) => {+ if (message.role === "tool") return []+ const items: TranscriptItem[] = []+ if (!(message.role === "assistant" && message.tool_calls?.length && !message.content.trim())) {+ items.push({ type: "message", message })+ }+ if (message.role === "assistant") {+ for (const toolCall of message.tool_calls ?? []) {+ const command = parseStoredCommand(toolCall, messages, index)+ if (command) items.push({ type: "command", command })+ }+ }+ return items+ })+}++function ConversationHistory({ conversations, loading, onSelect, disabled = false, showHeading = true }: { conversations: ConversationSummary[]; loading: boolean; onSelect: (id: string) => void; disabled?: boolean; showHeading?: boolean }) {+ const groups = useMemo(() => groupConversations(new Date(), conversations), [conversations])+ return (+ <SpaceBetween size="m">+ {showHeading && <Header variant="h2" counter={loading ? undefined : `(${conversations.length})`}>Conversations</Header>}+ {loading ? <SpaceBetween size="s"><Skeleton kind="conversation" /><Skeleton kind="conversation" /><Skeleton kind="conversation" /></SpaceBetween> : groups.length === 0 ? <Box color="text-body-secondary">No conversations yet.</Box> : (+ <SpaceBetween size="l">+ {groups.map(group => (+ <section aria-label={group.label} key={group.label}>+ <Box fontWeight="bold" padding={{ bottom: "xs" }}>{group.label}</Box>+ <List ariaLabel={`${group.label} conversations`} items={group.conversations} renderItem={conversation => {+ const timestamp = formatTime(conversation.updated_at)+ return {+ id: conversation.id,+ content: <Button disabled={disabled} disabledReason="Wait for the current turn to finish." onClick={() => onSelect(conversation.id)} variant="inline-link">{conversation.title || "Untitled conversation"}</Button>,+ secondaryContent: <span className="agent-chat-timestamp" title={new Date(conversation.updated_at).toLocaleString()}>{timestamp.local}</span>,+ }+ }} />+ </section>+ ))}+ </SpaceBetween>+ )}+ </SpaceBetween>+ )+}++function MessageBubble({ message, position, loading = false }: { message: ChatMessage; position: number; loading?: boolean }) {+ const incoming = message.role !== "user"+ const author = incoming ? "Assistant" : "You"+ const time = formatTime(message.created_at)+ return (+ <ChatBubble ariaLabel={`${author} at ${time.full}, message ${position}`} avatar={incoming ? <Avatar ariaLabel="Assistant avatar" color="gen-ai" iconName="gen-ai" loading={loading} /> : <Avatar ariaLabel="Your avatar" initials="You" />} type={incoming ? "incoming" : "outgoing"}>+ <SpaceBetween size="xxs">+ <div>{loading && !message.content ? "Generating a response" : message.content}</div>+ {!loading && <span className="agent-chat-timestamp" title={time.full}>{author} - {time.local}</span>}+ </SpaceBetween>+ </ChatBubble>+ )+}++function CommandStatus({ command }: { command: CommandStep }) {+ const { result } = command+ const running = command.running ?? !result+ const statusText = running ? "Running command" : result?.timed_out ? "Command timed out" : result?.exit_code === 0 ? "Command completed" : "Command failed"+ const statusType = running ? "in-progress" : result?.timed_out ? "warning" : result?.exit_code === 0 ? "success" : "error"+ return (+ <div className="agent-chat-command">+ <StatusIndicator type={statusType}>{statusText}</StatusIndicator>+ <ExpandableSection headerAriaLabel="Command details" headerText="Command details" variant="inline">+ <SpaceBetween size="xs">+ <Box variant="code">{command.arguments.command}</Box>+ {result && <>+ {result.stdout && <Box variant="code">{result.stdout}</Box>}+ {result.stderr && <Box variant="code">{result.stderr}</Box>}+ {result.truncated && <Box color="text-status-warning">Output was truncated</Box>}+ </>}+ </SpaceBetween>+ </ExpandableSection>+ </div>+ )+}++function isAbort(error: unknown): boolean {+ return error instanceof DOMException && error.name === "AbortError"+}++export function AgentChat() {+ const [conversations, setConversations] = useState<ConversationSummary[]>([])+ const [listLoading, setListLoading] = useState(true)+ const [selectedId, setSelectedId] = useState<string>()+ const [selectedConversation, setSelectedConversation] = useState<Conversation>()+ const [conversationLoading, setConversationLoading] = useState(false)+ const [historyOpen, setHistoryOpen] = useState(false)+ const [draft, setDraft] = useState("")+ const [liveItems, setLiveItems] = useState<TranscriptItem[]>([])+ const [liveAssistant, setLiveAssistant] = useState<ChatMessage>()+ const [assistantLoading, setAssistantLoading] = useState(false)+ const [running, setRunning] = useState(false)+ const [abortable, setAbortable] = useState(false)+ const [turnError, setTurnError] = useState<string>()+ const [refreshError, setRefreshError] = useState<string>()+ const [initialCreatePrompt, setInitialCreatePrompt] = useState<string>()+ const mobileHistory = useMobileHistory()+ const triggerRef = useRef<ButtonProps.Ref>(null)+ const closeButtonRef = useRef<ButtonProps.Ref>(null)+ const dialogRef = useRef<HTMLDivElement>(null)+ const transcriptRef = useRef<HTMLElement>(null)+ const wasHistoryOpenRef = useRef(false)+ const agentRef = useRef<BrowserBashAgent>()+ const abortControllerRef = useRef<AbortController>()+ const loadingTimerRef = useRef<number>()+ const ignoreNextConversationLoadRef = useRef(false)+ const nextRunIdRef = useRef(0)+ const activeRunIdRef = useRef<number>()+ const activeRunConversationIdRef = useRef<string>()+ const selectedConversationIdRef = useRef<string>()+ const loadingRunIdRef = useRef<number>()++ if (!agentRef.current) {+ agentRef.current = new BrowserBashAgent(async (conversationID, messages, signal, onDelta) => {+ const message = await streamTurn(conversationID, messages, onDelta ?? (() => undefined), signal)+ return {+ role: "assistant",+ content: message.content,+ tool_calls: (message.tool_calls ?? []).filter((toolCall): toolCall is ToolCall => toolCall.type === "function"),+ }+ })+ }++ const ownsRun = (runId: number, conversationID: string) =>+ activeRunIdRef.current === runId &&+ activeRunConversationIdRef.current === conversationID &&+ selectedConversationIdRef.current === conversationID++ const ownsUnboundRun = (runId: number) =>+ activeRunIdRef.current === runId && activeRunConversationIdRef.current === undefined++ const ownsLifecycle = (runId: number, conversationID?: string) =>+ conversationID === undefined ? ownsUnboundRun(runId) : ownsRun(runId, conversationID)++ const refresh = async (conversationID: string, runId?: number) => {+ const [conversation, summaries] = await Promise.all([getConversation(conversationID), listConversations()])+ if (runId !== undefined && !ownsRun(runId, conversationID)) return false+ setSelectedConversation(conversation)+ setConversations(summaries)+ setLiveItems([])+ setLiveAssistant(undefined)+ setRefreshError(undefined)+ return true+ }++ const recoverRefresh = async (conversationID: string) => {+ if (activeRunIdRef.current !== undefined || selectedConversationIdRef.current !== conversationID) return+ const runId = ++nextRunIdRef.current+ activeRunIdRef.current = runId+ activeRunConversationIdRef.current = conversationID+ setRunning(true)+ setRefreshError(undefined)+ try {+ await refresh(conversationID, runId)+ } catch (error) {+ if (ownsRun(runId, conversationID)) setRefreshError(error instanceof Error ? error.message : "Unable to refresh conversation")+ } finally {+ finishRun(runId, conversationID)+ }+ }++ useEffect(() => {+ let active = true+ void listConversations().then(items => { if (active) setConversations(items) }).catch(() => { if (active) setConversations([]) }).finally(() => { if (active) setListLoading(false) })+ return () => { active = false }+ }, [])++ useEffect(() => {+ selectedConversationIdRef.current = selectedId+ }, [selectedId])++ useEffect(() => {+ if (!selectedId) { setSelectedConversation(undefined); return }+ let active = true+ if (ignoreNextConversationLoadRef.current) {+ ignoreNextConversationLoadRef.current = false+ return+ }+ setConversationLoading(true)+ setSelectedConversation(undefined)+ setLiveItems([])+ setLiveAssistant(undefined)+ void getConversation(selectedId).then(conversation => { if (active && selectedConversationIdRef.current === selectedId) setSelectedConversation(conversation) }).catch(() => { if (active && selectedConversationIdRef.current === selectedId) setSelectedConversation(undefined) }).finally(() => { if (active && selectedConversationIdRef.current === selectedId) setConversationLoading(false) })+ return () => { active = false }+ }, [selectedId])++ useEffect(() => () => {+ abortControllerRef.current?.abort()+ if (loadingTimerRef.current) window.clearTimeout(loadingTimerRef.current)+ }, [])++ useEffect(() => {+ const appRoot = document.getElementById("root")+ if (appRoot) appRoot.inert = historyOpen+ if (historyOpen) {+ wasHistoryOpenRef.current = true+ closeButtonRef.current?.focus()+ return () => { if (appRoot) appRoot.inert = false }+ }+ if (wasHistoryOpenRef.current) { wasHistoryOpenRef.current = false; triggerRef.current?.focus() }+ }, [historyOpen])++ useEffect(() => { if (!mobileHistory) setHistoryOpen(false) }, [mobileHistory])++ useEffect(() => {+ const transcriptElement = transcriptRef.current+ const hasTranscriptUpdate = assistantLoading || Boolean(liveAssistant?.content) || liveItems.length > 0 || Boolean(selectedConversation)+ if (!transcriptElement || conversationLoading || !hasTranscriptUpdate) return+ transcriptElement.scrollTop = transcriptElement.scrollHeight+ }, [assistantLoading, conversationLoading, liveAssistant?.content, liveItems.length, selectedConversation])++ const clearLoading = (runId?: number, conversationID?: string) => {+ if (runId !== undefined && !ownsLifecycle(runId, conversationID)) return+ if (loadingTimerRef.current) window.clearTimeout(loadingTimerRef.current)+ loadingTimerRef.current = undefined+ loadingRunIdRef.current = undefined+ setAssistantLoading(false)+ }++ const finishAbortable = (runId: number, conversationID: string, controller: AbortController) => {+ if (!ownsRun(runId, conversationID)) return+ if (abortControllerRef.current === controller) abortControllerRef.current = undefined+ setAbortable(false)+ }++ const finishRun = (runId: number, conversationID?: string) => {+ if (!ownsLifecycle(runId, conversationID)) return+ clearLoading(runId, conversationID)+ abortControllerRef.current = undefined+ activeRunIdRef.current = undefined+ activeRunConversationIdRef.current = undefined+ setAbortable(false)+ setRunning(false)+ }++ const runAgent = async (runId: number, conversationID: string, messages: ClientMessage[]) => {+ const controller = new AbortController()+ let completedCommand = false+ abortControllerRef.current = controller+ setAbortable(true)+ try {+ await agentRef.current!.run(conversationID, messages, event => {+ if (!ownsRun(runId, conversationID)) return+ if (event.type === "generation_start") {+ clearLoading(runId, conversationID)+ loadingRunIdRef.current = runId+ loadingTimerRef.current = window.setTimeout(() => {+ if (ownsRun(runId, conversationID) && loadingRunIdRef.current === runId) setAssistantLoading(true)+ }, GENERATION_LOADING_DELAY_MS)+ } else if (event.type === "assistant_delta") {+ clearLoading(runId, conversationID)+ setLiveAssistant(current => ({ role: "assistant", content: `${current?.content ?? ""}${event.delta}`, created_at: new Date().toISOString() }))+ } else if (event.type === "tool_start") {+ clearLoading(runId, conversationID)+ setLiveItems(current => [...current, { type: "command", command: { id: event.toolCall.id, arguments: event.arguments, running: true } }])+ } else if (event.type === "tool_result") {+ setLiveItems(current => current.map(item => item.type === "command" && item.command.id === event.toolCall.id ? { type: "command", command: { ...item.command, result: event.result, running: true } } : item))+ completedCommand = true+ window.setTimeout(() => {+ if (!ownsRun(runId, conversationID)) return+ setLiveItems(current => current.map(item => item.type === "command" && item.command.id === event.toolCall.id ? { type: "command", command: { ...item.command, running: false } } : item))+ }, 350)+ } else if (event.type === "complete") {+ clearLoading(runId, conversationID)+ setLiveAssistant(current => ({ role: "assistant", content: current?.content || event.message.content, created_at: new Date().toISOString() }))+ }+ }, controller.signal)+ } catch (error) {+ if (ownsRun(runId, conversationID) && !isAbort(error)) setTurnError(error instanceof Error ? error.message : "Unable to generate a response")+ finishAbortable(runId, conversationID, controller)+ finishRun(runId, conversationID)+ return+ }++ finishAbortable(runId, conversationID, controller)+ if (completedCommand) await new Promise<void>(resolve => window.setTimeout(resolve, 360))++ try {+ await refresh(conversationID, runId)+ } catch (error) {+ if (ownsRun(runId, conversationID)) setRefreshError(error instanceof Error ? error.message : "Unable to refresh conversation")+ } finally {+ finishRun(runId, conversationID)+ }+ }++ const submitPrompt = async (prompt: string, initialConversationID = selectedId) => {+ if (activeRunIdRef.current !== undefined) return+ const runId = ++nextRunIdRef.current+ activeRunIdRef.current = runId+ activeRunConversationIdRef.current = initialConversationID+ setRunning(true)+ setTurnError(undefined)+ setRefreshError(undefined)+ setInitialCreatePrompt(undefined)+ let conversationID = initialConversationID+ try {+ if (!conversationID) {+ const conversation = await createConversation()+ if (!ownsUnboundRun(runId)) return+ conversationID = conversation.id+ activeRunConversationIdRef.current = conversation.id+ selectedConversationIdRef.current = conversation.id+ ignoreNextConversationLoadRef.current = true+ setSelectedId(conversation.id)+ setSelectedConversation(conversation)+ }+ setDraft("")+ setLiveItems([{ type: "message", message: { role: "user", content: prompt, created_at: new Date().toISOString() } }])+ await runAgent(runId, conversationID, [{ role: "user", content: prompt }])+ } catch (error) {+ if (!conversationID && ownsUnboundRun(runId)) {+ setInitialCreatePrompt(prompt)+ setTurnError(error instanceof Error ? error.message : "Unable to create conversation")+ finishRun(runId)+ } else if (conversationID && ownsRun(runId, conversationID)) {+ setTurnError(error instanceof Error ? error.message : "Unable to create conversation")+ finishRun(runId, conversationID)+ }+ }+ }++ const submit = async () => {+ const prompt = draft.trim()+ if (!prompt) return+ await submitPrompt(prompt)+ }++ const retryTurn = () => {+ if (!selectedId || activeRunIdRef.current !== undefined) return+ const runId = ++nextRunIdRef.current+ activeRunIdRef.current = runId+ activeRunConversationIdRef.current = selectedId+ setRunning(true)+ setTurnError(undefined)+ setRefreshError(undefined)+ setLiveAssistant(undefined)+ void runAgent(runId, selectedId, [])+ }++ const retryInitialCreate = () => {+ if (!initialCreatePrompt) return+ void submitPrompt(initialCreatePrompt, undefined)+ }++ const stop = () => {+ if (!abortable) return+ abortControllerRef.current?.abort()+ clearLoading(activeRunIdRef.current, activeRunConversationIdRef.current)+ setLiveAssistant(undefined)+ }++ const closeHistory = () => setHistoryOpen(false)+ const trapDialogFocus = (event: React.KeyboardEvent<HTMLDivElement>) => {+ if (event.key === "Escape") { event.preventDefault(); closeHistory(); return }+ if (event.key !== "Tab") return+ const focusable = dialogRef.current?.querySelectorAll<HTMLElement>('a[href], button:not([disabled]):not([tabindex="-1"]), input:not([disabled]):not([tabindex="-1"]), select:not([disabled]):not([tabindex="-1"]), textarea:not([disabled]):not([tabindex="-1"]), [tabindex]:not([tabindex="-1"])')+ if (!focusable?.length) { event.preventDefault(); return }+ const first = focusable[0]+ const last = focusable[focusable.length - 1]+ if (event.shiftKey && document.activeElement === first) { event.preventDefault(); last.focus() }+ else if (!event.shiftKey && document.activeElement === last) { event.preventDefault(); first.focus() }+ }++ const selectConversation = (conversationID: string) => {+ if (activeRunIdRef.current !== undefined) return false+ selectedConversationIdRef.current = conversationID+ setSelectedId(conversationID)+ return true+ }++ const persistedItems = selectedConversation ? reconstructTranscript(selectedConversation.messages) : []+ const transcript = [...persistedItems, ...liveItems]+ const latestMessage = [...transcript].reverse().find((item): item is Extract<TranscriptItem, { type: "message" }> => item.type === "message")?.message+ const effectiveMessage = liveAssistant ?? latestMessage+ const latestAnnouncement = abortable+ ? "Generating response"+ : effectiveMessage?.content+ ? `Latest ${effectiveMessage.role === "user" ? "user" : "assistant"} message available.`+ : ""+ const drawerHistory = <ConversationHistory conversations={conversations} disabled={running} loading={listLoading} onSelect={id => { if (selectConversation(id)) closeHistory() }} showHeading={false} />++ return (+ <div className="agent-chat-page">+ <aside className="agent-chat-history"><ConversationHistory conversations={conversations} disabled={running} loading={listLoading} onSelect={selectConversation} /></aside>+ <div className="agent-chat-main">+ <div className="agent-chat-mobile-history"><Button ariaLabel="View conversations" iconName="menu" onClick={() => setHistoryOpen(true)} ref={triggerRef}>Conversations</Button></div>+ <section aria-label="Chat" className="agent-chat-transcript" ref={transcriptRef}>+ {conversationLoading ? <SpaceBetween size="m"><Skeleton kind="message" /><Skeleton kind="message" /></SpaceBetween> : transcript.length || liveAssistant || assistantLoading ? (+ <SpaceBetween size="m">+ {transcript.map((item, index) => item.type === "message" ? <MessageBubble key={item.message.id ?? `message-${index}`} message={item.message} position={index + 1} /> : <CommandStatus command={item.command} key={item.command.id} />)}+ {liveAssistant && <MessageBubble loading={abortable} message={liveAssistant} position={transcript.length + 1} />}+ {!liveAssistant && assistantLoading && <MessageBubble loading message={{ role: "assistant", content: "", created_at: new Date().toISOString() }} position={transcript.length + 1} />}+ </SpaceBetween>+ ) : <div className="agent-chat-empty"><Box variant="h2">Select a conversation</Box><Box color="text-body-secondary">Choose a previous conversation to view its transcript.</Box></div>}+ {turnError && <div role="alert"><Alert action={<Button onClick={initialCreatePrompt ? retryInitialCreate : retryTurn}>Retry</Button>} type="error">{turnError}</Alert></div>}+ {refreshError && <div role="alert"><Alert action={<Button disabled={running} onClick={() => { if (selectedId) void recoverRefresh(selectedId) }}>Refresh conversation</Button>} type="error">{refreshError}</Alert></div>}+ <LiveRegion hidden>{conversationLoading ? "Loading conversation" : selectedConversation ? "Conversation loaded" : "No conversation selected"}</LiveRegion>+ <LiveRegion>{latestAnnouncement}</LiveRegion>+ </section>+ <div className="agent-chat-composer">+ <SpaceBetween direction="horizontal" size="xs">+ <div className="agent-chat-prompt"><PromptInput actionButtonAriaLabel="Send message" actionButtonIconName="send" disableActionButton={running || !draft.trim()} onAction={() => void submit()} onChange={({ detail }) => setDraft(detail.value)} placeholder="Ask a question" value={draft} /></div>+ {abortable && <Button ariaLabel="Stop generating" onClick={stop}>Stop</Button>}+ </SpaceBetween>+ </div>+ </div>+ {mobileHistory && historyOpen && createPortal(+ <div aria-label="Conversations" aria-modal="true" className="agent-chat-mobile-overlay" onKeyDown={trapDialogFocus} ref={dialogRef} role="dialog">+ <div aria-hidden="true" className="agent-chat-mobile-backdrop" data-testid="conversation-history-backdrop" onClick={closeHistory} />+ <div className="agent-chat-mobile-drawer"><Drawer header={<h2>Conversations</h2>} headerActions={<Button ariaLabel="Close conversations" iconName="close" onClick={closeHistory} ref={closeButtonRef} variant="icon" />}>{drawerHistory}</Drawer></div>+ </div>, document.body,+ )}+ </div>+ )+}diff --git a/libs/fleet/src/sdk/chat.ts b/libs/fleet/src/sdk/chat.tsnew file mode 100644index 0000000000..214fee60f1--- /dev/null+++ b/libs/fleet/src/sdk/chat.ts@@ -0,0 +1,207 @@+import { getToken } from "../auth/keycloak"++export type ChatRole = "user" | "assistant" | "tool"++export interface ChatToolFunction {+ name: string+ arguments: string+}++export interface ChatToolCall {+ id: string+ type: string+ function: ChatToolFunction+}++export interface ChatMessage {+ id?: string+ role: ChatRole+ content: string+ tool_call_id?: string+ tool_calls?: ChatToolCall[]+ created_at?: string+}++export interface Conversation {+ id: string+ title: string+ messages: ChatMessage[]+ created_at: string+ updated_at: string+}++export interface ConversationSummary {+ id: string+ title: string+ created_at: string+ updated_at: string+}++export class ChatApiError extends Error {+ constructor(+ message: string,+ readonly status?: number,+ ) {+ super(message)+ this.name = "ChatApiError"+ }+}++async function chatFetch(path: string, init: RequestInit = {}): Promise<Response> {+ const token = await getToken()+ return fetch(path, {+ ...init,+ headers: {+ Authorization: token ? `Bearer ${token}` : "",+ "Content-Type": "application/json",+ ...init.headers,+ },+ })+}++async function chatJson<T>(path: string, init: RequestInit = {}): Promise<T> {+ const response = await chatFetch(path, init)+ if (!response.ok) throw await responseError(response)+ return (await response.json()) as T+}++async function responseError(response: Response): Promise<ChatApiError> {+ let message = `Chat request failed (${response.status})`+ try {+ const body = (await response.json()) as { error?: unknown; message?: unknown }+ if (typeof body.error === "string") message = body.error+ else if (typeof body.message === "string") message = body.message+ } catch {+ // Keep the status-derived message when the backend did not return JSON.+ }+ return new ChatApiError(message, response.status)+}++function isRecord(value: unknown): value is Record<string, unknown> {+ return typeof value === "object" && value !== null && !Array.isArray(value)+}++function parseToolCalls(value: unknown): ChatToolCall[] {+ if (!Array.isArray(value)) throw new ChatApiError("Chat stream contained invalid tool calls")++ return value.map(toolCall => {+ if (!isRecord(toolCall) || typeof toolCall.id !== "string" || typeof toolCall.type !== "string") {+ throw new ChatApiError("Chat stream contained an invalid tool call")+ }+ if (+ !isRecord(toolCall.function) ||+ typeof toolCall.function.name !== "string" ||+ typeof toolCall.function.arguments !== "string"+ ) {+ throw new ChatApiError("Chat stream contained an invalid tool function")+ }+ return {+ id: toolCall.id,+ type: toolCall.type,+ function: {+ name: toolCall.function.name,+ arguments: toolCall.function.arguments,+ },+ }+ })+}++function parseAssistantMessage(value: unknown): ChatMessage {+ if (!isRecord(value) || value.role !== "assistant" || typeof value.content !== "string") {+ throw new ChatApiError("Chat stream contained an invalid assistant message")+ }+ if (value.id !== undefined && typeof value.id !== "string") {+ throw new ChatApiError("Chat stream contained an invalid assistant message")+ }+ if (value.tool_call_id !== undefined && typeof value.tool_call_id !== "string") {+ throw new ChatApiError("Chat stream contained an invalid assistant message")+ }+ if (value.created_at !== undefined && typeof value.created_at !== "string") {+ throw new ChatApiError("Chat stream contained an invalid assistant message")+ }++ return {+ ...(typeof value.id === "string" ? { id: value.id } : {}),+ role: "assistant",+ content: value.content,+ ...(typeof value.tool_call_id === "string" ? { tool_call_id: value.tool_call_id } : {}),+ ...(value.tool_calls !== undefined ? { tool_calls: parseToolCalls(value.tool_calls) } : {}),+ ...(typeof value.created_at === "string" ? { created_at: value.created_at } : {}),+ }+}++export function createConversation(): Promise<Conversation> {+ return chatJson<Conversation>("/api/chat/conversations", { method: "POST" })+}++export function listConversations(): Promise<ConversationSummary[]> {+ return chatJson<ConversationSummary[]>("/api/chat/conversations")+}++export function getConversation(id: string): Promise<Conversation> {+ return chatJson<Conversation>(`/api/chat/conversations/${encodeURIComponent(id)}`)+}++export async function streamTurn(+ conversationId: string,+ messages: ChatMessage[],+ onDelta: (delta: string) => void,+ signal?: AbortSignal,+): Promise<ChatMessage> {+ const response = await chatFetch(+ `/api/chat/conversations/${encodeURIComponent(conversationId)}/turns`,+ { method: "POST", body: JSON.stringify({ messages }), signal },+ )+ if (!response.ok) throw await responseError(response)+ if (!response.body) throw new ChatApiError("Chat response did not include a stream")++ const reader = response.body.getReader()+ const decoder = new TextDecoder()+ let buffer = ""+ let assistant: ChatMessage | undefined++ const applyLine = (line: string) => {+ if (!line.trim()) return++ let event: unknown+ try {+ event = JSON.parse(line)+ } catch {+ throw new ChatApiError("Chat stream contained invalid NDJSON")+ }+ if (!isRecord(event)) throw new ChatApiError("Chat stream contained an invalid event")++ if (event.type === "content_delta") {+ if (typeof event.delta !== "string") {+ throw new ChatApiError("Chat stream contained an invalid content delta")+ }+ onDelta(event.delta)+ return+ }++ if (event.type === "assistant") {+ assistant = parseAssistantMessage(event.message)+ return+ }++ throw new ChatApiError("Chat stream contained an unknown event")+ }++ try {+ while (true) {+ const { done, value } = await reader.read()+ buffer += decoder.decode(value, { stream: !done })+ const lines = buffer.split("\n")+ buffer = lines.pop() ?? ""+ for (const line of lines) applyLine(line)+ if (done) break+ }+ if (buffer.trim()) applyLine(buffer)+ } catch (error) {+ if (error instanceof ChatApiError || (error instanceof DOMException && error.name === "AbortError")) throw error+ throw new ChatApiError(error instanceof Error ? error.message : "Chat stream failed")+ }++ if (!assistant) throw new ChatApiError("Chat stream ended without an assistant message")+ return assistant+}diff --git a/libs/fleet/src/sdk/featureFlags.ts b/libs/fleet/src/sdk/featureFlags.tsindex f46d9abb8a..57911d2368 100644--- a/libs/fleet/src/sdk/featureFlags.ts+++ b/libs/fleet/src/sdk/featureFlags.ts@@ -12,11 +12,14 @@ export interface FeatureFlags {admin: boolean/** Billing navigation and page are disabled by default. */billing: boolean+ /** Chat users can access persisted browser-bash conversations. */+ chat: boolean}const DEFAULT_FLAGS: FeatureFlags = {admin: false,billing: false,+ chat: false,}let _cache: FeatureFlags | null = null@@ -40,6 +43,7 @@ export async function fetchFeatureFlags(): Promise<FeatureFlags> {_cache = {admin: data.admin ?? false,billing: data.billing ?? false,+ chat: data.chat ?? false,}return _cache} catch {diff --git a/libs/fleet/vite.config.ts b/libs/fleet/vite.config.tsindex 0c88442db0..0f8049b169 100644--- a/libs/fleet/vite.config.ts+++ b/libs/fleet/vite.config.ts@@ -1,5 +1,6 @@import { defineConfig } from "vite"import react from "@vitejs/plugin-react"+import { fileURLToPath, URL } from "node:url"// /api/k8s and /api/orch are served by the cyclops-cs backend sidecar// (Keycloak SSO + OPA), which isn't reachable from a laptop. In dev,@@ -10,6 +11,11 @@ const ORCH_API = process.env.ORCH_API ?? "https://cyclops-cs.tail204509.ts.net"export default defineConfig({plugins: [react()],assetsInclude: ["**/*.wasm"],+ resolve: {+ alias: {+ "node:zlib": fileURLToPath(new URL("./src/node-zlib-browser.ts", import.meta.url)),+ },+ },// @novnc/novnc (1.7+) uses top-level await; es2020 (esbuild's default here)// rejects it. es2022 is supported by all evergreen browsers the app targets.build: { target: "es2022" },