@journeyrewards/hive-vercel 1.0.0

package/dist/index.mjs

@@ -0,0 +1,429 @@
+// src/hooks.ts
+import {
+  useState,
+  useEffect,
+  useCallback,
+  useRef,
+  createContext,
+  useContext,
+  createElement
+} from "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 = createContext(null);
+function JourneyHiveProvider({ apiKey, baseUrl, children }) {
+  const clientRef = useRef(null);
+  if (!clientRef.current || clientRef.current.config.apiKey !== apiKey || clientRef.current.config.baseUrl !== baseUrl) {
+    clientRef.current = createClient({ apiKey, baseUrl });
+  }
+  return createElement(JourneyHiveContext.Provider, { value: clientRef.current }, children);
+}
+function useJourneyHive() {
+  const client = 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] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [streamedText, setStreamedText] = useState("");
+  const [error, setError] = useState(null);
+  const send = 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] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  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 = 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] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  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 = 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] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  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
+import {
+  useState as useState2,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useCallback as useCallback2,
+  createElement as createElement2
+} from "react";
+function ResponseStream({ agentId, input, onComplete, className }) {
+  const { streamedText, isStreaming, isLoading, error, send } = useResponse({ agent_id: agentId });
+  const sentRef = useRef2(false);
+  useEffect2(() => {
+    if (input && !sentRef.current) {
+      sentRef.current = true;
+      send(input);
+    }
+  }, [input, send]);
+  useEffect2(() => {
+    if (!isStreaming && !isLoading && streamedText && onComplete) {
+      onComplete(streamedText);
+    }
+  }, [isStreaming, isLoading, streamedText, onComplete]);
+  if (error) {
+    return createElement2("div", { className: `jh-error ${className || ""}`.trim() }, error.message);
+  }
+  return createElement2(
+    "div",
+    { className: `jh-response-stream ${className || ""}`.trim() },
+    createElement2("div", { className: "jh-stream-content" }, streamedText || ""),
+    isStreaming ? createElement2(
+      "span",
+      { className: "jh-typing-indicator" },
+      createElement2("span", { className: "jh-dot" }),
+      createElement2("span", { className: "jh-dot" }),
+      createElement2("span", { className: "jh-dot" })
+    ) : null
+  );
+}
+function MessageBubble({ role, content, timestamp }) {
+  const isUser = role === "user";
+  const time = timestamp ? new Date(timestamp * 1e3).toLocaleTimeString() : null;
+  return createElement2(
+    "div",
+    {
+      className: `jh-message-bubble jh-message-${isUser ? "user" : "assistant"}`,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: isUser ? "flex-end" : "flex-start",
+        marginBottom: "8px"
+      }
+    },
+    createElement2(
+      "div",
+      {
+        className: "jh-message-content",
+        style: {
+          padding: "8px 12px",
+          borderRadius: "8px",
+          maxWidth: "80%"
+        }
+      },
+      content
+    ),
+    time ? createElement2(
+      "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] = useState2("");
+  const messagesEndRef = useRef2(null);
+  useEffect2(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleSubmit = useCallback2(
+    (e) => {
+      e.preventDefault();
+      if (!inputValue.trim()) return;
+      sendMessage(inputValue.trim());
+      setInputValue("");
+    },
+    [inputValue, sendMessage]
+  );
+  if (error) {
+    return createElement2("div", { className: `jh-error ${className || ""}`.trim() }, error.message);
+  }
+  return createElement2(
+    "div",
+    {
+      className: `jh-conversation-view ${className || ""}`.trim(),
+      style: { display: "flex", flexDirection: "column", height: "100%" }
+    },
+    createElement2(
+      "div",
+      {
+        className: "jh-messages",
+        style: { flex: 1, overflowY: "auto", padding: "16px" }
+      },
+      isLoading ? createElement2("div", { className: "jh-loading" }, "Loading messages...") : messages.map((msg) => {
+        const text = msg.content?.map((c) => c.type === "output_text" ? c.text : "").join("") || "";
+        return createElement2(MessageBubble, {
+          key: msg.id,
+          role: msg.role,
+          content: text,
+          timestamp: msg.created_at
+        });
+      }),
+      createElement2("div", { ref: messagesEndRef })
+    ),
+    createElement2(
+      "form",
+      {
+        onSubmit: handleSubmit,
+        className: "jh-input-form",
+        style: { display: "flex", padding: "8px", gap: "8px" }
+      },
+      createElement2("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" }
+      }),
+      createElement2(
+        "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 createElement2(
+    "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
+      }
+    },
+    createElement2("span", {
+      style: {
+        width: "6px",
+        height: "6px",
+        borderRadius: "50%",
+        backgroundColor: color
+      }
+    }),
+    agent.status
+  );
+}
+export {
+  AgentStatus,
+  ConversationView,
+  JourneyHiveProvider,
+  MessageBubble,
+  ResponseStream,
+  useAgent,
+  useAgents,
+  useConversation,
+  useJourneyHive,
+  useResponse
+};

package/dist/server.d.mts

@@ -0,0 +1,38 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+
+declare function verifyApiKey(key: string): boolean;
+interface JourneyHiveHandlerConfig {
+    apiKey: string;
+    baseUrl?: string;
+    allowedAgentIds?: string[];
+}
+declare function createJourneyHiveHandler(config: JourneyHiveHandlerConfig): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+declare class JourneyHiveServerClient {
+    private baseUrl;
+    private headers;
+    constructor(config: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    private request;
+    createResponse(params: {
+        agent_id: string;
+        input: string;
+        conversation_id?: string;
+        instructions?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    getAgent(agentId: string): Promise<unknown>;
+    listAgents(): Promise<unknown>;
+    updateAgent(agentId: string, params: any): Promise<unknown>;
+    createConversation(params: {
+        agent_id: string;
+        external_user_id?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    getConversation(conversationId: string): Promise<unknown>;
+    getMessages(conversationId: string): Promise<unknown>;
+    getUsage(days?: number): Promise<unknown>;
+}
+
+export { JourneyHiveServerClient, createJourneyHiveHandler, verifyApiKey };

package/dist/server.d.ts

@@ -0,0 +1,38 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+
+declare function verifyApiKey(key: string): boolean;
+interface JourneyHiveHandlerConfig {
+    apiKey: string;
+    baseUrl?: string;
+    allowedAgentIds?: string[];
+}
+declare function createJourneyHiveHandler(config: JourneyHiveHandlerConfig): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+declare class JourneyHiveServerClient {
+    private baseUrl;
+    private headers;
+    constructor(config: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    private request;
+    createResponse(params: {
+        agent_id: string;
+        input: string;
+        conversation_id?: string;
+        instructions?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    getAgent(agentId: string): Promise<unknown>;
+    listAgents(): Promise<unknown>;
+    updateAgent(agentId: string, params: any): Promise<unknown>;
+    createConversation(params: {
+        agent_id: string;
+        external_user_id?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    getConversation(conversationId: string): Promise<unknown>;
+    getMessages(conversationId: string): Promise<unknown>;
+    getUsage(days?: number): Promise<unknown>;
+}
+
+export { JourneyHiveServerClient, createJourneyHiveHandler, verifyApiKey };

package/dist/server.js

@@ -0,0 +1,168 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  JourneyHiveServerClient: () => JourneyHiveServerClient,
+  createJourneyHiveHandler: () => createJourneyHiveHandler,
+  verifyApiKey: () => verifyApiKey
+});
+module.exports = __toCommonJS(server_exports);
+function verifyApiKey(key) {
+  return typeof key === "string" && (key.startsWith("jh_live_") || key.startsWith("jh_test_")) && key.length > 16;
+}
+function createJourneyHiveHandler(config) {
+  const baseUrl = config.baseUrl || "https://journey-hive.replit.app";
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  return async function handler(req, res) {
+    if (req.method !== "POST") {
+      res.status(405).json({ error: { message: "Method not allowed" } });
+      return;
+    }
+    const { action, ...params } = req.body;
+    if (config.allowedAgentIds && params.agent_id) {
+      if (!config.allowedAgentIds.includes(params.agent_id)) {
+        res.status(403).json({ error: { message: "Agent not allowed" } });
+        return;
+      }
+    }
+    let path;
+    let method = "POST";
+    switch (action) {
+      case "create_response":
+        path = "/v1/responses";
+        break;
+      case "list_agents":
+        path = "/v1/agents";
+        method = "GET";
+        break;
+      case "get_agent":
+        path = `/v1/agents/${params.agent_id}`;
+        method = "GET";
+        break;
+      case "create_conversation":
+        path = "/v1/conversations";
+        break;
+      case "get_conversation":
+        path = `/v1/conversations/${params.conversation_id}`;
+        method = "GET";
+        break;
+      case "get_messages":
+        path = `/v1/conversations/${params.conversation_id}/messages`;
+        method = "GET";
+        break;
+      default:
+        res.status(400).json({ error: { message: `Unknown action: ${action}` } });
+        return;
+    }
+    try {
+      const fetchOptions = {
+        method,
+        headers
+      };
+      if (method === "POST") {
+        const { action: _action, ...bodyParams } = params;
+        fetchOptions.body = JSON.stringify(bodyParams);
+      }
+      const response = await fetch(`${baseUrl}${path}`, fetchOptions);
+      if (params.stream && action === "create_response") {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        const reader = response.body?.getReader();
+        if (!reader) {
+          res.status(500).json({ error: { message: "No response body" } });
+          return;
+        }
+        const decoder = new TextDecoder();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(decoder.decode(value, { stream: true }));
+          }
+        } finally {
+          res.end();
+        }
+        return;
+      }
+      const data = await response.json();
+      res.status(response.status).json(data);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json({ error: { message } });
+    }
+  };
+}
+var JourneyHiveServerClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl || "https://journey-hive.replit.app";
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    };
+  }
+  async request(method, path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: this.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 createResponse(params) {
+    return this.request("POST", "/v1/responses", params);
+  }
+  async getAgent(agentId) {
+    return this.request("GET", `/v1/agents/${agentId}`);
+  }
+  async listAgents() {
+    return this.request("GET", "/v1/agents");
+  }
+  async updateAgent(agentId, params) {
+    return this.request("PATCH", `/v1/agents/${agentId}`, params);
+  }
+  async createConversation(params) {
+    return this.request("POST", "/v1/conversations", params);
+  }
+  async getConversation(conversationId) {
+    return this.request("GET", `/v1/conversations/${conversationId}`);
+  }
+  async getMessages(conversationId) {
+    return this.request("GET", `/v1/conversations/${conversationId}/messages`);
+  }
+  async getUsage(days) {
+    const query = days ? `?days=${days}` : "";
+    return this.request("GET", `/v1/usage${query}`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JourneyHiveServerClient,
+  createJourneyHiveHandler,
+  verifyApiKey
+});