Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

feat(cyclops): add browser bash chat (#6769)

r33drichards54d62e72ef44
diff --git a/libs/fleet/agent.test.ts b/libs/fleet/agent.test.ts
new file mode 100644
index 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.rego
new file mode 100644
index 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.rego
new file mode 100644
index 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.go
index 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.rego
var authzConfigPolicy string
+//go:embed authz_chat.rego
+var authzChatPolicy string
+
//go:embed authz_billing.rego
var authzBillingPolicy string
diff --git a/libs/fleet/backend/auth/policy_characterization_test.go b/libs/fleet/backend/auth/policy_characterization_test.go
index 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 route
diff --git a/libs/fleet/backend/auth/policy_routes.go b/libs/fleet/backend/auth/policy_routes.go
index 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.txt
new file mode 100644
index 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.txt
index 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 = deny
diff --git a/libs/fleet/backend/chat/litellm.go b/libs/fleet/backend/chat/litellm.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 GatewayConfiguration
Database DatabaseConfiguration
Stripe StripeConfiguration
+ Chat ChatConfiguration
Metrics MetricsConfiguration
Telemetry 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.go
index 100401476e..bc833bc909 100644
--- a/libs/fleet/backend/config/config_test.go
+++ b/libs/fleet/backend/config/config_test.go
@@ -3,6 +3,7 @@ package config
import (
"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.go
index 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.json
index 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.yaml
index 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_present
type: 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: object
handlers.BillingSessionResponse:
properties:
url:
@@ -39,6 +108,8 @@ definitions:
type: boolean
billing:
type: boolean
+ chat:
+ type: boolean
type: object
handlers.CreateKeyRequest:
properties:
@@ -133,6 +204,13 @@ definitions:
status:
type: string
type: object
+ handlers.TurnRequest:
+ properties:
+ messages:
+ items:
+ $ref: '#/definitions/chat.Message'
+ type: array
+ type: object
handlers.UserKeyResponse:
properties:
client_id:
@@ -146,6 +224,15 @@ definitions:
type: string
type: array
type: object
+ handlers.turnEvent:
+ properties:
+ delta:
+ type: string
+ message:
+ $ref: '#/definitions/chat.Message'
+ type:
+ type: string
+ type: object
keycloak.KeyClient:
properties:
client_id:
@@ -323,6 +410,139 @@ paths:
summary: Receive Stripe webhook
tags:
- 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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.go
index 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.md
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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 requests
await 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.conf
index 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.json
index 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.yaml
index 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
'@cloudscape-design/collection-hooks':
specifier: ^1.0.93
version: 1.0.93([email protected])
@@ -31,6 +34,9 @@ importers:
ansi-to-html:
specifier: ^0.7.2
version: 0.7.2
+ just-bash:
+ specifier: ^3.2.0
+ version: 3.2.0
keycloak-js:
specifier: ^25.0.6
version: 25.0.6
@@ -50,6 +56,9 @@ importers:
'@playwright/test':
specifier: ^1.60.0
version: 1.60.0
+ '@types/node':
+ specifier: ^22.19.17
+ version: 22.20.1
'@types/react':
specifier: ^18.3.12
version: 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.2
version: 5.9.3
vite:
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==}
+ resolution: {integrity: sha512-v9T+GQpmk43VDJ7d72sf0Nexhk+ArvtUihW27dy7lqAl0zBObFKtSBBIm5RBjwIhE8VwsPPm9PNuvPvNqLWUEg==}
+
+ resolution: {integrity: sha512-EX8zbXwGqCgAE764M+qvkHtyXDi/FUoMBea0JnES7vCM3P7a2+EOZOjGv85wtZ2sJhI1oJ+nekmqpOODFDY+hw==}
+
+ resolution: {integrity: sha512-LeYWrPGC1uNCTBWvibo3ZLJj0CSVNYUXvJpXMCmuQ5Sap2cCACc3uvGvYV4homHHBAzfw5akoTqMMS4YFRtw+Q==}
+
+ resolution: {integrity: sha512-3oSwPfja12ICz4aIblB58cuY8JlEq5Txt8Cut4VLo+LH47QN+mzCnSgnbB03hWzg1LBcc+VyyI9UOag7a1NF+Q==}
+
+ 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==}
+
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==}
+
resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
@@ -581,6 +631,9 @@ packages:
resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+ '@types/[email protected]':
+ resolution: {integrity: sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==}
+
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: true
peerDependencies:
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:
@@ -1031,6 +1333,16 @@ snapshots:
'@biomejs/[email protected]':
optional: true
+ '@borewit/[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]': {}
+
+ dependencies:
+ '@jitl/quickjs-ffi-types': 0.32.0
+
+ dependencies:
+ '@jitl/quickjs-ffi-types': 0.32.0
+
+ dependencies:
+ '@jitl/quickjs-ffi-types': 0.32.0
+
+ 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]': {}
+
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]': {}
@@ -1339,7 +1692,7 @@ snapshots:
'@ubjs/[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.5
react-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
+
+
+ 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.38
update-browserslist-db: 1.2.3([email protected])
+ dependencies:
+ base64-js: 1.5.1
+ ieee754: 1.2.1
+ optional: true
+
+ optional: true
+
+
@@ -1400,6 +1782,19 @@ snapshots:
+ dependencies:
+ mimic-response: 3.1.0
+ optional: true
+
+ optional: true
+
+ optional: true
+
+
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
+
+
+ optional: true
+
+ optional: true
+
+
dependencies:
'@formatjs/ecma402-abstract': 2.3.6
@@ -1454,6 +1896,8 @@ snapshots:
'@formatjs/icu-messageformat-parser': 2.11.4
tslib: 2.8.1
+
@@ -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
+
+ 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
+
+
+
@@ -1505,12 +2017,56 @@ snapshots:
picocolors: 1.1.1
source-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.0
object-assign: 4.1.1
react-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
+
+
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.3
fsevents: 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
+
+
+
+
+ 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
+
+
+
+
dependencies:
browserslist: 4.28.2
escalade: 3.2.0
picocolors: 1.1.1
+ optional: true
+
dependencies:
esbuild: 0.21.5
postcss: 8.5.14
rollup: 4.60.3
optionalDependencies:
+ '@types/node': 22.20.1
fsevents: 2.3.3
+ optional: true
+
+
+
diff --git a/libs/fleet/src/App.tsx b/libs/fleet/src/App.tsx
index 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 />} />
<Route
path="/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.ts
new file mode 100644
index 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.tsx
index 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: boolean
diff --git a/libs/fleet/src/node-zlib-browser.ts b/libs/fleet/src/node-zlib-browser.ts
new file mode 100644
index 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 = unsupported
diff --git a/libs/fleet/src/pages/AgentChat.css b/libs/fleet/src/pages/AgentChat.css
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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" },