@tangle-network/sandbox-ui 0.39.1 → 0.40.0

package/dist/assistant.js

@@ -0,0 +1,2306 @@
+import {
+  providerLabel
+} from "./chunk-7JLB7UZ3.js";
+
+// src/assistant/sse.ts
+var SSEChunkParser = class {
+  buffer = "";
+  current = {};
+  push(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    return this.processLines(lines);
+  }
+  flush() {
+    const lines = this.buffer ? [this.buffer] : [];
+    this.buffer = "";
+    const events = this.processLines(lines);
+    const finalEvent = this.parseCurrent();
+    if (finalEvent) {
+      events.push(finalEvent);
+      this.current = {};
+    }
+    return events;
+  }
+  processLines(lines) {
+    const events = [];
+    for (const rawLine of lines) {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (line.startsWith(":")) continue;
+      if (line === "") {
+        const parsed = this.parseCurrent();
+        if (parsed) events.push(parsed);
+        this.current = {};
+        continue;
+      }
+      if (line.startsWith("id:")) {
+        this.current.id = line.slice(3).trim();
+      } else if (line.startsWith("event:")) {
+        this.current.event = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        let value = line.slice(5);
+        if (value.startsWith(" ")) value = value.slice(1);
+        this.current.data = this.current.data !== void 0 ? `${this.current.data}
+${value}` : value;
+      }
+    }
+    return events;
+  }
+  parseCurrent() {
+    if (this.current.data === void 0) return null;
+    const rawData = this.current.data.trim();
+    if (!rawData) return null;
+    let data;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+      data = rawData;
+    }
+    return {
+      data,
+      rawData,
+      eventId: this.current.id,
+      eventType: this.current.event
+    };
+  }
+};
+async function readSSEEvents(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const parser = new SSEChunkParser();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      for (const event of parser.push(decoder.decode(value, { stream: true }))) {
+        onEvent(event);
+      }
+    }
+    const tail = decoder.decode();
+    if (tail) {
+      for (const event of parser.push(tail)) onEvent(event);
+    }
+    for (const event of parser.flush()) onEvent(event);
+  } catch (err) {
+    await reader.cancel(err).catch(() => {
+    });
+    throw err;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/assistant/client.ts
+var EMPTY_MODELS = { default: null, models: [] };
+function asObject(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function reqStr(v) {
+  return typeof v === "string" && v !== "" ? v : null;
+}
+function numOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function parseRequirement(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.provider !== "string" || r.provider === "") return null;
+  if (typeof r.connected !== "boolean") return null;
+  const kind = r.kind === "integration" || r.kind === "github_app" ? r.kind : void 0;
+  const connectUrl = typeof r.connectUrl === "string" || r.connectUrl === null ? r.connectUrl : void 0;
+  return {
+    provider: r.provider,
+    connected: r.connected,
+    ...kind ? { kind } : {},
+    ...connectUrl !== void 0 ? { connectUrl } : {}
+  };
+}
+function parseRequirements(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const item of v) {
+    const parsed = parseRequirement(item);
+    if (parsed) out.push(parsed);
+  }
+  return out;
+}
+function toStreamEvent(event, data) {
+  const obj = asObject(data);
+  if (!obj) return null;
+  switch (event) {
+    case "thread": {
+      const threadId = reqStr(obj.threadId);
+      const turnId = reqStr(obj.turnId);
+      if (!threadId || !turnId) return null;
+      return {
+        type: "thread",
+        data: { threadId, turnId, model: reqStr(obj.model) }
+      };
+    }
+    case "delta": {
+      if (typeof obj.text !== "string") return null;
+      return { type: "delta", data: { text: obj.text } };
+    }
+    case "reasoning": {
+      if (typeof obj.text !== "string") return null;
+      return { type: "reasoning", data: { text: obj.text } };
+    }
+    case "tool_call": {
+      const callId = reqStr(obj.callId);
+      const name = reqStr(obj.name);
+      if (!callId || !name) return null;
+      return { type: "tool_call", data: { callId, name } };
+    }
+    case "tool_result": {
+      const callId = reqStr(obj.callId);
+      const name = reqStr(obj.name);
+      if (!callId || !name) return null;
+      return {
+        type: "tool_result",
+        data: {
+          callId,
+          name,
+          ok: Boolean(obj.ok),
+          output: obj.output,
+          error: obj.error
+        }
+      };
+    }
+    case "tool_proposal": {
+      const callId = reqStr(obj.callId);
+      const name = reqStr(obj.name);
+      if (!callId || !name) return null;
+      return {
+        type: "tool_proposal",
+        data: {
+          proposalId: obj.proposalId == null ? null : reqStr(obj.proposalId),
+          callId,
+          name,
+          args: obj.args,
+          requirements: parseRequirements(obj.requirements)
+        }
+      };
+    }
+    case "usage":
+      return {
+        type: "usage",
+        data: {
+          promptTokens: numOrNull(obj.promptTokens),
+          completionTokens: numOrNull(obj.completionTokens),
+          costUsd: numOrNull(obj.costUsd),
+          balanceUsd: numOrNull(obj.balanceUsd),
+          replayed: Boolean(obj.replayed)
+        }
+      };
+    case "done": {
+      const turnId = reqStr(obj.turnId);
+      const status = reqStr(obj.status);
+      if (!turnId || !status) return null;
+      return {
+        type: "done",
+        data: {
+          turnId,
+          status,
+          proposed: Boolean(obj.proposed),
+          capped: Boolean(obj.capped)
+        }
+      };
+    }
+    case "error":
+      return {
+        type: "error",
+        data: {
+          code: reqStr(obj.code) ?? "STREAM_FAILED",
+          message: reqStr(obj.message) ?? "The assistant stream failed"
+        }
+      };
+    default:
+      return null;
+  }
+}
+async function readErrorEvent(res) {
+  try {
+    const body = await res.json();
+    return {
+      type: "error",
+      data: {
+        code: body.error?.code ?? `HTTP_${res.status}`,
+        message: body.error?.message ?? `Request failed (${res.status})`
+      }
+    };
+  } catch {
+    return {
+      type: "error",
+      data: {
+        code: `HTTP_${res.status}`,
+        message: `Request failed (${res.status})`
+      }
+    };
+  }
+}
+function parseRestoredProposal(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.proposalId !== "string" || r.proposalId === "") return null;
+  if (typeof r.callId !== "string" || r.callId === "") return null;
+  if (typeof r.name !== "string" || r.name === "") return null;
+  const requirements = Array.isArray(r.requirements) ? r.requirements.map(parseRequirement).filter((x) => x !== null) : void 0;
+  return {
+    proposalId: r.proposalId,
+    callId: r.callId,
+    name: r.name,
+    args: r.args,
+    ...requirements ? { requirements } : {}
+  };
+}
+function createAssistantClient(config) {
+  const base = config.baseUrl.replace(/\/+$/, "");
+  const credentials = config.credentials ?? "include";
+  const authHeaders = () => config.headers?.() ?? {};
+  const url = (path) => `${base}${path}`;
+  async function postJson(path, body) {
+    try {
+      const res = await fetch(url(path), {
+        method: "POST",
+        headers: { ...authHeaders(), "Content-Type": "application/json" },
+        credentials,
+        body: JSON.stringify(body)
+      });
+      const json = await res.json();
+      if (!res.ok) {
+        return {
+          success: false,
+          error: json?.error?.message || `HTTP ${res.status}`
+        };
+      }
+      return { success: true, data: json?.data ?? json };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Request failed"
+      };
+    }
+  }
+  return {
+    async fetchModels(signal) {
+      try {
+        const res = await fetch(url("/models"), {
+          method: "GET",
+          headers: authHeaders(),
+          credentials,
+          signal
+        });
+        if (!res.ok) return { ok: false, data: EMPTY_MODELS };
+        const body = await res.json();
+        if (!Array.isArray(body.models))
+          return { ok: false, data: EMPTY_MODELS };
+        const models = [];
+        for (const m of body.models) {
+          const slug = typeof m.slug === "string" ? m.slug : null;
+          if (!slug) continue;
+          const label = typeof m.label === "string" ? m.label : slug;
+          const option = { slug, label };
+          if (typeof m.promptUsdPerMillion === "number") {
+            option.promptUsdPerMillion = m.promptUsdPerMillion;
+          }
+          if (typeof m.contextTokens === "number") {
+            option.contextTokens = m.contextTokens;
+          }
+          models.push(option);
+        }
+        return {
+          // Empty ⇒ catalog unavailable: report not-ok so the caller retries next
+          // mount instead of caching an empty picker for the session.
+          ok: models.length > 0,
+          data: {
+            default: typeof body.default === "string" ? body.default : null,
+            models
+          }
+        };
+      } catch {
+        return { ok: false, data: EMPTY_MODELS };
+      }
+    },
+    async fetchThreads(signal) {
+      try {
+        const res = await fetch(url("/threads"), {
+          method: "GET",
+          headers: authHeaders(),
+          credentials,
+          signal
+        });
+        if (!res.ok) return null;
+        const body = await res.json();
+        if (!Array.isArray(body.threads)) return null;
+        const out = [];
+        for (const t of body.threads) {
+          const id = typeof t.id === "string" ? t.id : null;
+          if (!id) continue;
+          out.push({
+            id,
+            title: typeof t.title === "string" ? t.title : null,
+            createdAt: typeof t.createdAt === "string" ? t.createdAt : "",
+            updatedAt: typeof t.updatedAt === "string" ? t.updatedAt : ""
+          });
+        }
+        return out;
+      } catch {
+        return null;
+      }
+    },
+    async fetchThreadHistory(threadId, signal) {
+      try {
+        const res = await fetch(
+          url(`/threads/${encodeURIComponent(threadId)}/messages`),
+          {
+            method: "GET",
+            headers: authHeaders(),
+            credentials,
+            signal
+          }
+        );
+        if (res.status === 404) return { status: "gone" };
+        if (!res.ok) return { status: "error" };
+        const body = await res.json();
+        if (!Array.isArray(body.messages)) return { status: "error" };
+        const out = [];
+        for (const m of body.messages) {
+          const id = typeof m.id === "string" ? m.id : null;
+          const role = m.role === "user" || m.role === "assistant" ? m.role : null;
+          const text = typeof m.text === "string" ? m.text : null;
+          if (id && role && text != null) out.push({ id, role, text });
+        }
+        const proposals = [];
+        if (Array.isArray(body.proposals)) {
+          for (const p of body.proposals) {
+            const parsed = parseRestoredProposal(p);
+            if (parsed) proposals.push(parsed);
+          }
+        }
+        return { status: "ok", messages: out, proposals };
+      } catch {
+        if (signal?.aborted) return { status: "error" };
+        return { status: "error" };
+      }
+    },
+    async streamChat(req, onEvent, signal) {
+      const res = await fetch(url("/chat"), {
+        method: "POST",
+        headers: {
+          ...authHeaders(),
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        credentials,
+        body: JSON.stringify(req),
+        signal
+      });
+      if (!res.ok) {
+        onEvent(await readErrorEvent(res));
+        return;
+      }
+      if (!res.body) {
+        onEvent({
+          type: "error",
+          data: {
+            code: "NO_BODY",
+            message: "The assistant stream is unavailable"
+          }
+        });
+        return;
+      }
+      let settled = false;
+      await readSSEEvents(res.body, (frame) => {
+        const ev = toStreamEvent(frame.eventType ?? null, frame.data);
+        if (!ev) return;
+        if (ev.type === "done" || ev.type === "error") settled = true;
+        onEvent(ev);
+      });
+      if (!settled) {
+        onEvent({
+          type: "error",
+          data: {
+            code: "STREAM_CLOSED",
+            message: "The assistant stream ended unexpectedly"
+          }
+        });
+      }
+    },
+    async confirmProposal(proposalId) {
+      const res = await postJson("/tools/execute", { proposalId });
+      if (!res.success) {
+        return {
+          ok: false,
+          error: res.error ?? "The action could not be completed"
+        };
+      }
+      const body = res.data;
+      if (body?.success) {
+        return { ok: true, output: body.output, retryable: body.retryable };
+      }
+      return {
+        ok: false,
+        error: body?.error?.message ?? "The action could not be completed"
+      };
+    }
+  };
+}
+
+// src/assistant/client-context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var AssistantClientContext = createContext(null);
+function AssistantClientProvider({
+  client,
+  children
+}) {
+  return /* @__PURE__ */ jsx(AssistantClientContext.Provider, { value: client, children });
+}
+function useAssistantClient() {
+  const client = useContext(AssistantClientContext);
+  if (!client) {
+    throw new Error(
+      "useAssistantClient must be used within an <AssistantClientProvider>"
+    );
+  }
+  return client;
+}
+
+// src/assistant/useAssistantChat.ts
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+
+// src/assistant/persistence.ts
+var VERSION = "v1";
+function keyFor(userId) {
+  return userId ? `assistant:${VERSION}:${userId}` : null;
+}
+function loadThread(userId) {
+  const key = keyFor(userId);
+  if (!key) return { threadId: null, model: null };
+  try {
+    const raw = localStorage.getItem(key);
+    if (!raw) return { threadId: null, model: null };
+    const parsed = JSON.parse(raw);
+    return {
+      threadId: typeof parsed.threadId === "string" ? parsed.threadId : null,
+      model: typeof parsed.model === "string" ? parsed.model : null
+    };
+  } catch {
+    return { threadId: null, model: null };
+  }
+}
+function saveThread(userId, thread) {
+  const key = keyFor(userId);
+  if (!key) return;
+  try {
+    localStorage.setItem(
+      key,
+      JSON.stringify({ threadId: thread.threadId, model: thread.model })
+    );
+  } catch {
+  }
+}
+
+// src/assistant/presentation.ts
+var LOW_BALANCE_THRESHOLD = 1;
+var ADD_CREDITS_CTA = { label: "Add credits", to: "/app/billing" };
+var CONNECT_CTA = {
+  label: "Connect an integration",
+  to: "/app/integrations"
+};
+function presentError(code, message) {
+  switch (code) {
+    case "INSUFFICIENT_BALANCE":
+      return {
+        message: "You're out of credits. Add credits to keep using the assistant.",
+        cta: ADD_CREDITS_CTA
+      };
+    case "MODEL_ACCESS_UNCONFIGURED":
+      return {
+        message: "Model access isn't configured for your account yet. Please contact support.",
+        cta: null
+      };
+    case "BILLING_UNAVAILABLE":
+      return {
+        message: "Billing is temporarily unavailable. Try again in a moment.",
+        cta: null
+      };
+    case "TOO_MANY_STREAMS":
+      return {
+        message: "You have too many assistant requests in flight. Wait a moment and retry.",
+        cta: null
+      };
+    case "THREAD_BUSY":
+    case "TURN_IN_PROGRESS":
+      return {
+        message: "A previous request is still finishing. Try again shortly.",
+        cta: null
+      };
+    case "INTEGRATION_DISCONNECTED":
+      return {
+        message: `${message} Connect the integration, then ask again.`,
+        cta: CONNECT_CTA
+      };
+    case "TOOL_FAILED":
+    case "NETWORK":
+      return { message: message || "Something went wrong.", cta: null };
+    default:
+      return { message: message || "Something went wrong.", cta: null };
+  }
+}
+function asRecord(args) {
+  return args && typeof args === "object" && !Array.isArray(args) ? args : {};
+}
+function str(v) {
+  if (v == null) return "";
+  return typeof v === "string" ? v : JSON.stringify(v);
+}
+function nonEmptyStr(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : null;
+}
+function parseProposalSkills(v) {
+  if (!Array.isArray(v) || v.length === 0) return void 0;
+  const out = [];
+  for (const item of v) {
+    const rec = asRecord(item);
+    const name = nonEmptyStr(rec.name);
+    if (!name) continue;
+    out.push({ name, description: nonEmptyStr(rec.description) });
+  }
+  return out.length > 0 ? out : void 0;
+}
+function humanizeToolName(name) {
+  const spaced = name.replace(/_/g, " ").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+var TOOL_ACTIVITY_LABELS = {
+  get_workflow_schema: "Reading the workflow format",
+  list_workflows: "Listing workflows",
+  get_workflow: "Reading workflow",
+  validate_workflow: "Validating workflow",
+  list_skills: "Listing skills",
+  get_skill: "Reading skill",
+  list_integrations: "Checking integrations",
+  get_credit_balance: "Checking balance",
+  get_usage: "Checking usage",
+  list_api_keys: "Listing API keys"
+};
+function describeToolActivity(name) {
+  return TOOL_ACTIVITY_LABELS[name] ?? humanizeToolName(name);
+}
+function describeProposal(proposal) {
+  const args = asRecord(proposal.args);
+  const workflowYaml = nonEmptyStr(args.yaml);
+  const workflowPreview = workflowYaml ? {
+    label: "Workflow definition",
+    content: workflowYaml,
+    kind: "workflow"
+  } : null;
+  switch (proposal.name) {
+    case "create_workflow":
+      return { title: "Create workflow", preview: workflowPreview, fields: [] };
+    // author_workflow creates a workflow PLUS the new skills it needs in one
+    // unit; show the YAML and name each new skill rather than dumping the raw
+    // skills JSON (the card is the canonical, readable view of the proposal).
+    case "author_workflow":
+      return {
+        title: "Create workflow",
+        preview: workflowPreview,
+        fields: [],
+        skills: parseProposalSkills(args.skills)
+      };
+    case "update_workflow":
+      return {
+        title: "Update workflow",
+        preview: workflowPreview,
+        fields: [{ label: "Workflow id", value: str(args.id) }]
+      };
+    case "set_workflow_enabled":
+      return {
+        title: args.enabled ? "Enable workflow" : "Disable workflow",
+        preview: null,
+        fields: [{ label: "Workflow id", value: str(args.id) }]
+      };
+    case "create_skill": {
+      const prompt = nonEmptyStr(args.systemPrompt);
+      const fields = [
+        { label: "Name", value: str(args.name) }
+      ];
+      if (nonEmptyStr(args.description))
+        fields.push({ label: "Description", value: str(args.description) });
+      return {
+        title: "Create skill",
+        preview: prompt ? { label: "Instructions", content: prompt, kind: "text" } : null,
+        fields
+      };
+    }
+    case "update_skill": {
+      const prompt = nonEmptyStr(args.systemPrompt);
+      const fields = [
+        { label: "Skill id", value: str(args.id) }
+      ];
+      if (nonEmptyStr(args.name))
+        fields.push({ label: "Name", value: str(args.name) });
+      if (nonEmptyStr(args.description))
+        fields.push({ label: "Description", value: str(args.description) });
+      return {
+        title: "Update skill",
+        preview: prompt ? { label: "Instructions", content: prompt, kind: "text" } : null,
+        fields
+      };
+    }
+    case "delete_skill":
+      return {
+        title: "Delete skill",
+        preview: null,
+        fields: [{ label: "Skill id", value: str(args.id) }]
+      };
+    case "create_api_key": {
+      const fields = [
+        { label: "Name", value: str(args.name) }
+      ];
+      if (args.product != null)
+        fields.push({ label: "Product", value: str(args.product) });
+      if (args.budgetUsd != null)
+        fields.push({ label: "Budget (USD)", value: str(args.budgetUsd) });
+      return { title: "Create API key", preview: null, fields };
+    }
+    case "revoke_api_key":
+      return {
+        title: "Revoke API key",
+        preview: null,
+        fields: [{ label: "Key id", value: str(args.keyId) }]
+      };
+    case "invoke_integration": {
+      const fields = [
+        { label: "Action", value: str(args.path) }
+      ];
+      if (args.input != null)
+        fields.push({ label: "Input", value: str(args.input) });
+      return { title: "Run integration action", preview: null, fields };
+    }
+    default: {
+      const fields = Object.entries(args).map(([label, value]) => ({
+        label,
+        value: str(value)
+      }));
+      return { title: humanizeToolName(proposal.name), preview: null, fields };
+    }
+  }
+}
+function describeOutcome(name, output) {
+  const o = asRecord(output);
+  switch (name) {
+    case "author_workflow":
+    case "create_workflow": {
+      const wf = asRecord(o.workflow);
+      const skillCount = Array.isArray(o.skills) ? o.skills.length : 0;
+      if (wf.name) {
+        return skillCount > 0 ? `Created workflow "${str(wf.name)}" and ${skillCount} skill${skillCount === 1 ? "" : "s"}.` : `Created workflow "${str(wf.name)}".`;
+      }
+      return "Workflow created.";
+    }
+    case "update_workflow": {
+      const wf = asRecord(o.workflow);
+      return wf.name ? `Updated workflow "${str(wf.name)}".` : "Workflow updated.";
+    }
+    case "set_workflow_enabled": {
+      const wf = asRecord(o.workflow);
+      return wf.enabled ? "Workflow enabled." : "Workflow disabled.";
+    }
+    case "create_api_key":
+      return o.prefix ? `Created API key (${str(o.prefix)}\u2026). Copy it from the API Keys page.` : "API key created.";
+    case "revoke_api_key":
+      return "API key revoked.";
+    case "invoke_integration":
+      return "Integration action completed.";
+    default:
+      return "Action completed.";
+  }
+}
+function describeFailure(output) {
+  const o = asRecord(output);
+  const errors = Array.isArray(o.errors) ? o.errors : [];
+  const joined = errors.map((e) => typeof e === "string" ? e : str(asRecord(e).message)).filter((m) => m.length > 0).join("; ");
+  if (joined) return joined;
+  if (typeof o.message === "string" && o.message) return o.message;
+  if (o.notFound === true) return "That no longer exists.";
+  if (o.conflict === true) return "It changed since it was loaded. Try again.";
+  return "The action could not be completed.";
+}
+function isLowBalance(balanceUsd) {
+  return balanceUsd != null && balanceUsd < LOW_BALANCE_THRESHOLD;
+}
+function resolveConfirmation(name, result) {
+  if (result.ok) {
+    const out = asRecord(result.output);
+    if (out.ok === false && out.code === "NOT_CONNECTED") {
+      return {
+        statusText: null,
+        error: {
+          code: "INTEGRATION_DISCONNECTED",
+          message: str(out.message) || "That integration isn't connected."
+        }
+      };
+    }
+    if (out.created === false || out.updated === false || out.deleted === false || out.ok === false) {
+      return {
+        statusText: null,
+        error: { code: "TOOL_FAILED", message: describeFailure(result.output) }
+      };
+    }
+    return { statusText: describeOutcome(name, result.output), error: null };
+  }
+  return {
+    statusText: null,
+    error: { code: "TOOL_FAILED", message: result.error }
+  };
+}
+
+// src/assistant/reducer.ts
+var MAX_MESSAGES = 200;
+function capMessages(messages) {
+  return messages.length > MAX_MESSAGES ? messages.slice(-MAX_MESSAGES) : messages;
+}
+function initialAssistantState() {
+  return {
+    ownerId: null,
+    threadId: null,
+    messages: [],
+    status: "idle",
+    streamingId: null,
+    streamBaseId: null,
+    segmentSeq: 0,
+    pendingProposals: [],
+    usage: null,
+    model: null,
+    reasoning: null,
+    error: null
+  };
+}
+function selectVisibleState(state, userId) {
+  return state.ownerId === userId ? state : initialAssistantState();
+}
+function dropEmptyStreaming(messages, streamingId) {
+  if (!streamingId) return messages;
+  const msg = messages.find((m) => m.id === streamingId);
+  if (msg && msg.role === "assistant" && msg.text === "") {
+    return messages.filter((m) => m.id !== streamingId);
+  }
+  return messages;
+}
+function appendDelta(messages, streamingId, text) {
+  if (!streamingId) return messages;
+  return messages.map(
+    (m) => m.id === streamingId ? { ...m, text: m.text + text } : m
+  );
+}
+function applyStreamEvent(state, event) {
+  switch (event.type) {
+    case "thread":
+      return {
+        ...state,
+        threadId: event.data.threadId,
+        // The model the server actually ran this turn against (lets the picker
+        // reflect reality even when the user never explicitly chose one).
+        model: event.data.model ?? state.model
+      };
+    case "delta": {
+      if (state.streamingId) {
+        return {
+          ...state,
+          messages: appendDelta(
+            state.messages,
+            state.streamingId,
+            event.data.text
+          )
+        };
+      }
+      if (!state.streamBaseId) return state;
+      const segmentSeq = state.segmentSeq + 1;
+      const id = `${state.streamBaseId}-s${segmentSeq}`;
+      return {
+        ...state,
+        segmentSeq,
+        streamingId: id,
+        messages: capMessages([
+          ...state.messages,
+          { id, role: "assistant", text: event.data.text }
+        ])
+      };
+    }
+    case "reasoning":
+      return {
+        ...state,
+        reasoning: (state.reasoning ?? "") + event.data.text
+      };
+    case "tool_call": {
+      const trimmed = dropEmptyStreaming(state.messages, state.streamingId);
+      const chipId = `tool-${event.data.callId}`;
+      if (trimmed.some((m) => m.id === chipId)) {
+        return { ...state, messages: trimmed, streamingId: null };
+      }
+      const chip = {
+        id: chipId,
+        role: "tool",
+        text: "",
+        tool: { name: event.data.name, status: "running" }
+      };
+      return {
+        ...state,
+        streamingId: null,
+        messages: capMessages([...trimmed, chip])
+      };
+    }
+    case "tool_result": {
+      const chipId = `tool-${event.data.callId}`;
+      const status = event.data.ok ? "ok" : "failed";
+      const errText = event.data.ok ? "" : event.data.error?.message ?? "unknown error";
+      if (state.messages.some((m) => m.id === chipId)) {
+        return {
+          ...state,
+          messages: state.messages.map(
+            (m) => m.id === chipId ? { ...m, text: errText, tool: { name: event.data.name, status } } : m
+          )
+        };
+      }
+      const chip = {
+        id: chipId,
+        role: "tool",
+        text: errText,
+        tool: { name: event.data.name, status }
+      };
+      return { ...state, messages: capMessages([...state.messages, chip]) };
+    }
+    case "tool_proposal": {
+      if (state.pendingProposals.some((p) => p.callId === event.data.callId)) {
+        return state;
+      }
+      return {
+        ...state,
+        pendingProposals: [...state.pendingProposals, event.data]
+      };
+    }
+    case "usage":
+      return {
+        ...state,
+        usage: {
+          costUsd: event.data.costUsd,
+          balanceUsd: event.data.balanceUsd,
+          replayed: event.data.replayed ?? false
+        }
+      };
+    case "done": {
+      let messages = dropEmptyStreaming(state.messages, state.streamingId);
+      if (event.data.capped) {
+        messages = capMessages([
+          ...messages,
+          {
+            id: `cap-${event.data.turnId}`,
+            role: "status",
+            text: "I reached the step limit for this turn. Ask me to continue and I'll pick up where I left off."
+          }
+        ]);
+      }
+      return {
+        ...state,
+        messages,
+        streamingId: null,
+        status: state.pendingProposals.length > 0 ? "awaiting_confirm" : "idle"
+      };
+    }
+    case "error": {
+      const messages = dropEmptyStreaming(state.messages, state.streamingId);
+      return {
+        ...state,
+        messages,
+        streamingId: null,
+        status: "idle",
+        // A turn that didn't complete cleanly leaves no confirmable action: a
+        // proposal buffered before the failure must not stay actionable.
+        pendingProposals: [],
+        error: { code: event.data.code, message: event.data.message }
+      };
+    }
+  }
+}
+function assistantReducer(state, action) {
+  switch (action.type) {
+    case "send":
+      return {
+        ...state,
+        messages: capMessages([
+          ...state.messages,
+          { id: action.messageId, role: "user", text: action.text },
+          { id: action.assistantId, role: "assistant", text: "" }
+        ]),
+        status: "streaming",
+        streamingId: action.assistantId,
+        // The first bubble is segment 0; tool-finalized segments derive their id
+        // from this base, so they stay unique across turns.
+        streamBaseId: action.assistantId,
+        segmentSeq: 0,
+        usage: null,
+        reasoning: null,
+        error: null
+      };
+    case "stream":
+      return applyStreamEvent(state, action.event);
+    case "stream_failed": {
+      const messages = dropEmptyStreaming(state.messages, state.streamingId);
+      return {
+        ...state,
+        messages,
+        streamingId: null,
+        status: "idle",
+        // A failed turn leaves no confirmable action (see the `error` case).
+        pendingProposals: [],
+        error: action.error
+      };
+    }
+    case "proposal_resolved": {
+      const pendingProposals = state.pendingProposals.filter(
+        (p) => p.callId !== action.callId
+      );
+      const messages = action.status ? capMessages([...state.messages, action.status]) : state.messages;
+      return {
+        ...state,
+        messages,
+        pendingProposals,
+        error: action.error,
+        status: pendingProposals.length > 0 ? "awaiting_confirm" : state.status === "awaiting_confirm" ? "idle" : state.status
+      };
+    }
+    case "proposal_retry_failed": {
+      const pendingProposals = state.pendingProposals.map(
+        (p) => p.callId === action.callId ? { ...p, retryError: action.message } : p
+      );
+      return {
+        ...state,
+        pendingProposals,
+        status: pendingProposals.length > 0 ? "awaiting_confirm" : state.status === "awaiting_confirm" ? "idle" : state.status
+      };
+    }
+    case "stopped":
+      return {
+        ...state,
+        messages: dropEmptyStreaming(state.messages, state.streamingId),
+        status: "idle",
+        streamingId: null,
+        pendingProposals: []
+      };
+    case "hydrate":
+      return {
+        ...initialAssistantState(),
+        ownerId: action.ownerId,
+        threadId: action.threadId,
+        messages: action.messages
+      };
+    case "restore_history":
+      if (state.ownerId !== action.ownerId || state.threadId !== action.threadId || state.status !== "idle" || state.messages.length > 0 || state.pendingProposals.length > 0) {
+        return state;
+      }
+      return {
+        ...state,
+        messages: capMessages(action.messages),
+        pendingProposals: action.proposals,
+        status: action.proposals.length > 0 ? "awaiting_confirm" : state.status
+      };
+    case "thread_gone":
+      if (state.ownerId !== action.ownerId || state.threadId !== action.threadId || state.status !== "idle" || state.messages.length > 0) {
+        return state;
+      }
+      return { ...state, threadId: null };
+    case "history_failed":
+      if (state.ownerId !== action.ownerId || state.threadId !== action.threadId || state.status !== "idle" || state.messages.length > 0) {
+        return state;
+      }
+      return {
+        ...initialAssistantState(),
+        ownerId: state.ownerId,
+        error: action.error
+      };
+    case "switch_thread":
+      if (state.threadId === action.threadId) return state;
+      return {
+        ...initialAssistantState(),
+        ownerId: state.ownerId,
+        threadId: action.threadId
+      };
+    case "reset":
+      return { ...initialAssistantState(), ownerId: state.ownerId };
+  }
+}
+
+// src/assistant/useAssistantChat.ts
+var EMPTY_IDS = /* @__PURE__ */ new Set();
+var WORKFLOW_MUTATING_TOOLS = /* @__PURE__ */ new Set([
+  "create_workflow",
+  "author_workflow",
+  "update_workflow",
+  "set_workflow_enabled"
+]);
+function statusMessage(text) {
+  return { id: `status-${uuid()}`, role: "status", text };
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function useAssistantChat(userId, options) {
+  const [state, dispatch] = useReducer(
+    assistantReducer,
+    userId,
+    (uid) => {
+      return {
+        ...initialAssistantState(),
+        ownerId: uid,
+        threadId: loadThread(uid).threadId
+      };
+    }
+  );
+  const abortRef = useRef(null);
+  const historyAbortRef = useRef(null);
+  const hydratedUserRef = useRef(userId);
+  const streamSeqRef = useRef(0);
+  const confirmSeqRef = useRef(0);
+  const stateRef = useRef(state);
+  const userIdRef = useRef(userId);
+  stateRef.current = state;
+  userIdRef.current = userId;
+  const client = useAssistantClient();
+  const clientRef = useRef(client);
+  clientRef.current = client;
+  const onWorkflowMutationRef = useRef(options?.onWorkflowMutation);
+  onWorkflowMutationRef.current = options?.onWorkflowMutation;
+  const confirmingRef = useRef(/* @__PURE__ */ new Set());
+  const [confirmingIds, setConfirmingIds] = useState(EMPTY_IDS);
+  const sendingRef = useRef(false);
+  const restoringRef = useRef(false);
+  const [restoring, setRestoring] = useState(false);
+  const setRestoringBoth = useCallback((v) => {
+    restoringRef.current = v;
+    setRestoring(v);
+  }, []);
+  const [selectedModel, setSelectedModel] = useState(
+    () => loadThread(userId).model
+  );
+  const selectedModelRef = useRef(selectedModel);
+  selectedModelRef.current = selectedModel;
+  useEffect(() => {
+    if (hydratedUserRef.current === userId) return;
+    streamSeqRef.current += 1;
+    confirmSeqRef.current += 1;
+    abortRef.current?.abort();
+    historyAbortRef.current?.abort();
+    setRestoringBoth(false);
+    sendingRef.current = false;
+    confirmingRef.current.clear();
+    setConfirmingIds(EMPTY_IDS);
+    hydratedUserRef.current = userId;
+    const nextModel = loadThread(userId).model;
+    selectedModelRef.current = nextModel;
+    setSelectedModel(nextModel);
+    dispatch({
+      type: "hydrate",
+      ownerId: userId,
+      threadId: loadThread(userId).threadId,
+      messages: []
+    });
+  }, [userId, setRestoringBoth]);
+  useEffect(() => {
+    const threadId = loadThread(userId).threadId;
+    if (!userId || !threadId) return;
+    const ac = new AbortController();
+    historyAbortRef.current?.abort();
+    historyAbortRef.current = ac;
+    void clientRef.current.fetchThreadHistory(threadId, ac.signal).then((result) => {
+      if (ac.signal.aborted) return;
+      if (result.status === "ok") {
+        if (result.messages.length > 0 || result.proposals.length > 0) {
+          dispatch({
+            type: "restore_history",
+            ownerId: userId,
+            threadId,
+            messages: result.messages,
+            proposals: result.proposals
+          });
+        }
+      } else if (result.status === "gone") {
+        dispatch({ type: "thread_gone", ownerId: userId, threadId });
+      }
+    }).catch(() => {
+    });
+    return () => ac.abort();
+  }, [userId]);
+  useEffect(() => {
+    if (state.status === "streaming") return;
+    if (state.ownerId !== userIdRef.current) return;
+    saveThread(state.ownerId, {
+      threadId: state.threadId,
+      model: selectedModelRef.current
+    });
+  }, [state.ownerId, state.threadId, state.status]);
+  useEffect(() => {
+    return () => abortRef.current?.abort();
+  }, []);
+  const send = useCallback((message) => {
+    if (sendingRef.current) return;
+    const text = message.trim();
+    const current = stateRef.current;
+    if (current.ownerId !== userIdRef.current) return;
+    if (restoringRef.current) return;
+    if (!text || current.status === "streaming") return;
+    if (current.pendingProposals.length > 0) return;
+    dispatch({
+      type: "send",
+      messageId: uuid(),
+      assistantId: uuid(),
+      text
+    });
+    const seq = ++streamSeqRef.current;
+    const ac = new AbortController();
+    abortRef.current = ac;
+    sendingRef.current = true;
+    clientRef.current.streamChat(
+      {
+        message: text,
+        // null → omit, so the server applies its default model.
+        model: selectedModelRef.current ?? void 0,
+        threadId: current.threadId ?? void 0,
+        turnKey: uuid()
+      },
+      (event) => {
+        if (streamSeqRef.current === seq) dispatch({ type: "stream", event });
+      },
+      ac.signal
+    ).catch((err) => {
+      if (ac.signal.aborted || streamSeqRef.current !== seq) return;
+      dispatch({
+        type: "stream_failed",
+        error: {
+          code: "NETWORK",
+          message: err instanceof Error ? err.message : "The connection failed"
+        }
+      });
+    }).finally(() => {
+      if (streamSeqRef.current === seq) sendingRef.current = false;
+    });
+  }, []);
+  const stop = useCallback(() => {
+    streamSeqRef.current += 1;
+    abortRef.current?.abort();
+    sendingRef.current = false;
+    dispatch({ type: "stopped" });
+  }, []);
+  const confirm = useCallback(async (proposal) => {
+    const pid = proposal.proposalId;
+    if (!pid) {
+      dispatch({
+        type: "proposal_resolved",
+        callId: proposal.callId,
+        status: null,
+        error: {
+          code: "TOOL_FAILED",
+          message: "This action can no longer be confirmed."
+        }
+      });
+      return;
+    }
+    if (confirmingRef.current.has(pid)) return;
+    confirmingRef.current.add(pid);
+    setConfirmingIds(new Set(confirmingRef.current));
+    const seq = confirmSeqRef.current;
+    try {
+      const result = await clientRef.current.confirmProposal(pid);
+      if (confirmSeqRef.current !== seq) return;
+      if (result.ok && result.retryable) {
+        const { error: error2 } = resolveConfirmation(proposal.name, result);
+        dispatch({
+          type: "proposal_retry_failed",
+          callId: proposal.callId,
+          message: error2?.message ?? "Connect the required integration, then confirm again."
+        });
+        return;
+      }
+      const { statusText, error } = resolveConfirmation(proposal.name, result);
+      dispatch({
+        type: "proposal_resolved",
+        callId: proposal.callId,
+        status: statusText ? statusMessage(statusText) : null,
+        error
+      });
+      if (!error && WORKFLOW_MUTATING_TOOLS.has(proposal.name)) {
+        onWorkflowMutationRef.current?.();
+      }
+    } catch (err) {
+      if (confirmSeqRef.current !== seq) return;
+      dispatch({
+        type: "proposal_resolved",
+        callId: proposal.callId,
+        status: null,
+        error: {
+          code: "TOOL_FAILED",
+          message: err instanceof Error ? err.message : "The action could not be completed"
+        }
+      });
+    } finally {
+      if (confirmSeqRef.current === seq) {
+        confirmingRef.current.delete(pid);
+        setConfirmingIds(new Set(confirmingRef.current));
+      }
+    }
+  }, []);
+  const cancel = useCallback((proposal) => {
+    if (proposal.proposalId && confirmingRef.current.has(proposal.proposalId)) {
+      return;
+    }
+    dispatch({
+      type: "proposal_resolved",
+      callId: proposal.callId,
+      status: statusMessage("Action cancelled."),
+      error: null
+    });
+  }, []);
+  const reset = useCallback(() => {
+    streamSeqRef.current += 1;
+    confirmSeqRef.current += 1;
+    abortRef.current?.abort();
+    historyAbortRef.current?.abort();
+    setRestoringBoth(false);
+    sendingRef.current = false;
+    confirmingRef.current.clear();
+    setConfirmingIds(EMPTY_IDS);
+    dispatch({ type: "reset" });
+  }, [setRestoringBoth]);
+  const switchThread = useCallback(
+    (threadId) => {
+      const current = stateRef.current;
+      const uid = userIdRef.current;
+      if (current.ownerId !== uid) return;
+      if (threadId === current.threadId) return;
+      if (current.status === "streaming" || current.pendingProposals.length > 0) {
+        return;
+      }
+      streamSeqRef.current += 1;
+      confirmSeqRef.current += 1;
+      abortRef.current?.abort();
+      sendingRef.current = false;
+      confirmingRef.current.clear();
+      setConfirmingIds(EMPTY_IDS);
+      dispatch({ type: "switch_thread", threadId });
+      setRestoringBoth(true);
+      saveThread(uid, { threadId, model: selectedModelRef.current });
+      const ac = new AbortController();
+      historyAbortRef.current?.abort();
+      historyAbortRef.current = ac;
+      void clientRef.current.fetchThreadHistory(threadId, ac.signal).then((result) => {
+        if (ac.signal.aborted) return;
+        if (result.status === "ok") {
+          if (result.messages.length > 0 || result.proposals.length > 0) {
+            dispatch({
+              type: "restore_history",
+              ownerId: uid,
+              threadId,
+              messages: result.messages,
+              proposals: result.proposals
+            });
+          }
+        } else if (result.status === "gone") {
+          dispatch({ type: "thread_gone", ownerId: uid, threadId });
+        } else {
+          dispatch({
+            type: "history_failed",
+            ownerId: uid,
+            threadId,
+            error: {
+              code: "HISTORY_LOAD_FAILED",
+              message: "Couldn't load that conversation. You're in a new chat \u2014 reopen it from history to try again."
+            }
+          });
+        }
+        setRestoringBoth(false);
+      }).catch(() => {
+        if (!ac.signal.aborted) setRestoringBoth(false);
+      });
+    },
+    [setRestoringBoth]
+  );
+  const setModel = useCallback((model) => {
+    selectedModelRef.current = model;
+    setSelectedModel(model);
+    const currentUserId = userIdRef.current;
+    if (stateRef.current.ownerId === currentUserId) {
+      saveThread(currentUserId, {
+        threadId: stateRef.current.threadId,
+        model
+      });
+    }
+  }, []);
+  useEffect(() => {
+    if (state.error?.code === "MODEL_NOT_ALLOWED" && state.ownerId === userIdRef.current && selectedModelRef.current !== null) {
+      setModel(null);
+    }
+  }, [state.error, state.ownerId, setModel]);
+  const visibleState = selectVisibleState(state, userId);
+  return {
+    state: visibleState,
+    confirmingIds,
+    selectedModel,
+    setModel,
+    send,
+    stop,
+    confirm,
+    cancel,
+    reset,
+    switchThread,
+    restoring
+  };
+}
+
+// src/assistant/useAssistantModels.ts
+import { useEffect as useEffect2, useReducer as useReducer2 } from "react";
+var EMPTY = { default: null, models: [] };
+var byClient = /* @__PURE__ */ new WeakMap();
+function cacheFor(client) {
+  let entry = byClient.get(client);
+  if (!entry) {
+    entry = { cache: null, inflight: null };
+    byClient.set(client, entry);
+  }
+  return entry;
+}
+function useAssistantModels() {
+  const client = useAssistantClient();
+  const [, bump] = useReducer2((n) => n + 1, 0);
+  useEffect2(() => {
+    const entry = cacheFor(client);
+    if (entry.cache) return;
+    let active = true;
+    entry.inflight ??= client.fetchModels();
+    void entry.inflight.then((result) => {
+      if (result.ok) entry.cache = result.data;
+      entry.inflight = null;
+      if (active) bump();
+    }).catch(() => {
+      entry.inflight = null;
+    });
+    return () => {
+      active = false;
+    };
+  }, [client]);
+  return cacheFor(client).cache ?? EMPTY;
+}
+
+// src/assistant/useAssistantThreads.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2, useState as useState2 } from "react";
+function useAssistantThreads(userId) {
+  const client = useAssistantClient();
+  const userRef = useRef2(userId);
+  userRef.current = userId;
+  const clientRef = useRef2(client);
+  clientRef.current = client;
+  const abortRef = useRef2(null);
+  const [state, setState] = useState2(() => ({
+    threads: [],
+    loading: false,
+    loaded: false,
+    ownerUserId: userId,
+    ownerClient: client
+  }));
+  const refresh = useCallback2(() => {
+    const requestedUserId = userRef.current;
+    const requestedClient = clientRef.current;
+    if (!requestedUserId) {
+      setState({
+        threads: [],
+        loading: false,
+        loaded: true,
+        ownerUserId: requestedUserId,
+        ownerClient: requestedClient
+      });
+      return;
+    }
+    abortRef.current?.abort();
+    const ac = new AbortController();
+    abortRef.current = ac;
+    setState((s) => ({
+      ...s,
+      loading: true,
+      ownerUserId: requestedUserId,
+      ownerClient: requestedClient
+    }));
+    const isCurrent = () => !ac.signal.aborted && userRef.current === requestedUserId && clientRef.current === requestedClient;
+    void requestedClient.fetchThreads(ac.signal).then((result) => {
+      if (!isCurrent()) return;
+      setState((s) => ({
+        // null = transient failure: keep the prior list, just drop the spinner.
+        threads: result ?? s.threads,
+        loading: false,
+        loaded: true,
+        ownerUserId: requestedUserId,
+        ownerClient: requestedClient
+      }));
+    }).catch(() => {
+      if (isCurrent()) {
+        setState((s) => ({ ...s, loading: false, loaded: true }));
+      }
+    });
+  }, []);
+  useEffect3(() => () => abortRef.current?.abort(), [userId, client]);
+  const stale = state.ownerUserId !== userId || state.ownerClient !== client;
+  return {
+    threads: stale ? [] : state.threads,
+    loading: stale ? false : state.loading,
+    loaded: stale ? false : state.loaded,
+    refresh
+  };
+}
+
+// src/assistant/AssistantDock.tsx
+import { MessageSquare } from "lucide-react";
+import {
+  useEffect as useEffect5,
+  useRef as useRef5
+} from "react";
+
+// src/assistant/AssistantPanel.tsx
+import { AgentTimeline, ChatInput } from "@tangle-network/ui/chat";
+import { History, Minus, Plus, RotateCcw, X } from "lucide-react";
+import { useState as useState5 } from "react";
+
+// src/assistant/build-timeline.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TOOL_STATUS = {
+  running: "running",
+  ok: "success",
+  failed: "error"
+};
+function assistantIsThinking(state) {
+  if (state.status !== "streaming") return false;
+  const streaming = state.streamingId ? state.messages.find((m) => m.id === state.streamingId) : void 0;
+  return !streaming || streaming.text === "";
+}
+function formatUsd(usd) {
+  return `$${usd.toFixed(usd < 0.01 ? 4 : 2)}`;
+}
+function messageItem(m, streamingId) {
+  switch (m.role) {
+    case "user":
+      return { id: m.id, kind: "message", role: "user", content: m.text };
+    case "assistant": {
+      const isStreaming = m.id === streamingId;
+      if (m.text === "" && isStreaming) return null;
+      return {
+        id: m.id,
+        kind: "message",
+        role: "assistant",
+        content: m.text,
+        isStreaming
+      };
+    }
+    case "status":
+      return { id: m.id, kind: "status", label: m.text };
+    case "tool": {
+      const name = m.tool?.name ?? "tool";
+      const status = TOOL_STATUS[m.tool?.status ?? "running"];
+      const call = {
+        id: m.id,
+        type: "unknown",
+        label: describeToolActivity(name),
+        status,
+        // The tool message's text carries the error text on failure.
+        detail: status === "error" && m.text ? m.text : void 0
+      };
+      return { id: m.id, kind: "tool", call };
+    }
+  }
+}
+function buildAssistantTimeline(state, renderProposal) {
+  const items = [];
+  for (const m of state.messages) {
+    const item = messageItem(m, state.streamingId);
+    if (item) items.push(item);
+  }
+  if (assistantIsThinking(state) && state.reasoning) {
+    items.push({
+      id: "reasoning",
+      kind: "custom",
+      content: /* @__PURE__ */ jsx2("p", { className: "whitespace-pre-wrap px-1 text-muted-foreground text-xs italic", children: state.reasoning })
+    });
+  }
+  if (state.status !== "streaming" && state.usage && state.usage.costUsd != null) {
+    items.push({
+      id: "usage",
+      kind: "status",
+      label: state.usage.replayed ? "Replayed from a previous turn \u2014 no charge." : `This turn cost ${formatUsd(state.usage.costUsd)}.`
+    });
+  }
+  for (const p of state.pendingProposals) {
+    items.push({
+      id: `proposal-${p.callId}`,
+      kind: "custom",
+      content: renderProposal(p)
+    });
+  }
+  return items;
+}
+
+// src/assistant/ProposalCard.tsx
+import { useState as useState3 } from "react";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function ProposalCard({
+  proposal,
+  confirming,
+  onConfirm,
+  onCancel,
+  navigate,
+  renderGraph
+}) {
+  const view = describeProposal(proposal);
+  const [tab, setTab] = useState3("graph");
+  const isWorkflow = view.preview?.kind === "workflow";
+  const showGraph = isWorkflow && !!renderGraph;
+  return /* @__PURE__ */ jsxs("div", { className: "rounded-lg border border-primary/40 bg-card p-3 text-sm", children: [
+    /* @__PURE__ */ jsx3("p", { className: "font-medium text-foreground", children: view.title }),
+    /* @__PURE__ */ jsx3("p", { className: "text-muted-foreground text-xs", children: "Confirm to run this action on your account." }),
+    view.fields.length > 0 && /* @__PURE__ */ jsx3("dl", { className: "mt-2 space-y-1", children: view.fields.map((f) => /* @__PURE__ */ jsxs("div", { className: "flex gap-2 text-xs", children: [
+      /* @__PURE__ */ jsx3("dt", { className: "shrink-0 text-muted-foreground", children: f.label }),
+      /* @__PURE__ */ jsx3("dd", { className: "truncate text-foreground", title: f.value, children: f.value })
+    ] }, f.label)) }),
+    view.skills && view.skills.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx3("p", { className: "text-muted-foreground text-xs", children: "New skills" }),
+      /* @__PURE__ */ jsx3("ul", { className: "mt-1 space-y-0.5", children: view.skills.map((s) => /* @__PURE__ */ jsxs("li", { className: "text-foreground text-xs", children: [
+        /* @__PURE__ */ jsx3("span", { className: "font-medium", children: s.name }),
+        s.description ? /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+          " \u2014 ",
+          s.description
+        ] }) : null
+      ] }, s.name)) })
+    ] }),
+    view.preview && /* @__PURE__ */ jsxs("div", { className: "mt-2", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsx3("p", { className: "text-muted-foreground text-xs", children: view.preview.label }),
+        showGraph && /* @__PURE__ */ jsxs("div", { className: "flex gap-2 text-xs", children: [
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: () => setTab("graph"),
+              className: tab === "graph" ? "text-foreground" : "text-muted-foreground",
+              children: "Graph"
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: () => setTab("yaml"),
+              className: tab === "yaml" ? "text-foreground" : "text-muted-foreground",
+              children: "YAML"
+            }
+          )
+        ] })
+      ] }),
+      showGraph && tab === "graph" ? /* @__PURE__ */ jsx3("div", { className: "mt-1 h-48 overflow-hidden rounded border border-border", children: renderGraph?.(view.preview.content) }) : /* @__PURE__ */ jsx3("pre", { className: "mt-1 max-h-48 overflow-auto rounded border border-border bg-muted/50 p-2 text-xs", children: /* @__PURE__ */ jsx3("code", { children: view.preview.content }) })
+    ] }),
+    proposal.requirements && proposal.requirements.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-3 rounded border border-border p-2", children: [
+      /* @__PURE__ */ jsx3("p", { className: "text-muted-foreground text-xs", children: "Integrations" }),
+      /* @__PURE__ */ jsx3("ul", { className: "mt-1 space-y-1", children: proposal.requirements.map((r) => /* @__PURE__ */ jsx3(
+        RequirementRow,
+        {
+          req: r,
+          navigate
+        },
+        `${r.provider}-${r.kind ?? "integration"}`
+      )) }),
+      /* @__PURE__ */ jsx3("p", { className: "mt-1 text-muted-foreground text-xs", children: "Connect the items above, then confirm \u2014 your proposal stays here until you do." })
+    ] }),
+    proposal.retryError && /* @__PURE__ */ jsx3("p", { role: "alert", className: "mt-2 text-destructive text-xs", children: proposal.retryError }),
+    /* @__PURE__ */ jsxs("div", { className: "mt-3 flex gap-2", children: [
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          onClick: onConfirm,
+          disabled: confirming || !proposal.proposalId,
+          className: "rounded bg-primary px-3 py-1.5 text-primary-foreground text-sm disabled:opacity-50",
+          children: confirming ? "Confirming\u2026" : "Confirm"
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          onClick: onCancel,
+          disabled: confirming,
+          className: "rounded border border-border px-3 py-1.5 text-foreground text-sm disabled:opacity-50",
+          children: "Cancel"
+        }
+      )
+    ] })
+  ] });
+}
+function openConnect(target, navigate) {
+  if (target.startsWith("//")) return;
+  let url;
+  try {
+    url = new URL(target, window.location.origin);
+  } catch {
+    return;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(target)) {
+    window.open(url.href, "_blank", "noopener,noreferrer");
+  } else if (navigate) {
+    navigate(target);
+  } else {
+    window.location.assign(url.href);
+  }
+}
+function RequirementRow({
+  req,
+  navigate
+}) {
+  const label = providerLabel(req.provider);
+  const isApp = req.kind === "github_app";
+  const kindLabel = isApp ? `${label} App` : label;
+  const statusText = req.connected ? isApp ? "installed" : "connected" : isApp ? "not installed" : "not connected";
+  const canConnect = !req.connected && req.connectUrl !== null;
+  const target = req.connectUrl ?? "/app/integrations";
+  return /* @__PURE__ */ jsxs("li", { className: "flex items-center justify-between gap-2 text-xs", children: [
+    /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx3(
+        "span",
+        {
+          "aria-hidden": "true",
+          className: `h-2 w-2 rounded-full ${req.connected ? "bg-primary" : "border border-muted-foreground"}`
+        }
+      ),
+      /* @__PURE__ */ jsx3("span", { className: "text-foreground", children: kindLabel }),
+      /* @__PURE__ */ jsx3("span", { className: "text-muted-foreground", children: statusText })
+    ] }),
+    canConnect && /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => openConnect(target, navigate),
+        className: "shrink-0 text-primary",
+        children: [
+          isApp ? "Install" : "Connect",
+          " \u2192"
+        ]
+      }
+    )
+  ] });
+}
+
+// src/assistant/usePanelPrefs.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useRef as useRef3, useState as useState4 } from "react";
+var MIN_PANEL_WIDTH = 360;
+var DEFAULT_PANEL_WIDTH = 448;
+var MAX_PANEL_WIDTH_FRACTION = 0.95;
+var MIN_FONT_SCALE = 0.875;
+var MAX_FONT_SCALE = 1.5;
+var DEFAULT_FONT_SCALE = 1;
+var FONT_SCALE_STEP = 0.125;
+var WIDTH_KEY = "assistant.panel.width";
+var FONT_SCALE_KEY = "assistant.panel.fontScale";
+function readNumber(key) {
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (raw == null || raw.trim() === "") return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+function writeNumber(key, value) {
+  try {
+    window.localStorage.setItem(key, String(value));
+  } catch {
+  }
+}
+function maxPanelWidth() {
+  if (typeof window === "undefined") return 9999;
+  return Math.round(window.innerWidth * MAX_PANEL_WIDTH_FRACTION);
+}
+function clampWidth(value) {
+  return Math.min(
+    Math.max(Math.round(value), MIN_PANEL_WIDTH),
+    maxPanelWidth()
+  );
+}
+function clampScale(value) {
+  const stepped = Math.round(value / FONT_SCALE_STEP) * FONT_SCALE_STEP;
+  return Math.min(Math.max(stepped, MIN_FONT_SCALE), MAX_FONT_SCALE);
+}
+function usePanelWidth() {
+  const [width, setWidthState] = useState4(DEFAULT_PANEL_WIDTH);
+  const [maxWidth, setMaxWidth] = useState4(() => maxPanelWidth());
+  const desiredRef = useRef3(DEFAULT_PANEL_WIDTH);
+  useEffect4(() => {
+    setMaxWidth(maxPanelWidth());
+    const stored = readNumber(WIDTH_KEY);
+    if (stored != null) {
+      desiredRef.current = Math.max(Math.round(stored), MIN_PANEL_WIDTH);
+      setWidthState(clampWidth(stored));
+    }
+  }, []);
+  useEffect4(() => {
+    const onResize = () => {
+      setMaxWidth(maxPanelWidth());
+      setWidthState(clampWidth(desiredRef.current));
+    };
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  }, []);
+  const setWidth = useCallback3((next) => {
+    const clamped = clampWidth(next);
+    desiredRef.current = clamped;
+    writeNumber(WIDTH_KEY, clamped);
+    setWidthState(clamped);
+  }, []);
+  const previewWidth = useCallback3((next) => {
+    setWidthState(clampWidth(next));
+  }, []);
+  const nudgeWidth = useCallback3((deltaPx) => {
+    const clamped = clampWidth(desiredRef.current + deltaPx);
+    desiredRef.current = clamped;
+    writeNumber(WIDTH_KEY, clamped);
+    setWidthState(clamped);
+  }, []);
+  return { width, maxWidth, setWidth, previewWidth, nudgeWidth };
+}
+function useFontScale() {
+  const [scale, setScaleState] = useState4(DEFAULT_FONT_SCALE);
+  useEffect4(() => {
+    const stored = readNumber(FONT_SCALE_KEY);
+    if (stored != null) setScaleState(clampScale(stored));
+  }, []);
+  const step = useCallback3((delta) => {
+    setScaleState((prev) => {
+      const clamped = clampScale(prev + delta);
+      writeNumber(FONT_SCALE_KEY, clamped);
+      return clamped;
+    });
+  }, []);
+  return {
+    scale,
+    increase: () => step(FONT_SCALE_STEP),
+    decrease: () => step(-FONT_SCALE_STEP),
+    canIncrease: scale < MAX_FONT_SCALE - 1e-9,
+    canDecrease: scale > MIN_FONT_SCALE + 1e-9
+  };
+}
+function useIsDesktop() {
+  const [isDesktop, setIsDesktop] = useState4(
+    () => typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia("(min-width: 768px)").matches : true
+  );
+  useEffect4(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+      return;
+    }
+    const mq = window.matchMedia("(min-width: 768px)");
+    const update = () => setIsDesktop(mq.matches);
+    update();
+    mq.addEventListener("change", update);
+    return () => mq.removeEventListener("change", update);
+  }, []);
+  return isDesktop;
+}
+
+// src/assistant/AssistantPanel.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var EMPTY_STATE = "Ask me to create a workflow, check your usage, or manage your API keys.";
+function defaultFormatMoney(usd) {
+  if (usd == null) return "\u2014";
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD"
+  }).format(usd);
+}
+function AssistantPanel({
+  chat,
+  userId,
+  onClose,
+  navigate,
+  balanceUsd = null,
+  formatMoney = defaultFormatMoney,
+  renderGraph
+}) {
+  const models = useAssistantModels();
+  const threads = useAssistantThreads(userId);
+  const font = useFontScale();
+  const [historyOpen, setHistoryOpen] = useState5(false);
+  const { state } = chat;
+  const effectiveBalance = state.usage?.balanceUsd ?? balanceUsd;
+  const errorView = state.error ? presentError(state.error.code, state.error.message) : null;
+  const low = isLowBalance(effectiveBalance) && !errorView;
+  const streaming = state.status === "streaming";
+  const renderProposal = (proposal) => /* @__PURE__ */ jsx4(
+    ProposalCard,
+    {
+      proposal,
+      confirming: proposal.proposalId ? chat.confirmingIds.has(proposal.proposalId) : false,
+      onConfirm: () => chat.confirm(proposal),
+      onCancel: () => chat.cancel(proposal),
+      navigate,
+      renderGraph
+    }
+  );
+  const items = buildAssistantTimeline(state, renderProposal);
+  const openHistory = () => {
+    setHistoryOpen((v) => {
+      const next = !v;
+      if (next) threads.refresh();
+      return next;
+    });
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "flex h-full flex-col bg-background", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between border-border border-b px-4 py-3", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "flex items-baseline gap-2", children: [
+        /* @__PURE__ */ jsx4("span", { className: "font-medium text-foreground text-sm", children: "Assistant" }),
+        /* @__PURE__ */ jsx4(
+          "span",
+          {
+            "aria-label": "Your credit balance",
+            className: "text-muted-foreground text-xs",
+            children: formatMoney(effectiveBalance)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-1", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center", role: "group", "aria-label": "Text size", children: [
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              onClick: font.decrease,
+              disabled: !font.canDecrease,
+              "aria-label": "Decrease text size",
+              className: "rounded p-1 text-muted-foreground hover:text-foreground disabled:opacity-40",
+              children: /* @__PURE__ */ jsx4(Minus, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              onClick: font.increase,
+              disabled: !font.canIncrease,
+              "aria-label": "Increase text size",
+              className: "rounded p-1 text-muted-foreground hover:text-foreground disabled:opacity-40",
+              children: /* @__PURE__ */ jsx4(Plus, { className: "h-4 w-4" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            onClick: openHistory,
+            "aria-label": "Chat history",
+            "aria-pressed": historyOpen,
+            className: "rounded p-1 text-muted-foreground hover:text-foreground",
+            children: /* @__PURE__ */ jsx4(History, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            onClick: chat.reset,
+            "aria-label": "New chat",
+            className: "rounded p-1 text-muted-foreground hover:text-foreground",
+            children: /* @__PURE__ */ jsx4(RotateCcw, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            onClick: onClose,
+            "aria-label": "Close assistant",
+            className: "rounded p-1 text-muted-foreground hover:text-foreground",
+            children: /* @__PURE__ */ jsx4(X, { className: "h-4 w-4" })
+          }
+        )
+      ] })
+    ] }),
+    models.models.length > 0 && /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 border-border border-b px-4 py-2", children: [
+      /* @__PURE__ */ jsx4(
+        "label",
+        {
+          htmlFor: "assistant-model",
+          className: "text-muted-foreground text-xs",
+          children: "Model"
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "select",
+        {
+          id: "assistant-model",
+          value: chat.selectedModel ?? "",
+          onChange: (e) => chat.setModel(e.target.value || null),
+          className: "rounded border border-border bg-card px-2 py-1 text-foreground text-xs",
+          children: [
+            /* @__PURE__ */ jsx4("option", { value: "", children: models.default ?? "Default" }),
+            models.models.map((m) => /* @__PURE__ */ jsx4("option", { value: m.slug, children: m.label }, m.slug))
+          ]
+        }
+      )
+    ] }),
+    historyOpen && /* @__PURE__ */ jsx4("div", { className: "max-h-48 overflow-y-auto border-border border-b", children: threads.threads.length === 0 ? /* @__PURE__ */ jsx4("p", { className: "px-4 py-3 text-muted-foreground text-xs", children: threads.loaded ? "No past conversations." : "Loading\u2026" }) : /* @__PURE__ */ jsx4("ul", { children: threads.threads.map((t) => /* @__PURE__ */ jsx4("li", { children: /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        onClick: () => {
+          chat.switchThread(t.id);
+          setHistoryOpen(false);
+        },
+        className: "block w-full truncate px-4 py-2 text-left text-foreground text-xs hover:bg-muted/50",
+        children: t.title ?? "Untitled conversation"
+      }
+    ) }, t.id)) }) }),
+    /* @__PURE__ */ jsx4(
+      "div",
+      {
+        role: "log",
+        "aria-label": "Conversation",
+        "aria-live": "polite",
+        className: "min-h-0 flex-1 overflow-y-auto px-2 py-3",
+        style: { fontSize: `${font.scale}rem` },
+        children: /* @__PURE__ */ jsx4(
+          AgentTimeline,
+          {
+            items,
+            isThinking: assistantIsThinking(state),
+            emptyState: /* @__PURE__ */ jsx4("p", { className: "px-4 py-8 text-center text-muted-foreground text-sm", children: EMPTY_STATE })
+          }
+        )
+      }
+    ),
+    errorView && /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        role: "alert",
+        className: "mx-4 mb-2 rounded-lg border border-destructive/40 bg-destructive/5 px-3 py-2 text-sm",
+        children: [
+          /* @__PURE__ */ jsx4("p", { className: "text-foreground", children: errorView.message }),
+          errorView.cta && /* @__PURE__ */ jsxs2(
+            "button",
+            {
+              type: "button",
+              onClick: () => navigate?.(errorView.cta?.to ?? ""),
+              className: "mt-1 text-primary text-xs",
+              children: [
+                errorView.cta.label,
+                " \u2192"
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    low && /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        role: "status",
+        className: "mx-4 mb-2 rounded-lg border border-border bg-muted/40 px-3 py-2 text-sm",
+        children: [
+          /* @__PURE__ */ jsx4("p", { className: "text-foreground", children: "Your credit balance is running low." }),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              onClick: () => navigate?.("/app/billing"),
+              className: "mt-1 text-primary text-xs",
+              children: "Add credits \u2192"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx4("div", { className: "border-border border-t p-2", children: /* @__PURE__ */ jsx4(
+      ChatInput,
+      {
+        onSend: (message) => chat.send(message),
+        onCancel: chat.stop,
+        isStreaming: streaming,
+        disabled: chat.restoring || state.status === "awaiting_confirm",
+        placeholder: "Message the assistant\u2026",
+        inputLabel: null,
+        idleStatus: null,
+        streamingStatus: null
+      }
+    ) })
+  ] });
+}
+
+// src/assistant/launcher.tsx
+import {
+  createContext as createContext2,
+  useCallback as useCallback4,
+  useContext as useContext2,
+  useMemo,
+  useState as useState6
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var AssistantLauncherContext = createContext2(null);
+function AssistantLauncherProvider({
+  children
+}) {
+  const [open, setOpen] = useState6(false);
+  const [seed, setSeed] = useState6(null);
+  const openAssistant = useCallback4((next) => {
+    if (next != null) setSeed(next);
+    setOpen(true);
+  }, []);
+  const closeAssistant = useCallback4(() => setOpen(false), []);
+  const clearSeed = useCallback4(() => setSeed(null), []);
+  const value = useMemo(
+    () => ({ open, seed, openAssistant, closeAssistant, clearSeed }),
+    [open, seed, openAssistant, closeAssistant, clearSeed]
+  );
+  return /* @__PURE__ */ jsx5(AssistantLauncherContext.Provider, { value, children });
+}
+function useAssistantLauncher() {
+  const ctx = useContext2(AssistantLauncherContext);
+  if (!ctx) {
+    throw new Error(
+      "useAssistantLauncher must be used within an AssistantLauncherProvider"
+    );
+  }
+  return ctx;
+}
+
+// src/assistant/ResizeHandle.tsx
+import { useRef as useRef4 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function ResizeHandle({
+  width,
+  maxWidth,
+  onPreview,
+  onCommit,
+  onNudge
+}) {
+  const dragRef = useRef4(null);
+  const onPointerDown = (e) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.currentTarget.setPointerCapture(e.pointerId);
+    dragRef.current = {
+      startX: e.clientX,
+      startWidth: width,
+      lastWidth: width
+    };
+  };
+  const onPointerMove = (e) => {
+    const drag = dragRef.current;
+    if (!drag) return;
+    const next = drag.startWidth + (drag.startX - e.clientX);
+    if (Math.abs(next - drag.lastWidth) < 1) return;
+    drag.lastWidth = next;
+    onPreview(next);
+  };
+  const endDrag = (e) => {
+    const drag = dragRef.current;
+    if (!drag) return;
+    dragRef.current = null;
+    if (e.currentTarget.hasPointerCapture(e.pointerId)) {
+      e.currentTarget.releasePointerCapture(e.pointerId);
+    }
+    onCommit(drag.lastWidth);
+  };
+  const onKeyDown = (e) => {
+    const STEP = 24;
+    if (e.key === "ArrowLeft") {
+      e.preventDefault();
+      onNudge(STEP);
+    } else if (e.key === "ArrowRight") {
+      e.preventDefault();
+      onNudge(-STEP);
+    }
+  };
+  return (
+    // biome-ignore lint/a11y/useSemanticElements: a focusable drag handle is an ARIA window-splitter (role=separator); no native HTML element provides this.
+    /* @__PURE__ */ jsx6(
+      "div",
+      {
+        role: "separator",
+        "aria-orientation": "vertical",
+        "aria-label": "Resize assistant panel",
+        "aria-valuemin": MIN_PANEL_WIDTH,
+        "aria-valuemax": maxWidth,
+        "aria-valuenow": width,
+        tabIndex: 0,
+        onPointerDown,
+        onPointerMove,
+        onPointerUp: endDrag,
+        onPointerCancel: endDrag,
+        onKeyDown,
+        className: "group absolute inset-y-0 left-0 z-10 flex w-2 -translate-x-1/2 cursor-ew-resize touch-none items-center justify-center focus:outline-none",
+        children: /* @__PURE__ */ jsx6(
+          "span",
+          {
+            "aria-hidden": "true",
+            className: "h-10 w-1 rounded-full bg-border transition-colors group-hover:bg-primary group-focus:bg-primary"
+          }
+        )
+      }
+    )
+  );
+}
+
+// src/assistant/AssistantDock.tsx
+import { Fragment, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+function focusableWithin(container) {
+  const selector = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+  return Array.from(container.querySelectorAll(selector)).filter(
+    (el) => el.getClientRects().length > 0
+  );
+}
+function AssistantDock({
+  userId,
+  navigate,
+  balanceUsd = null,
+  formatMoney,
+  renderGraph,
+  onWorkflowMutation
+}) {
+  const { open, openAssistant, closeAssistant } = useAssistantLauncher();
+  const chat = useAssistantChat(userId, { onWorkflowMutation });
+  const isDesktop = useIsDesktop();
+  const { width, maxWidth, setWidth, previewWidth, nudgeWidth } = usePanelWidth();
+  const launcherRef = useRef5(null);
+  const dialogRef = useRef5(null);
+  const returnFocusRef = useRef5(null);
+  const wasOpenRef = useRef5(false);
+  useEffect5(() => {
+    if (!open) return;
+    const onKeyDown = (e) => {
+      if (e.key === "Escape") closeAssistant();
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [open, closeAssistant]);
+  useEffect5(() => {
+    if (open) {
+      if (!wasOpenRef.current && !returnFocusRef.current) {
+        returnFocusRef.current = document.activeElement;
+      }
+      wasOpenRef.current = true;
+      const el = dialogRef.current;
+      if (el) (focusableWithin(el)[0] ?? el).focus();
+    } else if (wasOpenRef.current) {
+      wasOpenRef.current = false;
+      const target = returnFocusRef.current?.isConnected ? returnFocusRef.current : launcherRef.current;
+      target?.focus();
+      returnFocusRef.current = null;
+    }
+  }, [open]);
+  const openDialog = () => {
+    returnFocusRef.current = document.activeElement;
+    openAssistant();
+  };
+  if (!open) {
+    return /* @__PURE__ */ jsx7(
+      "button",
+      {
+        ref: launcherRef,
+        type: "button",
+        onClick: openDialog,
+        "aria-label": "Open assistant",
+        className: "fixed right-4 bottom-4 z-40 flex h-12 w-12 items-center justify-center rounded-full bg-primary text-primary-foreground shadow-lg transition-colors hover:opacity-90 focus:outline-none focus:ring-2 focus:ring-ring",
+        children: /* @__PURE__ */ jsx7(MessageSquare, { className: "h-6 w-6" })
+      }
+    );
+  }
+  const trapTab = (e) => {
+    if (e.key !== "Tab") return;
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    const focusables = focusableWithin(dialog);
+    if (focusables.length === 0) {
+      e.preventDefault();
+      dialog.focus();
+      return;
+    }
+    const first = focusables[0];
+    const last = focusables[focusables.length - 1];
+    const active = document.activeElement;
+    const inside = active instanceof Node && dialog.contains(active);
+    if (e.shiftKey) {
+      if (!inside || active === first || active === dialog) {
+        e.preventDefault();
+        last.focus();
+      }
+    } else if (!inside || active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx7(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: "fixed inset-0 z-40 bg-black/40",
+        onClick: () => closeAssistant()
+      }
+    ),
+    /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        ref: dialogRef,
+        role: "dialog",
+        "aria-label": "Assistant",
+        "aria-modal": "true",
+        tabIndex: -1,
+        onKeyDown: trapTab,
+        style: isDesktop ? { width: `${width}px` } : void 0,
+        className: "fixed inset-y-0 right-0 z-50 flex w-full flex-col border-border border-l shadow-xl focus:outline-none",
+        children: [
+          /* @__PURE__ */ jsx7(
+            AssistantPanel,
+            {
+              chat,
+              userId,
+              onClose: () => closeAssistant(),
+              navigate,
+              balanceUsd,
+              formatMoney,
+              renderGraph
+            },
+            userId ?? "anon"
+          ),
+          isDesktop && /* @__PURE__ */ jsx7(
+            ResizeHandle,
+            {
+              width,
+              maxWidth,
+              onPreview: previewWidth,
+              onCommit: setWidth,
+              onNudge: nudgeWidth
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+export {
+  AssistantClientProvider,
+  AssistantDock,
+  AssistantLauncherProvider,
+  AssistantPanel,
+  ProposalCard,
+  createAssistantClient,
+  useAssistantChat,
+  useAssistantClient,
+  useAssistantLauncher,
+  useAssistantModels,
+  useAssistantThreads
+};