@love-moon/app-sdk 0.3.2

package/dist/react/index.js

@@ -0,0 +1,814 @@
+// src/react/store/chat-store.tsx
+import {
+  createContext,
+  useContext,
+  useMemo,
+  useReducer,
+  useRef,
+  useEffect
+} from "react";
+import { jsx } from "react/jsx-runtime";
+function generateRequestId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  if (c?.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    c.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+var INITIAL_STATE = {
+  messages: [],
+  pendingByClientId: {},
+  runtime: null,
+  connectionState: "offline",
+  hasMoreBefore: false,
+  oldestMessageId: null,
+  loadingHistory: false,
+  error: null,
+  latestReplyId: null
+};
+function reducer(state, action) {
+  switch (action.type) {
+    case "HYDRATE_HISTORY":
+      return {
+        ...state,
+        messages: dedupSorted(action.messages),
+        hasMoreBefore: action.hasMoreBefore,
+        oldestMessageId: action.oldestMessageId
+      };
+    case "PREPEND_HISTORY":
+      return {
+        ...state,
+        messages: dedupSorted([...action.messages, ...state.messages]),
+        hasMoreBefore: action.hasMoreBefore,
+        oldestMessageId: action.oldestMessageId ?? state.oldestMessageId
+      };
+    case "LOADING_HISTORY":
+      return { ...state, loadingHistory: action.loading };
+    case "OPTIMISTIC_SEND": {
+      return {
+        ...state,
+        messages: dedupSorted([...state.messages, action.message]),
+        pendingByClientId: {
+          ...state.pendingByClientId,
+          [action.clientRequestId]: action.message
+        }
+      };
+    }
+    case "CONFIRM_SEND": {
+      const { [action.clientRequestId]: _pending, ...rest } = state.pendingByClientId;
+      const pendingId = `pending:${action.clientRequestId}`;
+      const filtered = state.messages.filter((m) => m.id !== pendingId);
+      return {
+        ...state,
+        pendingByClientId: rest,
+        messages: dedupSorted([...filtered, action.serverMessage])
+      };
+    }
+    case "ROLLBACK_SEND": {
+      const { [action.clientRequestId]: _pending, ...rest } = state.pendingByClientId;
+      return {
+        ...state,
+        pendingByClientId: rest,
+        messages: state.messages.filter(
+          (m) => m.id !== `pending:${action.clientRequestId}`
+        )
+      };
+    }
+    case "APPEND_MESSAGE": {
+      const next = dedupSorted([...state.messages, action.message]);
+      const meta = action.message.metadata;
+      const auditActor = meta && typeof meta === "object" ? meta.audit?.actor : void 0;
+      const isSynthetic = Boolean(meta && meta.synthetic === true);
+      const isAppEcho = auditActor === "app";
+      const isAssistant = action.message.role !== "user" && action.message.role !== "sdk" && action.message.role !== "system" && !isSynthetic && !isAppEcho;
+      return {
+        ...state,
+        messages: next,
+        latestReplyId: isAssistant ? action.message.id : state.latestReplyId
+      };
+    }
+    case "UPDATE_MESSAGE": {
+      const idx = state.messages.findIndex((m) => m.id === action.message.id);
+      if (idx === -1) return state;
+      const next = state.messages.slice();
+      next[idx] = action.message;
+      return { ...state, messages: next };
+    }
+    case "SET_RUNTIME": {
+      const replyTo = action.status.replyTo ?? state.latestReplyId;
+      return {
+        ...state,
+        runtime: action.status,
+        latestReplyId: replyTo ?? state.latestReplyId
+      };
+    }
+    case "SET_CONNECTION":
+      return { ...state, connectionState: action.state };
+    case "SET_ERROR":
+      return { ...state, error: action.error };
+    case "TASK_FAILED":
+      return { ...state, error: action.error };
+    case "TASK_FINISHED":
+      return { ...state, runtime: null };
+    default:
+      return state;
+  }
+}
+function dedupSorted(messages) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of messages) byId.set(m.id, m);
+  return Array.from(byId.values()).sort((a, b) => {
+    const ta = Date.parse(a.createdAt || "");
+    const tb = Date.parse(b.createdAt || "");
+    if (Number.isFinite(ta) && Number.isFinite(tb) && ta !== tb) return ta - tb;
+    return a.id.localeCompare(b.id);
+  });
+}
+var ChatContext = createContext(null);
+function useChat() {
+  const ctx = useContext(ChatContext);
+  if (!ctx) {
+    throw new Error(
+      "useChat() must be called inside <ChatProvider> (or <ChatView>, which wraps it)."
+    );
+  }
+  return ctx;
+}
+function ChatProvider(props) {
+  const { taskId, adapter, onError } = props;
+  const [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+  const taskIdRef = useRef(taskId);
+  const adapterRef = useRef(adapter);
+  const onErrorRef = useRef(onError);
+  taskIdRef.current = taskId;
+  onErrorRef.current = onError;
+  useEffect(() => {
+    adapterRef.current = adapter;
+  }, [adapter]);
+  useEffect(() => {
+    const activeAdapter = adapterRef.current;
+    let cancelled = false;
+    const abort = new AbortController();
+    dispatch({ type: "LOADING_HISTORY", loading: true });
+    activeAdapter.fetchHistory(taskId, { signal: abort.signal }).then((page) => {
+      if (cancelled) return;
+      dispatch({
+        type: "HYDRATE_HISTORY",
+        messages: page.messages,
+        hasMoreBefore: page.hasMoreBefore,
+        oldestMessageId: page.oldestMessageId
+      });
+    }).catch((err) => {
+      if (cancelled) return;
+      onErrorRef.current?.(err);
+      dispatch({
+        type: "SET_ERROR",
+        error: extractError(err)
+      });
+    }).finally(() => {
+      if (!cancelled) dispatch({ type: "LOADING_HISTORY", loading: false });
+    });
+    const sub = activeAdapter.subscribe(taskId, (event) => {
+      if (cancelled) return;
+      switch (event.type) {
+        case "message_appended":
+          dispatch({ type: "APPEND_MESSAGE", message: event.message });
+          break;
+        case "message_updated":
+          dispatch({ type: "UPDATE_MESSAGE", message: event.message });
+          break;
+        case "runtime_status":
+          dispatch({ type: "SET_RUNTIME", status: event.status });
+          break;
+        case "task_finished":
+          dispatch({ type: "TASK_FINISHED" });
+          break;
+        case "task_failed": {
+          const taskErr = {
+            code: event.error.code,
+            message: event.error.message
+          };
+          if (event.error.details !== void 0) taskErr.details = event.error.details;
+          if (event.error.cause !== void 0) taskErr.cause = event.error.cause;
+          dispatch({ type: "TASK_FAILED", error: taskErr });
+          break;
+        }
+        case "connection_state":
+          dispatch({ type: "SET_CONNECTION", state: event.state });
+          break;
+      }
+    });
+    return () => {
+      cancelled = true;
+      abort.abort();
+      sub.unsubscribe();
+    };
+  }, [taskId]);
+  const value = useMemo(() => {
+    const send = async (content, opts) => {
+      const trimmed = content.trim();
+      if (!trimmed) return;
+      const clientRequestId = generateRequestId();
+      const optimistic = {
+        id: `pending:${clientRequestId}`,
+        taskId: taskIdRef.current,
+        // The widget represents a real human typing — always 'user'. This
+        // matters for routing on the backend: the daemon's message router
+        // only forwards `task_user_message` envelopes to the AI fire process
+        // (see conductor-sdk's message/router.ts). A message persisted with
+        // role='sdk' would silently get ignored by codex/claude, leaving
+        // the user wondering why their question never got a reply.
+        role: "user",
+        content: trimmed,
+        metadata: opts?.metadata ?? null,
+        attachments: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      dispatch({ type: "OPTIMISTIC_SEND", message: optimistic, clientRequestId });
+      try {
+        const payload = {
+          content: trimmed,
+          clientRequestId,
+          role: "user",
+          ...opts?.metadata ? { metadata: opts.metadata } : {}
+        };
+        const server = await adapterRef.current.sendMessage(taskIdRef.current, payload);
+        dispatch({ type: "CONFIRM_SEND", clientRequestId, serverMessage: server });
+      } catch (err) {
+        dispatch({ type: "ROLLBACK_SEND", clientRequestId });
+        onErrorRef.current?.(err);
+        dispatch({ type: "SET_ERROR", error: extractError(err) });
+      }
+    };
+    const interrupt = async () => {
+      const targetReplyTo = state.runtime?.replyTo ?? state.latestReplyId;
+      if (!targetReplyTo) return;
+      try {
+        await adapterRef.current.interrupt(taskIdRef.current, { targetReplyTo });
+      } catch (err) {
+        onErrorRef.current?.(err);
+        dispatch({ type: "SET_ERROR", error: extractError(err) });
+      }
+    };
+    const loadEarlier = async () => {
+      if (!state.hasMoreBefore || state.loadingHistory) return;
+      dispatch({ type: "LOADING_HISTORY", loading: true });
+      try {
+        const page = await adapterRef.current.fetchHistory(taskIdRef.current, {
+          beforeId: state.oldestMessageId ?? void 0
+        });
+        dispatch({
+          type: "PREPEND_HISTORY",
+          messages: page.messages,
+          hasMoreBefore: page.hasMoreBefore,
+          oldestMessageId: page.oldestMessageId
+        });
+      } catch (err) {
+        onErrorRef.current?.(err);
+        dispatch({ type: "SET_ERROR", error: extractError(err) });
+      } finally {
+        dispatch({ type: "LOADING_HISTORY", loading: false });
+      }
+    };
+    return { state, taskId, adapter, send, interrupt, loadEarlier };
+  }, [state, taskId, adapter]);
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children: props.children });
+}
+function extractError(err) {
+  if (typeof err === "object" && err !== null) {
+    const obj = err;
+    const code = String(obj.code ?? "unknown_error");
+    const message = String(obj.message ?? "Unknown error");
+    const status = typeof obj.status === "number" ? obj.status : void 0;
+    const requestId = typeof obj.requestId === "string" ? obj.requestId : void 0;
+    const details = obj.details ?? void 0;
+    return {
+      code,
+      message,
+      ...status !== void 0 ? { status } : {},
+      ...requestId !== void 0 ? { requestId } : {},
+      ...details !== void 0 ? { details } : {}
+    };
+  }
+  return { code: "unknown_error", message: String(err) };
+}
+
+// src/react/components/MessageList.tsx
+import { useEffect as useEffect2, useLayoutEffect, useRef as useRef2 } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function MessageList({ labels }) {
+  const { state, loadEarlier } = useChat();
+  const containerRef = useRef2(null);
+  const lastMessageCountRef = useRef2(state.messages.length);
+  useLayoutEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const grew = state.messages.length > lastMessageCountRef.current;
+    lastMessageCountRef.current = state.messages.length;
+    if (!grew) return;
+    const distanceFromBottom = el.scrollHeight - el.scrollTop - el.clientHeight;
+    if (distanceFromBottom < 120) {
+      el.scrollTop = el.scrollHeight;
+    }
+  }, [state.messages.length]);
+  useEffect2(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    el.scrollTop = el.scrollHeight;
+  }, []);
+  return /* @__PURE__ */ jsxs("div", { ref: containerRef, className: "conductor-message-list", role: "log", "aria-live": "polite", children: [
+    state.hasMoreBefore && /* @__PURE__ */ jsx2("div", { className: "conductor-load-earlier", children: /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        onClick: () => {
+          void loadEarlier();
+        },
+        disabled: state.loadingHistory,
+        children: state.loadingHistory ? "\u2026" : labels.loadEarlier
+      }
+    ) }),
+    state.messages.length === 0 && !state.loadingHistory && /* @__PURE__ */ jsx2("div", { className: "conductor-empty" }),
+    state.messages.map((m) => {
+      const isUser = m.role === "user" || m.role === "sdk";
+      const isPending = m.id.startsWith("pending:");
+      return /* @__PURE__ */ jsx2(
+        "div",
+        {
+          className: "conductor-message " + (isUser ? "conductor-message--user" : "conductor-message--assistant") + (isPending ? " conductor-message--pending" : ""),
+          "data-role": m.role,
+          "data-message-id": m.id,
+          children: /* @__PURE__ */ jsx2("div", { className: "conductor-bubble", children: m.content })
+        },
+        m.id
+      );
+    })
+  ] });
+}
+
+// src/react/components/MessageInput.tsx
+import { useCallback, useLayoutEffect as useLayoutEffect2, useRef as useRef3, useState } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function MessageInput({ labels, disabled }) {
+  const { state, send, interrupt } = useChat();
+  const [value, setValue] = useState("");
+  const taRef = useRef3(null);
+  const isComposingRef = useRef3(false);
+  useLayoutEffect2(() => {
+    const el = taRef.current;
+    if (!el) return;
+    el.style.height = "auto";
+    el.style.height = `${Math.min(el.scrollHeight, 5 * 24 + 16)}px`;
+  }, [value]);
+  const handleSend = useCallback(() => {
+    if (!value.trim() || disabled) return;
+    void send(value);
+    setValue("");
+  }, [send, value, disabled]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      const nativeComposing = e.nativeEvent.isComposing === true;
+      if (isComposingRef.current || nativeComposing) return;
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleSend();
+      }
+    },
+    [handleSend]
+  );
+  const handleCompositionStart = useCallback(() => {
+    isComposingRef.current = true;
+  }, []);
+  const handleCompositionEnd = useCallback(() => {
+    isComposingRef.current = false;
+  }, []);
+  const replyInProgress = state.runtime?.replyInProgress === true;
+  const canInterrupt = replyInProgress && Boolean(state.latestReplyId);
+  return /* @__PURE__ */ jsxs2("div", { className: "conductor-message-input", children: [
+    /* @__PURE__ */ jsx3(
+      "textarea",
+      {
+        ref: taRef,
+        value,
+        onChange: (e) => setValue(e.target.value),
+        onKeyDown: handleKeyDown,
+        onCompositionStart: handleCompositionStart,
+        onCompositionEnd: handleCompositionEnd,
+        placeholder: labels.inputPlaceholder,
+        rows: 1,
+        className: "conductor-message-input__textarea",
+        disabled
+      }
+    ),
+    /* @__PURE__ */ jsx3("div", { className: "conductor-message-input__actions", children: canInterrupt ? /* @__PURE__ */ jsx3(
+      "button",
+      {
+        type: "button",
+        className: "conductor-button conductor-button--interrupt",
+        onClick: () => void interrupt(),
+        children: labels.interrupt
+      }
+    ) : /* @__PURE__ */ jsx3(
+      "button",
+      {
+        type: "button",
+        className: "conductor-button conductor-button--send",
+        onClick: handleSend,
+        disabled: !value.trim() || disabled,
+        children: labels.send
+      }
+    ) })
+  ] });
+}
+
+// src/react/components/RuntimeStatusBar.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function RuntimeStatusBar({ labels }) {
+  const { state } = useChat();
+  const runtime = state.runtime;
+  const isThinking = runtime?.replyInProgress === true || runtime?.state === "thinking";
+  const text = pickStatusText(runtime?.state, runtime?.statusLine, labels);
+  const showConnection = state.connectionState !== "connected" && state.connectionState !== "offline";
+  return /* @__PURE__ */ jsxs3("div", { className: "conductor-runtime-status", role: "status", "aria-live": "polite", children: [
+    /* @__PURE__ */ jsx4(
+      "span",
+      {
+        className: "conductor-runtime-indicator" + (isThinking ? " conductor-runtime-indicator--active" : ""),
+        "aria-hidden": "true"
+      }
+    ),
+    /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-text", children: text }),
+    state.error && /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-error", role: "alert", children: state.error.message }),
+    showConnection && /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-connection", children: state.connectionState === "reconnecting" ? "\u2026" : "" })
+  ] });
+}
+function pickStatusText(state, statusLine, labels) {
+  if (statusLine) return statusLine;
+  switch (state) {
+    case "thinking":
+      return labels.statusThinking;
+    case "tool_call":
+      return labels.statusToolCall;
+    case "awaiting_user":
+      return labels.statusAwaitingUser;
+    case "done":
+      return labels.statusDone;
+    default:
+      return "";
+  }
+}
+
+// src/react/ChatView.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var DEFAULT_LABELS = {
+  statusThinking: "Thinking\u2026",
+  statusToolCall: "Calling tool\u2026",
+  statusAwaitingUser: "Waiting for input",
+  statusDone: "Done",
+  inputPlaceholder: "Type a message",
+  send: "Send",
+  interrupt: "Stop",
+  restart: "Restart",
+  loadEarlier: "Load earlier messages"
+};
+function ChatView(props) {
+  const labels = { ...DEFAULT_LABELS, ...props.labels ?? {} };
+  const themeStyle = props.theme ? toCssVariableStyle(props.theme) : void 0;
+  const className = ["conductor-chat-view", props.className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className,
+      "data-task-id": props.taskId,
+      "data-layout": props.layout ?? "auto",
+      style: themeStyle,
+      children: /* @__PURE__ */ jsxs4(ChatProvider, { taskId: props.taskId, adapter: props.adapter, onError: props.onError, children: [
+        /* @__PURE__ */ jsx5(RuntimeStatusBar, { labels }),
+        /* @__PURE__ */ jsx5(MessageList, { labels }),
+        /* @__PURE__ */ jsx5(MessageInput, { labels, disabled: props.readOnly })
+      ] })
+    }
+  );
+}
+function toCssVariableStyle(theme) {
+  const out = {};
+  for (const [key, value] of Object.entries(theme)) {
+    if (typeof value !== "string") continue;
+    const varName = WELL_KNOWN_THEME_VARS[key] ?? toCssVarName(key);
+    out[varName] = value;
+  }
+  return out;
+}
+var WELL_KNOWN_THEME_VARS = {
+  accent: "--accent",
+  background: "--conductor-paper",
+  bubbleUser: "--conductor-bubble-user",
+  bubbleAssistant: "--conductor-bubble-assistant"
+};
+function toCssVarName(camelCaseKey) {
+  if (camelCaseKey.startsWith("--")) return camelCaseKey;
+  return "--" + camelCaseKey.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
+}
+
+// src/types/errors.ts
+var ConductorAppError = class extends Error {
+  name = "ConductorAppError";
+  code;
+  status;
+  details;
+  requestId;
+  constructor(args) {
+    super(args.message, args.cause ? { cause: args.cause } : void 0);
+    this.code = args.code;
+    this.status = args.status;
+    this.details = args.details;
+    this.requestId = args.requestId;
+  }
+};
+function isConductorAppError(error) {
+  return typeof error === "object" && error !== null && error.name === "ConductorAppError";
+}
+
+// src/types/error-codes.ts
+function extractErrorMarker(details, message) {
+  if (details && typeof details === "object" && "error" in details) {
+    const raw = details.error;
+    if (typeof raw === "string") return raw.toLowerCase();
+  }
+  if (message) return message.toLowerCase();
+  return "";
+}
+function mapHttpStatusToErrorCode(status, details, message) {
+  const marker = extractErrorMarker(details, message);
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) {
+    if (marker.includes("project")) return "project_not_found";
+    if (marker.includes("task")) return "task_not_found";
+    if (marker.includes("message")) return "message_not_found";
+    return "task_not_found";
+  }
+  if (status === 408) return "timeout";
+  if (status === 409) {
+    if (marker.includes("fire owner")) return "task_fire_owner_offline";
+    if (marker.includes("task_type")) return "task_type_not_messageable";
+    if (marker.includes("not_running") || marker.includes("not running"))
+      return "task_not_running";
+    if (marker.includes("daemon") || marker.includes("offline")) return "daemon_offline";
+    if (marker.includes("binding")) return "binding_validation_failed";
+    return "binding_validation_failed";
+  }
+  if (status === 422) return "invalid_input";
+  if (status === 429) return "rate_limited";
+  if (status >= 500) return "server_error";
+  if (status >= 400) return "invalid_input";
+  return "server_error";
+}
+
+// src/react/adapter/rest-adapter.ts
+function createRestAdapter(options) {
+  if (!options.baseUrl) {
+    throw new ConductorAppError({
+      code: "invalid_input",
+      message: "createRestAdapter requires baseUrl"
+    });
+  }
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const EventSourceCtor = options.eventSource ?? (typeof globalThis !== "undefined" ? globalThis.EventSource : void 0);
+  const credentials = options.credentials ?? "include";
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  async function resolveAuth() {
+    const t = options.authToken;
+    if (!t) return null;
+    if (typeof t === "string") return t;
+    return await t();
+  }
+  async function buildHeaders(init = {}) {
+    const auth = await resolveAuth();
+    return {
+      Accept: "application/json",
+      ...init,
+      ...auth ? { Authorization: `Bearer ${auth}` } : {}
+    };
+  }
+  async function jsonFetch(method, path, init = {}) {
+    const url = buildUrl(baseUrl, path, init.query);
+    const headers = await buildHeaders(
+      init.body !== void 0 ? { "Content-Type": "application/json" } : {}
+    );
+    const composed = composeAbortSignals(init.signal, timeoutMs);
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method,
+        headers,
+        credentials,
+        body: init.body !== void 0 ? JSON.stringify(init.body) : void 0,
+        signal: composed.signal
+      });
+    } catch (cause) {
+      composed.dispose();
+      if (cause?.name === "AbortError") {
+        throw new ConductorAppError({
+          code: composed.timedOut ? "timeout" : "stream_aborted",
+          message: composed.timedOut ? `Request timed out after ${timeoutMs}ms` : "Request aborted",
+          cause
+        });
+      }
+      throw new ConductorAppError({
+        code: "network_error",
+        message: `Network error: ${cause?.message ?? String(cause)}`,
+        cause
+      });
+    }
+    composed.dispose();
+    if (!res.ok) {
+      const detail = await safeJson(res);
+      const message = detail && typeof detail === "object" && "error" in detail ? String(detail.error) : null;
+      throw new ConductorAppError({
+        code: mapHttpStatusToErrorCode(res.status, detail, message),
+        status: res.status,
+        message: message ?? `${method} ${path} failed with ${res.status}`,
+        details: detail
+      });
+    }
+    if (res.status === 204) return void 0;
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  return {
+    async fetchHistory(taskId, opts) {
+      if (!taskId) {
+        throw new ConductorAppError({
+          code: "invalid_input",
+          message: "fetchHistory requires a taskId"
+        });
+      }
+      const body = await jsonFetch("GET", `/tasks/${encodeURIComponent(taskId)}/messages`, {
+        signal: opts?.signal,
+        query: {
+          pagination: "1",
+          ...opts?.beforeId ? { before_id: opts.beforeId } : {},
+          ...opts?.limit ? { limit: opts.limit } : {}
+        }
+      });
+      return {
+        messages: body?.messages ?? [],
+        hasMoreBefore: Boolean(body?.pagination?.has_more_before),
+        oldestMessageId: body?.pagination?.oldest_message_id ?? null
+      };
+    },
+    subscribe(taskId, handler) {
+      if (!taskId) {
+        throw new ConductorAppError({
+          code: "invalid_input",
+          message: "subscribe requires a taskId"
+        });
+      }
+      if (!EventSourceCtor) {
+        throw new ConductorAppError({
+          code: "subscribe_failed",
+          message: "No EventSource available. Either run in a browser or pass eventSource via createRestAdapter options."
+        });
+      }
+      const url = buildUrl(baseUrl, `/tasks/${encodeURIComponent(taskId)}/events`);
+      const es = new EventSourceCtor(url, { withCredentials: credentials === "include" });
+      let closed = false;
+      const emit = (state) => {
+        try {
+          handler({ type: "connection_state", state });
+        } catch {
+        }
+      };
+      const onOpen = () => emit("connected");
+      const onMessage = (e) => {
+        if (closed) return;
+        let parsed;
+        try {
+          parsed = JSON.parse(e.data);
+        } catch {
+          return;
+        }
+        if (parsed && typeof parsed === "object" && "type" in parsed) {
+          try {
+            handler(parsed);
+          } catch {
+          }
+        }
+      };
+      const onError = () => {
+        if (closed) return;
+        emit("reconnecting");
+      };
+      es.addEventListener("open", onOpen);
+      es.addEventListener("message", onMessage);
+      es.addEventListener("error", onError);
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          es.removeEventListener("open", onOpen);
+          es.removeEventListener("message", onMessage);
+          es.removeEventListener("error", onError);
+          es.close();
+        }
+      };
+    },
+    async sendMessage(taskId, input) {
+      if (!taskId) {
+        throw new ConductorAppError({
+          code: "invalid_input",
+          message: "sendMessage requires a taskId"
+        });
+      }
+      const body = await jsonFetch(
+        "POST",
+        `/tasks/${encodeURIComponent(taskId)}/messages`,
+        {
+          body: {
+            content: input.content,
+            ...input.role ? { role: input.role } : {},
+            ...input.clientRequestId ? { clientRequestId: input.clientRequestId } : {},
+            ...input.metadata ? { metadata: input.metadata } : {}
+          }
+        }
+      );
+      return body;
+    },
+    async interrupt(taskId, opts) {
+      if (!taskId) {
+        throw new ConductorAppError({
+          code: "invalid_input",
+          message: "interrupt requires a taskId"
+        });
+      }
+      await jsonFetch(
+        "POST",
+        `/tasks/${encodeURIComponent(taskId)}/interrupt`,
+        { body: { target_reply_to: opts.targetReplyTo } }
+      );
+    }
+  };
+}
+function buildUrl(base, path, query) {
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  let url = `${base}${cleanPath}`;
+  if (query) {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(query)) {
+      if (v === void 0 || v === null) continue;
+      params.append(k, String(v));
+    }
+    const s = params.toString();
+    if (s) url += `?${s}`;
+  }
+  return url;
+}
+async function safeJson(res) {
+  try {
+    const text = await res.text();
+    if (!text) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function composeAbortSignals(external, timeoutMs) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs) : null;
+  const onExternal = () => controller.abort();
+  if (external) {
+    if (external.aborted) controller.abort();
+    else external.addEventListener("abort", onExternal);
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      if (timer) clearTimeout(timer);
+      if (external) external.removeEventListener("abort", onExternal);
+    },
+    get timedOut() {
+      return timedOut;
+    }
+  };
+}
+export {
+  ChatProvider,
+  ChatView,
+  ConductorAppError,
+  MessageInput,
+  MessageList,
+  RuntimeStatusBar,
+  createRestAdapter,
+  isConductorAppError,
+  useChat
+};