@journeyrewards/hive-vercel 1.0.0

package/dist/index.js

@@ -0,0 +1,451 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentStatus: () => AgentStatus,
+  ConversationView: () => ConversationView,
+  JourneyHiveProvider: () => JourneyHiveProvider,
+  MessageBubble: () => MessageBubble,
+  ResponseStream: () => ResponseStream,
+  useAgent: () => useAgent,
+  useAgents: () => useAgents,
+  useConversation: () => useConversation,
+  useJourneyHive: () => useJourneyHive,
+  useResponse: () => useResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks.ts
+var import_react = require("react");
+function createClient(config) {
+  const baseUrl = config.baseUrl || "https://journey-hive.replit.app";
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  async function request(method, path, body) {
+    const res = await fetch(`${baseUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || `Request failed with status ${res.status}`);
+    }
+    return res.json();
+  }
+  async function* streamRequest(path, body) {
+    const res = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || `Request failed with status ${res.status}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      let currentEvent = "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+        } else if (line.startsWith("data: ")) {
+          const dataStr = line.slice(6);
+          try {
+            const data = JSON.parse(dataStr);
+            yield { event: currentEvent, data };
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return {
+    config,
+    responses: {
+      async create(params) {
+        if (params.stream) {
+          return streamRequest("/v1/responses", params);
+        }
+        return request("POST", "/v1/responses", params);
+      }
+    },
+    conversations: {
+      get: (id) => request("GET", `/v1/conversations/${id}`),
+      messages: (id) => request("GET", `/v1/conversations/${id}/messages`)
+    },
+    agents: {
+      get: (id) => request("GET", `/v1/agents/${id}`),
+      list: () => request("GET", "/v1/agents"),
+      update: (id, params) => request("PATCH", `/v1/agents/${id}`, params)
+    }
+  };
+}
+var JourneyHiveContext = (0, import_react.createContext)(null);
+function JourneyHiveProvider({ apiKey, baseUrl, children }) {
+  const clientRef = (0, import_react.useRef)(null);
+  if (!clientRef.current || clientRef.current.config.apiKey !== apiKey || clientRef.current.config.baseUrl !== baseUrl) {
+    clientRef.current = createClient({ apiKey, baseUrl });
+  }
+  return (0, import_react.createElement)(JourneyHiveContext.Provider, { value: clientRef.current }, children);
+}
+function useJourneyHive() {
+  const client = (0, import_react.useContext)(JourneyHiveContext);
+  if (!client) {
+    throw new Error("useJourneyHive must be used within a JourneyHiveProvider");
+  }
+  return client;
+}
+function useResponse(params) {
+  const client = useJourneyHive();
+  const [data, setData] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [isStreaming, setIsStreaming] = (0, import_react.useState)(false);
+  const [streamedText, setStreamedText] = (0, import_react.useState)("");
+  const [error, setError] = (0, import_react.useState)(null);
+  const send = (0, import_react.useCallback)(
+    async (input) => {
+      setIsLoading(true);
+      setIsStreaming(false);
+      setStreamedText("");
+      setError(null);
+      setData(null);
+      try {
+        const createParams = {
+          agent_id: params?.agent_id || "",
+          input,
+          stream: true,
+          ...params
+        };
+        const result = await client.responses.create(createParams);
+        if (Symbol.asyncIterator in result) {
+          setIsStreaming(true);
+          let accumulated = "";
+          for await (const { event, data: eventData } of result) {
+            if (event === "response.output_text.delta") {
+              accumulated += eventData.delta;
+              setStreamedText(accumulated);
+            } else if (event === "response.completed") {
+              setData(eventData);
+            } else if (event === "response.failed") {
+              throw new Error(eventData.error?.message || "Response failed");
+            }
+          }
+          setIsStreaming(false);
+        } else {
+          setData(result);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsLoading(false);
+        setIsStreaming(false);
+      }
+    },
+    [client, params]
+  );
+  return { data, isLoading, isStreaming, streamedText, error, send };
+}
+function useConversation(conversationId) {
+  const client = useJourneyHive();
+  const [conversation, setConversation] = (0, import_react.useState)(null);
+  const [messages, setMessages] = (0, import_react.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (!conversationId) return;
+    setIsLoading(true);
+    Promise.all([
+      client.conversations.get(conversationId),
+      client.conversations.messages(conversationId)
+    ]).then(([conv, msgResult]) => {
+      setConversation(conv);
+      setMessages(msgResult.data);
+    }).catch((err) => setError(err instanceof Error ? err : new Error(String(err)))).finally(() => setIsLoading(false));
+  }, [conversationId, client]);
+  const sendMessage = (0, import_react.useCallback)(
+    async (input) => {
+      if (!conversation) return;
+      const optimisticMsg = {
+        id: `temp_${Date.now()}`,
+        object: "message",
+        role: "user",
+        content: [{ type: "output_text", text: input }],
+        created_at: Math.floor(Date.now() / 1e3)
+      };
+      setMessages((prev) => [...prev, optimisticMsg]);
+      try {
+        const result = await client.responses.create({
+          agent_id: conversation.agent_id,
+          input,
+          conversation_id: conversationId
+        });
+        const response = result;
+        if (response.output) {
+          const assistantMsg = {
+            id: response.output[0]?.id || `msg_${Date.now()}`,
+            object: "message",
+            role: "assistant",
+            content: response.output[0]?.content || [],
+            created_at: response.created_at
+          };
+          setMessages((prev) => [...prev, assistantMsg]);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setMessages((prev) => prev.filter((m) => m.id !== optimisticMsg.id));
+      }
+    },
+    [client, conversation, conversationId]
+  );
+  return { conversation, messages, isLoading, error, sendMessage };
+}
+function useAgent(agentId) {
+  const client = useJourneyHive();
+  const [agent, setAgent] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (!agentId) return;
+    setIsLoading(true);
+    client.agents.get(agentId).then(setAgent).catch((err) => setError(err instanceof Error ? err : new Error(String(err)))).finally(() => setIsLoading(false));
+  }, [agentId, client]);
+  const update = (0, import_react.useCallback)(
+    async (params) => {
+      try {
+        const updated = await client.agents.update(agentId, params);
+        setAgent(updated);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [client, agentId]
+  );
+  return { agent, isLoading, error, update };
+}
+function useAgents() {
+  const client = useJourneyHive();
+  const [agents, setAgents] = (0, import_react.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    setIsLoading(true);
+    client.agents.list().then((result) => setAgents(result.data)).catch((err) => setError(err instanceof Error ? err : new Error(String(err)))).finally(() => setIsLoading(false));
+  }, [client]);
+  return { agents, isLoading, error };
+}
+
+// src/components.tsx
+var import_react2 = require("react");
+function ResponseStream({ agentId, input, onComplete, className }) {
+  const { streamedText, isStreaming, isLoading, error, send } = useResponse({ agent_id: agentId });
+  const sentRef = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
+    if (input && !sentRef.current) {
+      sentRef.current = true;
+      send(input);
+    }
+  }, [input, send]);
+  (0, import_react2.useEffect)(() => {
+    if (!isStreaming && !isLoading && streamedText && onComplete) {
+      onComplete(streamedText);
+    }
+  }, [isStreaming, isLoading, streamedText, onComplete]);
+  if (error) {
+    return (0, import_react2.createElement)("div", { className: `jh-error ${className || ""}`.trim() }, error.message);
+  }
+  return (0, import_react2.createElement)(
+    "div",
+    { className: `jh-response-stream ${className || ""}`.trim() },
+    (0, import_react2.createElement)("div", { className: "jh-stream-content" }, streamedText || ""),
+    isStreaming ? (0, import_react2.createElement)(
+      "span",
+      { className: "jh-typing-indicator" },
+      (0, import_react2.createElement)("span", { className: "jh-dot" }),
+      (0, import_react2.createElement)("span", { className: "jh-dot" }),
+      (0, import_react2.createElement)("span", { className: "jh-dot" })
+    ) : null
+  );
+}
+function MessageBubble({ role, content, timestamp }) {
+  const isUser = role === "user";
+  const time = timestamp ? new Date(timestamp * 1e3).toLocaleTimeString() : null;
+  return (0, import_react2.createElement)(
+    "div",
+    {
+      className: `jh-message-bubble jh-message-${isUser ? "user" : "assistant"}`,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: isUser ? "flex-end" : "flex-start",
+        marginBottom: "8px"
+      }
+    },
+    (0, import_react2.createElement)(
+      "div",
+      {
+        className: "jh-message-content",
+        style: {
+          padding: "8px 12px",
+          borderRadius: "8px",
+          maxWidth: "80%"
+        }
+      },
+      content
+    ),
+    time ? (0, import_react2.createElement)(
+      "span",
+      {
+        className: "jh-message-time",
+        style: { fontSize: "0.75em", opacity: 0.6, marginTop: "2px" }
+      },
+      time
+    ) : null
+  );
+}
+function ConversationView({ conversationId, agentId, className }) {
+  const { messages, isLoading, error, sendMessage } = useConversation(conversationId);
+  const [inputValue, setInputValue] = (0, import_react2.useState)("");
+  const messagesEndRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleSubmit = (0, import_react2.useCallback)(
+    (e) => {
+      e.preventDefault();
+      if (!inputValue.trim()) return;
+      sendMessage(inputValue.trim());
+      setInputValue("");
+    },
+    [inputValue, sendMessage]
+  );
+  if (error) {
+    return (0, import_react2.createElement)("div", { className: `jh-error ${className || ""}`.trim() }, error.message);
+  }
+  return (0, import_react2.createElement)(
+    "div",
+    {
+      className: `jh-conversation-view ${className || ""}`.trim(),
+      style: { display: "flex", flexDirection: "column", height: "100%" }
+    },
+    (0, import_react2.createElement)(
+      "div",
+      {
+        className: "jh-messages",
+        style: { flex: 1, overflowY: "auto", padding: "16px" }
+      },
+      isLoading ? (0, import_react2.createElement)("div", { className: "jh-loading" }, "Loading messages...") : messages.map((msg) => {
+        const text = msg.content?.map((c) => c.type === "output_text" ? c.text : "").join("") || "";
+        return (0, import_react2.createElement)(MessageBubble, {
+          key: msg.id,
+          role: msg.role,
+          content: text,
+          timestamp: msg.created_at
+        });
+      }),
+      (0, import_react2.createElement)("div", { ref: messagesEndRef })
+    ),
+    (0, import_react2.createElement)(
+      "form",
+      {
+        onSubmit: handleSubmit,
+        className: "jh-input-form",
+        style: { display: "flex", padding: "8px", gap: "8px" }
+      },
+      (0, import_react2.createElement)("input", {
+        type: "text",
+        value: inputValue,
+        onChange: (e) => setInputValue(e.target.value),
+        placeholder: "Type a message...",
+        className: "jh-input",
+        style: { flex: 1, padding: "8px", borderRadius: "4px", border: "1px solid #ccc" }
+      }),
+      (0, import_react2.createElement)(
+        "button",
+        {
+          type: "submit",
+          className: "jh-send-button",
+          style: { padding: "8px 16px", borderRadius: "4px" }
+        },
+        "Send"
+      )
+    )
+  );
+}
+function AgentStatus({ agent }) {
+  const statusColors = {
+    active: "#22c55e",
+    sleeping: "#eab308",
+    provisioning: "#3b82f6",
+    error: "#ef4444",
+    stopped: "#6b7280"
+  };
+  const color = statusColors[agent.status] || "#6b7280";
+  return (0, import_react2.createElement)(
+    "span",
+    {
+      className: "jh-agent-status",
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "6px",
+        padding: "2px 8px",
+        borderRadius: "9999px",
+        fontSize: "0.75em",
+        fontWeight: 500,
+        border: `1px solid ${color}`,
+        color
+      }
+    },
+    (0, import_react2.createElement)("span", {
+      style: {
+        width: "6px",
+        height: "6px",
+        borderRadius: "50%",
+        backgroundColor: color
+      }
+    }),
+    agent.status
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentStatus,
+  ConversationView,
+  JourneyHiveProvider,
+  MessageBubble,
+  ResponseStream,
+  useAgent,
+  useAgents,
+  useConversation,
+  useJourneyHive,
+  useResponse
+});