dooers-agents-client 0.1.0

package/dist/main.js

@@ -0,0 +1,927 @@
+import { createContext, useRef, useEffect, useMemo, useCallback, useContext } from 'react';
+import { useStore as useStore$1 } from 'zustand';
+import { useShallow } from 'zustand/shallow';
+import { createStore } from 'zustand/vanilla';
+import { jsx } from 'react/jsx-runtime';
+
+// src/hooks/use-analytics.ts
+
+// src/types.ts
+function isSettingsFieldGroup(item) {
+  return "fields" in item && Array.isArray(item.fields);
+}
+function toUser(w) {
+  if (!w) return void 0;
+  return {
+    userId: w.user_id,
+    userName: w.user_name,
+    userEmail: w.user_email,
+    systemRole: w.system_role,
+    organizationRole: w.organization_role,
+    workspaceRole: w.workspace_role
+  };
+}
+function toThread(w) {
+  return {
+    id: w.id,
+    workerId: w.worker_id,
+    organizationId: w.organization_id,
+    workspaceId: w.workspace_id,
+    owner: toUser(w.owner),
+    users: w.users.map((u) => toUser(u)),
+    title: w.title,
+    createdAt: w.created_at,
+    updatedAt: w.updated_at,
+    lastEventAt: w.last_event_at
+  };
+}
+function toContentPart(w) {
+  switch (w.type) {
+    case "text":
+      return { type: "text", text: w.text };
+    case "image":
+      return { type: "image", url: w.url, mimeType: w.mime_type, alt: w.alt };
+    case "document":
+      return { type: "document", url: w.url, filename: w.filename, mimeType: w.mime_type };
+  }
+}
+function toThreadEvent(w) {
+  return {
+    id: w.id,
+    threadId: w.thread_id,
+    runId: w.run_id,
+    type: w.type,
+    actor: w.actor,
+    author: w.author,
+    user: toUser(w.user),
+    content: w.content?.map(toContentPart),
+    data: w.data,
+    createdAt: w.created_at,
+    clientEventId: w.client_event_id
+  };
+}
+function toRun(w) {
+  return {
+    id: w.id,
+    threadId: w.thread_id,
+    agentId: w.agent_id,
+    status: w.status,
+    startedAt: w.started_at,
+    endedAt: w.ended_at,
+    error: w.error
+  };
+}
+function toSettingsField(w) {
+  return {
+    id: w.id,
+    type: w.type,
+    label: w.label,
+    required: w.required,
+    readonly: w.readonly,
+    value: w.value,
+    placeholder: w.placeholder,
+    options: w.options,
+    min: w.min,
+    max: w.max,
+    rows: w.rows,
+    src: w.src,
+    width: w.width,
+    height: w.height
+  };
+}
+function toSettingsItem(w) {
+  if ("fields" in w && Array.isArray(w.fields)) {
+    const g = w;
+    return {
+      id: g.id,
+      label: g.label,
+      fields: g.fields.map(toSettingsField),
+      collapsible: g.collapsible
+    };
+  }
+  return toSettingsField(w);
+}
+function toAnalyticsEvent(w) {
+  return {
+    event: w.event,
+    timestamp: w.timestamp,
+    workerId: w.worker_id,
+    threadId: w.thread_id,
+    userId: w.user_id,
+    runId: w.run_id,
+    eventId: w.event_id,
+    data: w.data
+  };
+}
+function toWireContentPart(p) {
+  switch (p.type) {
+    case "text":
+      return { type: "text", text: p.text };
+    case "image":
+      return { type: "image", url: p.url, mime_type: p.mimeType, alt: p.alt };
+    case "document":
+      return { type: "document", url: p.url, filename: p.filename, mime_type: p.mimeType };
+  }
+}
+
+// src/client.ts
+var MAX_RECONNECT_ATTEMPTS = 5;
+var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3];
+var SEND_MESSAGE_TIMEOUT = 3e4;
+var WorkerClient = class {
+  ws = null;
+  callbacks;
+  onError = null;
+  url = "";
+  workerId = "";
+  config = {
+    organizationId: "",
+    workspaceId: "",
+    userId: ""
+  };
+  connectFrameId = "";
+  isIntentionallyClosed = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  // Refcounted subscriptions
+  subscriptionRefs = /* @__PURE__ */ new Map();
+  // Track optimistic events for reconciliation
+  pendingOptimistic = /* @__PURE__ */ new Map();
+  // Pending message promises — resolved when event.append arrives with matching clientEventId
+  pendingMessages = /* @__PURE__ */ new Map();
+  // Track last event ID per thread for gap recovery on reconnect
+  lastEventIds = /* @__PURE__ */ new Map();
+  // Pagination
+  lastThreadListCursor = null;
+  isLoadingMore = false;
+  // Event pagination cursors per thread
+  eventPaginationCursors = /* @__PURE__ */ new Map();
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  setOnError(cb) {
+    this.onError = cb;
+  }
+  connect(url, workerId, config) {
+    this.url = url;
+    this.workerId = workerId;
+    this.config = config ?? { organizationId: "", workspaceId: "", userId: "" };
+    this.isIntentionallyClosed = false;
+    this.callbacks.setConnectionStatus("connecting");
+    this.createConnection();
+  }
+  disconnect() {
+    this.isIntentionallyClosed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    for (const [, pending] of this.pendingMessages) {
+      clearTimeout(pending.timer);
+    }
+    this.pendingMessages.clear();
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.callbacks.setConnectionStatus("disconnected");
+  }
+  retry() {
+    this.reconnectAttempts = 0;
+    this.isIntentionallyClosed = false;
+    this.callbacks.setConnectionStatus("connecting");
+    this.createConnection();
+  }
+  // --- Thread operations ---
+  requestThreadList(cursor, limit) {
+    this.send("thread.list", { cursor, limit });
+  }
+  subscribe(threadId) {
+    const refs = this.subscriptionRefs.get(threadId) ?? 0;
+    this.subscriptionRefs.set(threadId, refs + 1);
+    if (refs === 0) {
+      const afterEventId = this.lastEventIds.get(threadId) ?? null;
+      this.send("thread.subscribe", { thread_id: threadId, after_event_id: afterEventId });
+      this.callbacks.addSubscription(threadId);
+    }
+  }
+  unsubscribe(threadId) {
+    const refs = this.subscriptionRefs.get(threadId) ?? 0;
+    if (refs <= 1) {
+      this.subscriptionRefs.delete(threadId);
+      this.lastEventIds.delete(threadId);
+      this.eventPaginationCursors.delete(threadId);
+      this.send("thread.unsubscribe", { thread_id: threadId });
+      this.callbacks.removeSubscription(threadId);
+    } else {
+      this.subscriptionRefs.set(threadId, refs - 1);
+    }
+  }
+  deleteThread(threadId) {
+    this.send("thread.delete", { thread_id: threadId });
+  }
+  loadMoreThreads(limit) {
+    const cursor = this.lastThreadListCursor;
+    if (!cursor) return;
+    this.isLoadingMore = true;
+    this.send("thread.list", { cursor, limit });
+  }
+  loadOlderEvents(threadId, limit) {
+    const cursor = this.eventPaginationCursors.get(threadId);
+    this.send("event.list", {
+      thread_id: threadId,
+      before_event_id: cursor ?? null,
+      limit
+    });
+  }
+  // --- Settings ---
+  subscribeSettings() {
+    this.send("settings.subscribe", { worker_id: this.workerId });
+  }
+  unsubscribeSettings() {
+    this.send("settings.unsubscribe", { worker_id: this.workerId });
+  }
+  patchSetting(fieldId, value) {
+    this.send("settings.patch", { field_id: fieldId, value });
+  }
+  // --- Feedback ---
+  sendFeedback(targetType, targetId, feedback, reason) {
+    this.send("feedback", {
+      target_type: targetType,
+      target_id: targetId,
+      feedback,
+      reason
+    });
+  }
+  // --- Analytics ---
+  subscribeAnalytics() {
+    this.send("analytics.subscribe", { worker_id: this.workerId });
+  }
+  unsubscribeAnalytics() {
+    this.send("analytics.unsubscribe", { worker_id: this.workerId });
+  }
+  // --- Messaging ---
+  sendMessage(params) {
+    const clientEventId = crypto.randomUUID();
+    const content = params.content ? params.content.map(toWireContentPart) : [{ type: "text", text: params.text ?? "" }];
+    const optimisticEvent = {
+      id: `optimistic-${clientEventId}`,
+      threadId: params.threadId ?? "",
+      runId: null,
+      type: "message",
+      actor: "user",
+      author: null,
+      user: {
+        userId: this.config.userId ?? "",
+        userName: this.config.userName,
+        userEmail: this.config.userEmail,
+        systemRole: this.config.systemRole ?? "user",
+        organizationRole: this.config.organizationRole ?? "member",
+        workspaceRole: this.config.workspaceRole ?? "member"
+      },
+      content: params.content ?? [{ type: "text", text: params.text ?? "" }],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (params.threadId) {
+      this.callbacks.addOptimistic(params.threadId, optimisticEvent, clientEventId);
+    }
+    this.pendingOptimistic.set(clientEventId, {
+      threadId: params.threadId ?? "",
+      clientEventId
+    });
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingMessages.delete(clientEventId);
+        reject(new Error("sendMessage timed out waiting for server response"));
+      }, SEND_MESSAGE_TIMEOUT);
+      this.pendingMessages.set(clientEventId, { resolve, timer });
+    });
+    this.send("event.create", {
+      thread_id: params.threadId,
+      client_event_id: clientEventId,
+      event: {
+        type: "message",
+        actor: "user",
+        content
+      }
+    });
+    return promise;
+  }
+  // --- Private ---
+  createConnection() {
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+    }
+    this.ws = new WebSocket(this.url);
+    this.ws.onopen = () => {
+      this.authenticate();
+    };
+    this.ws.onmessage = (e) => {
+      try {
+        const frame = JSON.parse(e.data);
+        this.route(frame);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      if (!this.isIntentionallyClosed) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  authenticate() {
+    this.connectFrameId = crypto.randomUUID();
+    this.sendRaw({
+      id: this.connectFrameId,
+      type: "connect",
+      payload: {
+        worker_id: this.workerId,
+        organization_id: this.config.organizationId ?? "",
+        workspace_id: this.config.workspaceId ?? "",
+        user: {
+          user_id: this.config.userId ?? "",
+          user_name: this.config.userName ?? null,
+          user_email: this.config.userEmail ?? null,
+          system_role: this.config.systemRole ?? "user",
+          organization_role: this.config.organizationRole ?? "member",
+          workspace_role: this.config.workspaceRole ?? "member"
+        },
+        auth_token: this.config.authToken,
+        client: { name: "dooers-agents-client", version: "0.1.0" }
+      }
+    });
+  }
+  route(frame) {
+    switch (frame.type) {
+      case "ack": {
+        if (frame.payload.ack_id === this.connectFrameId) {
+          if (frame.payload.ok) {
+            this.callbacks.setConnectionStatus("connected");
+            this.callbacks.resetReconnect();
+            this.requestThreadList();
+            for (const threadId of this.subscriptionRefs.keys()) {
+              const afterEventId = this.lastEventIds.get(threadId) ?? null;
+              this.send("thread.subscribe", {
+                thread_id: threadId,
+                after_event_id: afterEventId
+              });
+            }
+          } else {
+            this.callbacks.setConnectionStatus("error", frame.payload.error?.message);
+          }
+        } else if (!frame.payload.ok && frame.payload.error) {
+          this.onError?.({
+            code: frame.payload.error.code,
+            message: frame.payload.error.message,
+            frameType: "ack"
+          });
+        }
+        break;
+      }
+      case "thread.list.result": {
+        const threads = frame.payload.threads.map(toThread);
+        const cursor = frame.payload.cursor ?? null;
+        const totalCount = frame.payload.total_count;
+        this.lastThreadListCursor = cursor;
+        if (this.isLoadingMore) {
+          this.callbacks.onThreadListAppend(threads, cursor, totalCount);
+        } else {
+          this.callbacks.onThreadList(threads, cursor, totalCount);
+        }
+        this.isLoadingMore = false;
+        break;
+      }
+      case "thread.snapshot": {
+        const thread = toThread(frame.payload.thread);
+        const events = frame.payload.events.map(toThreadEvent);
+        const runs = (frame.payload.runs ?? []).map(toRun);
+        const lastEvent = events[events.length - 1];
+        if (lastEvent) {
+          this.lastEventIds.set(thread.id, lastEvent.id);
+        }
+        const oldestEvent = events[0];
+        if (oldestEvent) {
+          this.eventPaginationCursors.set(thread.id, oldestEvent.id);
+        }
+        this.callbacks.onThreadSnapshot(thread, events, runs);
+        break;
+      }
+      case "event.append": {
+        const events = frame.payload.events.map(toThreadEvent);
+        for (const event of events) {
+          if (event.clientEventId && this.pendingOptimistic.has(event.clientEventId)) {
+            const pending = this.pendingOptimistic.get(event.clientEventId);
+            if (pending) {
+              this.callbacks.removeOptimistic(pending.threadId, event.clientEventId);
+              this.pendingOptimistic.delete(event.clientEventId);
+            }
+          }
+          if (event.clientEventId && this.pendingMessages.has(event.clientEventId)) {
+            const pendingMessage = this.pendingMessages.get(event.clientEventId);
+            if (pendingMessage) {
+              clearTimeout(pendingMessage.timer);
+              pendingMessage.resolve({ threadId: frame.payload.thread_id });
+              this.pendingMessages.delete(event.clientEventId);
+            }
+          }
+        }
+        const lastEvent = events[events.length - 1];
+        if (lastEvent) {
+          this.lastEventIds.set(frame.payload.thread_id, lastEvent.id);
+        }
+        this.callbacks.onEventAppend(frame.payload.thread_id, events);
+        break;
+      }
+      case "event.list.result": {
+        const events = frame.payload.events.map(toThreadEvent);
+        this.eventPaginationCursors.set(frame.payload.thread_id, frame.payload.cursor);
+        this.callbacks.onEventListResult(
+          frame.payload.thread_id,
+          events,
+          frame.payload.cursor,
+          frame.payload.has_more
+        );
+        break;
+      }
+      case "thread.upsert":
+        this.callbacks.onThreadUpsert(toThread(frame.payload.thread));
+        break;
+      case "thread.deleted":
+        this.callbacks.onThreadDeleted(frame.payload.thread_id);
+        this.lastEventIds.delete(frame.payload.thread_id);
+        break;
+      case "run.upsert":
+        this.callbacks.onRunUpsert(toRun(frame.payload.run));
+        break;
+      case "settings.snapshot": {
+        const fields = frame.payload.fields.map(toSettingsItem);
+        this.callbacks.onSettingsSnapshot(fields, frame.payload.updated_at);
+        break;
+      }
+      case "settings.patch":
+        this.callbacks.onSettingsPatch(
+          frame.payload.field_id,
+          frame.payload.value,
+          frame.payload.updated_at
+        );
+        break;
+      case "feedback.ack":
+        if (frame.payload.ok) {
+          this.callbacks.onFeedbackAck(
+            frame.payload.target_id,
+            frame.payload.feedback
+          );
+        }
+        break;
+      case "analytics.event":
+        this.callbacks.onAnalyticsEvent(toAnalyticsEvent(frame.payload));
+        break;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      this.callbacks.setReconnectFailed();
+      this.callbacks.setConnectionStatus("error", "Connection lost after maximum retries");
+      return;
+    }
+    this.callbacks.setConnectionStatus("disconnected");
+    const delay = RECONNECT_DELAYS[this.reconnectAttempts] ?? 16e3;
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.callbacks.setConnectionStatus("connecting");
+      this.createConnection();
+    }, delay);
+  }
+  send(type, payload) {
+    this.sendRaw({ id: crypto.randomUUID(), type, payload });
+  }
+  sendRaw(frame) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify(frame));
+  }
+};
+function createWorkerStore() {
+  return createStore()((set) => ({
+    connection: {
+      status: "idle",
+      error: null,
+      reconnectAttempts: 0,
+      reconnectFailed: false
+    },
+    threads: {},
+    threadOrder: [],
+    threadListCursor: null,
+    threadListHasMore: false,
+    threadListTotalCount: 0,
+    events: {},
+    eventPagination: {},
+    optimistic: {},
+    optimisticKeys: {},
+    runs: {},
+    settings: {
+      fields: [],
+      updatedAt: null,
+      isLoading: true
+    },
+    feedback: {},
+    analytics: {
+      events: [],
+      counters: { totalRequests: 0, feedbackLikes: 0, feedbackDislikes: 0 }
+    },
+    subscriptions: /* @__PURE__ */ new Set(),
+    loadingThreads: /* @__PURE__ */ new Set(),
+    actions: {
+      setConnectionStatus: (status, error) => set((s) => ({
+        connection: { ...s.connection, status, error: error ?? null }
+      })),
+      setReconnectFailed: () => set((s) => ({
+        connection: { ...s.connection, reconnectFailed: true }
+      })),
+      resetReconnect: () => set((s) => ({
+        connection: { ...s.connection, reconnectAttempts: 0, reconnectFailed: false }
+      })),
+      onThreadList: (threads, cursor, totalCount) => set(() => {
+        const map = {};
+        const order = [];
+        for (const t of threads) {
+          map[t.id] = t;
+          order.push(t.id);
+        }
+        return {
+          threads: map,
+          threadOrder: order,
+          threadListCursor: cursor ?? null,
+          threadListHasMore: cursor != null,
+          threadListTotalCount: totalCount ?? 0
+        };
+      }),
+      onThreadListAppend: (threads, cursor) => set((s) => {
+        const map = { ...s.threads };
+        const order = [...s.threadOrder];
+        for (const t of threads) {
+          if (!map[t.id]) {
+            order.push(t.id);
+          }
+          map[t.id] = t;
+        }
+        return {
+          threads: map,
+          threadOrder: order,
+          threadListCursor: cursor ?? null,
+          threadListHasMore: cursor != null
+        };
+      }),
+      onThreadUpsert: (thread) => set((s) => {
+        const threads = { ...s.threads, [thread.id]: thread };
+        const threadOrder = s.threadOrder.includes(thread.id) ? s.threadOrder : [thread.id, ...s.threadOrder];
+        return { threads, threadOrder };
+      }),
+      onThreadDeleted: (threadId) => set((s) => {
+        const { [threadId]: _, ...threads } = s.threads;
+        const { [threadId]: _e, ...events } = s.events;
+        const { [threadId]: _r, ...runs } = s.runs;
+        const { [threadId]: _o, ...optimistic } = s.optimistic;
+        const { [threadId]: _k, ...optimisticKeys } = s.optimisticKeys;
+        const { [threadId]: _p, ...eventPagination } = s.eventPagination;
+        const threadOrder = s.threadOrder.filter((id) => id !== threadId);
+        const subscriptions = new Set(s.subscriptions);
+        subscriptions.delete(threadId);
+        const loadingThreads = new Set(s.loadingThreads);
+        loadingThreads.delete(threadId);
+        return {
+          threads,
+          threadOrder,
+          events,
+          runs,
+          optimistic,
+          optimisticKeys,
+          eventPagination,
+          subscriptions,
+          loadingThreads
+        };
+      }),
+      onThreadSnapshot: (thread, events, runs) => set((s) => {
+        const threads = { ...s.threads, [thread.id]: thread };
+        const threadOrder = s.threadOrder.includes(thread.id) ? s.threadOrder : [thread.id, ...s.threadOrder];
+        const loadingThreads = new Set(s.loadingThreads);
+        loadingThreads.delete(thread.id);
+        return {
+          threads,
+          threadOrder,
+          events: { ...s.events, [thread.id]: events },
+          runs: { ...s.runs, [thread.id]: runs },
+          loadingThreads
+        };
+      }),
+      onEventAppend: (threadId, newEvents) => set((s) => {
+        const existing = s.events[threadId] ?? [];
+        const existingIds = new Set(existing.map((e) => e.id));
+        const unique = newEvents.filter((e) => !existingIds.has(e.id));
+        return {
+          events: { ...s.events, [threadId]: [...existing, ...unique] }
+        };
+      }),
+      onEventListResult: (threadId, olderEvents, cursor, hasMore) => set((s) => {
+        const existing = s.events[threadId] ?? [];
+        const existingIds = new Set(existing.map((e) => e.id));
+        const unique = olderEvents.filter((e) => !existingIds.has(e.id));
+        return {
+          events: { ...s.events, [threadId]: [...unique, ...existing] },
+          eventPagination: {
+            ...s.eventPagination,
+            [threadId]: { cursor, hasMore }
+          }
+        };
+      }),
+      onRunUpsert: (run) => set((s) => {
+        const existing = s.runs[run.threadId] ?? [];
+        const idx = existing.findIndex((r) => r.id === run.id);
+        const updated = idx >= 0 ? existing.map((r) => r.id === run.id ? run : r) : [...existing, run];
+        return { runs: { ...s.runs, [run.threadId]: updated } };
+      }),
+      addOptimistic: (threadId, event, clientEventId) => set((s) => ({
+        optimistic: {
+          ...s.optimistic,
+          [threadId]: [...s.optimistic[threadId] ?? [], event]
+        },
+        optimisticKeys: {
+          ...s.optimisticKeys,
+          [threadId]: [...s.optimisticKeys[threadId] ?? [], clientEventId]
+        }
+      })),
+      removeOptimistic: (threadId, clientEventId) => set((s) => {
+        const keys = s.optimisticKeys[threadId] ?? [];
+        const idx = keys.indexOf(clientEventId);
+        if (idx < 0) return s;
+        const newKeys = [...keys];
+        newKeys.splice(idx, 1);
+        const newEvents = [...s.optimistic[threadId] ?? []];
+        newEvents.splice(idx, 1);
+        return {
+          optimistic: { ...s.optimistic, [threadId]: newEvents },
+          optimisticKeys: { ...s.optimisticKeys, [threadId]: newKeys }
+        };
+      }),
+      addSubscription: (threadId) => set((s) => {
+        const subscriptions = new Set(s.subscriptions);
+        subscriptions.add(threadId);
+        const loadingThreads = new Set(s.loadingThreads);
+        loadingThreads.add(threadId);
+        return { subscriptions, loadingThreads };
+      }),
+      removeSubscription: (threadId) => set((s) => {
+        const subscriptions = new Set(s.subscriptions);
+        subscriptions.delete(threadId);
+        const loadingThreads = new Set(s.loadingThreads);
+        loadingThreads.delete(threadId);
+        return { subscriptions, loadingThreads };
+      }),
+      onSettingsSnapshot: (fields, updatedAt) => set(() => ({
+        settings: { fields, updatedAt, isLoading: false }
+      })),
+      onSettingsPatch: (fieldId, value, updatedAt) => set((s) => ({
+        settings: {
+          ...s.settings,
+          updatedAt,
+          fields: s.settings.fields.map((item) => {
+            if (isSettingsFieldGroup(item)) {
+              const hasField = item.fields.some((f) => f.id === fieldId);
+              if (hasField) {
+                return {
+                  ...item,
+                  fields: item.fields.map((f) => f.id === fieldId ? { ...f, value } : f)
+                };
+              }
+              return item;
+            }
+            return item.id === fieldId ? { ...item, value } : item;
+          })
+        }
+      })),
+      onFeedbackAck: (targetId, feedback) => set((s) => ({
+        feedback: { ...s.feedback, [targetId]: feedback }
+      })),
+      onAnalyticsEvent: (event) => set((s) => {
+        const events = [...s.analytics.events, event];
+        const trimmed = events.length > 50 ? events.slice(-50) : events;
+        const counters = { ...s.analytics.counters };
+        if (event.event === "feedback.like") {
+          counters.feedbackLikes += 1;
+        } else if (event.event === "feedback.dislike") {
+          counters.feedbackDislikes += 1;
+        } else {
+          counters.totalRequests += 1;
+        }
+        return { analytics: { events: trimmed, counters } };
+      }),
+      resetAnalytics: () => set(() => ({
+        analytics: {
+          events: [],
+          counters: { totalRequests: 0, feedbackLikes: 0, feedbackDislikes: 0 }
+        }
+      }))
+    }
+  }));
+}
+var WorkerContext = createContext(null);
+function WorkerProvider({
+  url,
+  workerId,
+  organizationId,
+  workspaceId,
+  userId,
+  userName,
+  userEmail,
+  systemRole,
+  organizationRole,
+  workspaceRole,
+  authToken,
+  onError,
+  children
+}) {
+  const storeRef = useRef(void 0);
+  const clientRef = useRef(void 0);
+  if (!storeRef.current) {
+    storeRef.current = createWorkerStore();
+    clientRef.current = new WorkerClient(storeRef.current.getState().actions);
+  }
+  useEffect(() => {
+    clientRef.current?.setOnError(onError ?? null);
+  }, [onError]);
+  useEffect(() => {
+    if (!url || !workerId) return;
+    clientRef.current?.connect(url, workerId, {
+      organizationId,
+      workspaceId,
+      userId,
+      userName,
+      userEmail,
+      systemRole,
+      organizationRole,
+      workspaceRole,
+      authToken
+    });
+    return () => clientRef.current?.disconnect();
+  }, [
+    url,
+    workerId,
+    organizationId,
+    workspaceId,
+    userId,
+    userName,
+    userEmail,
+    systemRole,
+    organizationRole,
+    workspaceRole,
+    authToken
+  ]);
+  const contextValue = useMemo(
+    () => ({ store: storeRef.current, client: clientRef.current }),
+    []
+  );
+  return /* @__PURE__ */ jsx(WorkerContext.Provider, { value: contextValue, children });
+}
+function useWorkerContext() {
+  const ctx = useContext(WorkerContext);
+  if (!ctx) {
+    throw new Error("useWorkerContext must be used within a <WorkerProvider>");
+  }
+  return ctx;
+}
+function useStore(selector) {
+  const { store } = useWorkerContext();
+  return useStore$1(store, selector);
+}
+function useShallowStore(selector) {
+  const { store } = useWorkerContext();
+  return useStore$1(store, useShallow(selector));
+}
+
+// src/hooks/use-analytics.ts
+function useAnalytics() {
+  const { client } = useWorkerContext();
+  const events = useShallowStore((s) => s.analytics.events);
+  const counters = useShallowStore((s) => s.analytics.counters);
+  const subscribe = useCallback(() => client.subscribeAnalytics(), [client]);
+  const unsubscribe = useCallback(() => client.unsubscribeAnalytics(), [client]);
+  return { events, counters, subscribe, unsubscribe };
+}
+function useConnection() {
+  const { client } = useWorkerContext();
+  const status = useStore((s) => s.connection.status);
+  const error = useStore((s) => s.connection.error);
+  const reconnectFailed = useStore((s) => s.connection.reconnectFailed);
+  const reconnect = useCallback(() => client.retry(), [client]);
+  return { status, error, reconnectFailed, reconnect };
+}
+function useFeedback(targetId, targetType = "event") {
+  const { client } = useWorkerContext();
+  const feedback = useStore((s) => s.feedback[targetId] ?? null);
+  const like = useCallback(
+    (reason) => client.sendFeedback(targetType, targetId, "like", reason),
+    [client, targetType, targetId]
+  );
+  const dislike = useCallback(
+    (reason) => client.sendFeedback(targetType, targetId, "dislike", reason),
+    [client, targetType, targetId]
+  );
+  return { feedback, like, dislike };
+}
+function useMessage() {
+  const { client } = useWorkerContext();
+  const send = useCallback(
+    (params) => {
+      return client.sendMessage(params);
+    },
+    [client]
+  );
+  return { send };
+}
+function useSettings() {
+  const { client } = useWorkerContext();
+  const fields = useShallowStore((s) => s.settings.fields);
+  const updatedAt = useStore((s) => s.settings.updatedAt);
+  const isLoading = useStore((s) => s.settings.isLoading);
+  const subscribe = useCallback(() => client.subscribeSettings(), [client]);
+  const unsubscribe = useCallback(() => client.unsubscribeSettings(), [client]);
+  const patchField = useCallback(
+    (fieldId, value) => client.patchSetting(fieldId, value),
+    [client]
+  );
+  return { fields, updatedAt, isLoading, subscribe, unsubscribe, patchField };
+}
+var EMPTY_ARRAY = [];
+var EMPTY_RUNS = [];
+function useThreadDetails(threadId) {
+  const { client } = useWorkerContext();
+  useEffect(() => {
+    if (!threadId) return;
+    client.subscribe(threadId);
+    return () => client.unsubscribe(threadId);
+  }, [threadId, client]);
+  const thread = useStore((s) => threadId ? s.threads[threadId] ?? null : null);
+  const isLoading = useStore((s) => threadId ? s.loadingThreads.has(threadId) : false);
+  const isWaiting = useStore((s) => {
+    if (!threadId) return false;
+    const r = s.runs[threadId];
+    return r ? r.some((run) => run.status === "running") : false;
+  });
+  const optimistic = useStore(
+    (s) => threadId ? s.optimistic[threadId] ?? EMPTY_ARRAY : EMPTY_ARRAY
+  );
+  const confirmed = useStore((s) => threadId ? s.events[threadId] ?? EMPTY_ARRAY : EMPTY_ARRAY);
+  const runs = useStore((s) => threadId ? s.runs[threadId] ?? EMPTY_RUNS : EMPTY_RUNS);
+  const events = useMemo(
+    () => optimistic.length ? [...optimistic, ...confirmed] : confirmed,
+    [optimistic, confirmed]
+  );
+  return { thread, events, runs, isLoading, isWaiting };
+}
+function useThreadEvents(threadId) {
+  const { client } = useWorkerContext();
+  const hasOlderEvents = useStore(
+    (s) => threadId ? s.eventPagination[threadId]?.hasMore ?? true : false
+  );
+  const loadOlderEvents = useCallback(
+    (limit) => {
+      if (threadId) client.loadOlderEvents(threadId, limit);
+    },
+    [threadId, client]
+  );
+  return { hasOlderEvents, loadOlderEvents };
+}
+function useThreadsList() {
+  const threadOrder = useStore((s) => s.threadOrder);
+  const threadMap = useStore((s) => s.threads);
+  const threads = useMemo(
+    () => threadOrder.flatMap((id) => {
+      const t = threadMap[id];
+      return t ? [t] : [];
+    }),
+    [threadOrder, threadMap]
+  );
+  const isLoading = useStore((s) => s.connection.status !== "connected");
+  const hasMore = useStore((s) => s.threadListHasMore);
+  const totalCount = useStore((s) => s.threadListTotalCount);
+  return { threads, isLoading, hasMore, totalCount };
+}
+function useThreadsActions() {
+  const { client } = useWorkerContext();
+  const deleteThread = useCallback((threadId) => client.deleteThread(threadId), [client]);
+  const loadMore = useCallback((limit) => client.loadMoreThreads(limit), [client]);
+  return { deleteThread, loadMore };
+}
+
+export { WorkerProvider, isSettingsFieldGroup, useAnalytics, useConnection, useFeedback, useMessage, useSettings, useThreadDetails, useThreadEvents, useThreadsActions, useThreadsList };
+//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map