@journeyrewards/hive-react-native 1.0.0

package/dist/index.mjs

@@ -0,0 +1,447 @@
+// src/streaming.ts
+async function* parseSSEFromFetch(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  let buffer = "";
+  let currentEvent = "";
+  const decode = (chunk) => {
+    let result = "";
+    for (let i = 0; i < chunk.length; i++) {
+      result += String.fromCharCode(chunk[i]);
+    }
+    return result;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += value instanceof Uint8Array ? decode(value) : String(value);
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+          continue;
+        }
+        if (trimmed.startsWith("event: ")) {
+          currentEvent = trimmed.slice(7).trim();
+        } else if (trimmed.startsWith("data: ")) {
+          const dataStr = trimmed.slice(6);
+          try {
+            const data = JSON.parse(dataStr);
+            yield { event: currentEvent, data };
+          } catch {
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const remaining = buffer.trim();
+      if (remaining.startsWith("data: ")) {
+        try {
+          const data = JSON.parse(remaining.slice(6));
+          yield { event: currentEvent, data };
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var RNEventSource = class {
+  constructor(url, headers = {}) {
+    this.abortController = null;
+    this.onmessage = null;
+    this.onerror = null;
+    this.onopen = null;
+    this.url = url;
+    this.headers = headers;
+  }
+  async connect(body) {
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(this.url, {
+        method: body ? "POST" : "GET",
+        headers: {
+          ...this.headers,
+          Accept: "text/event-stream",
+          ...body ? { "Content-Type": "application/json" } : {}
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        throw new Error(`EventSource connection failed: ${response.status}`);
+      }
+      this.onopen?.();
+      for await (const event of parseSSEFromFetch(response)) {
+        if (this.abortController?.signal.aborted) break;
+        this.onmessage?.(event);
+      }
+    } catch (err) {
+      if (!(err instanceof DOMException && err.name === "AbortError")) {
+        this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+  close() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+};
+
+// src/client.ts
+var JourneyHiveRNClient = class {
+  constructor(config) {
+    this.offlineQueue = [];
+    this.isConnected = true;
+    this.connectionListeners = [];
+    this.appStateListeners = [];
+    this.appState = "active";
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://journey-hive.replit.app";
+    this.timeout = config.timeout || 3e4;
+    this.defaultAgentId = config.defaultAgentId;
+    this.debug = config.debug || false;
+  }
+  resolveAgentId(agentId) {
+    return agentId || this.defaultAgentId;
+  }
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[JourneyHive] ${message}`, data !== void 0 ? data : "");
+    }
+  }
+  async request(method, path, body) {
+    if (!this.isConnected && method === "POST") {
+      return new Promise((resolve, reject) => {
+        if (body?.input) {
+          this.offlineQueue.push({
+            id: `queue_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            params: body,
+            resolve,
+            reject
+          });
+          this.log("Queued offline message", { path });
+        } else {
+          reject(new Error("No network connection"));
+        }
+      });
+    }
+    this.log(`${method} ${path}`, body);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: this.headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        const error = new Error(err?.error?.message || `Request failed with status ${res.status}`);
+        this.log(`${method} ${path} failed`, { status: res.status, error: err });
+        throw error;
+      }
+      const result = await res.json();
+      this.log(`${method} ${path} response`, { status: res.status });
+      return result;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      throw err;
+    }
+  }
+  async createResponse(params) {
+    const resolved = { ...params, agent_id: this.resolveAgentId(params.agent_id) };
+    if (params.stream) {
+      return this.createStreamingResponse(resolved);
+    }
+    return this.request("POST", "/v1/responses", resolved);
+  }
+  async *createStreamingResponse(params) {
+    const resolved = { ...params, agent_id: this.resolveAgentId(params.agent_id) };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout * 3);
+    try {
+      this.log("POST /v1/responses (streaming)", resolved);
+      const response = await fetch(`${this.baseUrl}/v1/responses`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(resolved),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({}));
+        throw new Error(err?.error?.message || `Request failed with status ${response.status}`);
+      }
+      yield* parseSSEFromFetch(response);
+    } catch (err) {
+      clearTimeout(timeoutId);
+      throw err;
+    }
+  }
+  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) {
+    const resolved = { ...params, agent_id: this.resolveAgentId(params.agent_id) };
+    return this.request("POST", "/v1/conversations", resolved);
+  }
+  async getConversation(conversationId) {
+    return this.request("GET", `/v1/conversations/${conversationId}`);
+  }
+  async getMessages(conversationId) {
+    return this.request("GET", `/v1/conversations/${conversationId}/messages`);
+  }
+  setConnectionStatus(connected) {
+    const changed = this.isConnected !== connected;
+    this.isConnected = connected;
+    if (changed) {
+      this.connectionListeners.forEach((listener) => listener(connected));
+      if (connected) {
+        this.flushOfflineQueue();
+      }
+    }
+  }
+  getConnectionStatus() {
+    return this.isConnected;
+  }
+  onConnectionChange(listener) {
+    this.connectionListeners.push(listener);
+    return () => {
+      this.connectionListeners = this.connectionListeners.filter((l) => l !== listener);
+    };
+  }
+  setAppState(state) {
+    const prev = this.appState;
+    this.appState = state;
+    if (prev !== state) {
+      this.appStateListeners.forEach((listener) => listener(state));
+    }
+  }
+  onAppStateChange(listener) {
+    this.appStateListeners.push(listener);
+    return () => {
+      this.appStateListeners = this.appStateListeners.filter((l) => l !== listener);
+    };
+  }
+  getQueuedMessages() {
+    return [...this.offlineQueue];
+  }
+  clearQueue() {
+    this.offlineQueue.forEach((msg) => msg.reject(new Error("Queue cleared")));
+    this.offlineQueue = [];
+  }
+  async flushOfflineQueue() {
+    const queue = [...this.offlineQueue];
+    this.offlineQueue = [];
+    for (const item of queue) {
+      try {
+        const result = await this.request("POST", "/v1/responses", item.params);
+        item.resolve(result);
+      } catch (err) {
+        item.reject(err);
+      }
+    }
+  }
+};
+
+// src/hooks.ts
+import {
+  useState,
+  useEffect,
+  useCallback,
+  useRef,
+  createContext,
+  useContext,
+  createElement
+} from "react";
+var JourneyHiveContext = createContext(null);
+function JourneyHiveProvider({ apiKey, baseUrl, children }) {
+  const clientRef = useRef(null);
+  if (!clientRef.current) {
+    clientRef.current = new JourneyHiveRNClient({ 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 stream = client.createStreamingResponse({
+          agent_id: params?.agent_id || "",
+          input,
+          stream: true,
+          conversation_id: params?.conversation_id,
+          instructions: params?.instructions
+        });
+        setIsStreaming(true);
+        let accumulated = "";
+        for await (const { event, data: eventData } of stream) {
+          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);
+      } 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.getConversation(conversationId),
+      client.getMessages(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.createResponse({
+          agent_id: conversation.agent_id,
+          input,
+          conversation_id: conversationId
+        });
+        if (result?.output) {
+          const assistantMsg = {
+            id: result.output[0]?.id || `msg_${Date.now()}`,
+            object: "message",
+            role: "assistant",
+            content: result.output[0]?.content || [],
+            created_at: result.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.getAgent(agentId).then((a) => setAgent(a)).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.updateAgent(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.listAgents().then((result) => setAgents(result.data || [])).catch((err) => setError(err instanceof Error ? err : new Error(String(err)))).finally(() => setIsLoading(false));
+  }, [client]);
+  return { agents, isLoading, error };
+}
+function useConnectionStatus() {
+  const client = useJourneyHive();
+  const [isConnected, setIsConnected] = useState(client.getConnectionStatus());
+  useEffect(() => {
+    const unsubscribe = client.onConnectionChange((connected) => {
+      setIsConnected(connected);
+    });
+    return unsubscribe;
+  }, [client]);
+  return { isConnected };
+}
+export {
+  JourneyHiveProvider,
+  JourneyHiveRNClient,
+  RNEventSource,
+  parseSSEFromFetch,
+  useAgent,
+  useAgents,
+  useConnectionStatus,
+  useConversation,
+  useJourneyHive,
+  useResponse
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@journeyrewards/hive-react-native",
+  "version": "1.0.0",
+  "description": "React Native SDK for Journey Hive Agent Orchestration",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean --external react --external react-native",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/journeyrewards/hive-react-native"
+  },
+  "homepage": "https://journey-hive.replit.app/api-guides",
+  "license": "MIT",
+  "keywords": [
+    "journeyrewards",
+    "journey-hive",
+    "ai-agents",
+    "react-native",
+    "mobile",
+    "sdk"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.72"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "@types/react": "^18.0.0"
+  }
+}