@journeyrewards/hive-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,344 @@
+// src/errors.ts
+var JourneyHiveError = class extends Error {
+  constructor(status, type, code, message) {
+    super(message);
+    this.name = "JourneyHiveError";
+    this.status = status;
+    this.type = type;
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends JourneyHiveError {
+  constructor(code, message) {
+    super(401, "authentication_error", code, message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends JourneyHiveError {
+  constructor(code, message) {
+    super(429, "rate_limit_error", code, message);
+    this.name = "RateLimitError";
+  }
+};
+var NotFoundError = class extends JourneyHiveError {
+  constructor(code, message) {
+    super(404, "not_found_error", code, message);
+    this.name = "NotFoundError";
+  }
+};
+var PermissionError = class extends JourneyHiveError {
+  constructor(code, message) {
+    super(403, "permission_error", code, message);
+    this.name = "PermissionError";
+  }
+};
+function parseErrorResponse(status, body) {
+  const error = body?.error;
+  const message = error?.message || "Unknown error";
+  const type = error?.type || "unknown_error";
+  const code = error?.code || "unknown";
+  switch (status) {
+    case 401:
+      return new AuthenticationError(code, message);
+    case 403:
+      return new PermissionError(code, message);
+    case 404:
+      return new NotFoundError(code, message);
+    case 429:
+      return new RateLimitError(code, message);
+    default:
+      return new JourneyHiveError(status, type, code, message);
+  }
+}
+
+// src/streaming.ts
+async function* parseSSEStream(response) {
+  if (!response.body) {
+    throw new Error("Response body is null. Streaming is not supported.");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const event = parseSSEBlock(buffer);
+          if (event) yield event;
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split("\n\n");
+      buffer = blocks.pop() || "";
+      for (const block of blocks) {
+        const trimmed = block.trim();
+        if (!trimmed) continue;
+        const event = parseSSEBlock(trimmed);
+        if (event) yield event;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSSEBlock(block) {
+  let eventType = "";
+  let dataStr = "";
+  const lines = block.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("event: ")) {
+      eventType = line.slice(7).trim();
+    } else if (line.startsWith("data: ")) {
+      dataStr += line.slice(6);
+    } else if (line.startsWith("data:")) {
+      dataStr += line.slice(5);
+    }
+  }
+  if (!eventType || !dataStr) return null;
+  try {
+    const data = JSON.parse(dataStr);
+    return { type: eventType, ...data };
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://journey-hive.replit.app";
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_RETRIES = 3;
+var RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var JourneyHiveClient = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.defaultAgentId = config.defaultAgentId;
+    this.debug = config.debug || false;
+    this.responses = new ResponsesAPI(this);
+    this.conversations = new ConversationsAPI(this);
+    this.agents = new AgentsAPI(this);
+    this.usage = new UsageAPI(this);
+  }
+  getDefaultAgentId() {
+    return this.defaultAgentId;
+  }
+  log(direction, method, path, body) {
+    if (!this.debug) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (body) {
+      console.log(`[JourneyHive ${direction}] ${timestamp} ${method} ${path}`, JSON.stringify(body, null, 2));
+    } else {
+      console.log(`[JourneyHive ${direction}] ${timestamp} ${method} ${path}`);
+    }
+  }
+  async _fetch(path, options = {}) {
+    const { retries = MAX_RETRIES, idempotencyKey, ...fetchOptions } = options;
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...fetchOptions.headers || {}
+    };
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    let parsedBody;
+    if (fetchOptions.body && typeof fetchOptions.body === "string") {
+      try {
+        parsedBody = JSON.parse(fetchOptions.body);
+      } catch {
+        parsedBody = fetchOptions.body;
+      }
+    }
+    this.log(">>>", fetchOptions.method || "GET", path, parsedBody);
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(url, {
+          ...fetchOptions,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (attempt < retries && RETRY_STATUS_CODES.includes(response.status)) {
+            const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+            this.log("<<<", `${response.status}`, path, { retry: attempt + 1, delay });
+            await sleep(delay);
+            continue;
+          }
+          let body;
+          try {
+            body = await response.json();
+          } catch {
+            body = { error: { message: response.statusText } };
+          }
+          this.log("<<<", `${response.status}`, path, body);
+          throw parseErrorResponse(
+            response.status,
+            body
+          );
+        }
+        const requestId = response.headers.get("x-request-id");
+        if (requestId) {
+          this.log("<<<", "200", `${path} [req_id: ${requestId}]`);
+        } else {
+          this.log("<<<", "200", path);
+        }
+        return response;
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof JourneyHiveError) {
+          throw err;
+        }
+        lastError = err;
+        if (attempt < retries) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+          this.log("<<<", "ERR", path, { error: err.message, retry: attempt + 1 });
+          await sleep(delay);
+          continue;
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+};
+var ResponsesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  resolveAgentId(params) {
+    if (!params.agent_id && this.client.getDefaultAgentId()) {
+      return { ...params, agent_id: this.client.getDefaultAgentId() };
+    }
+    return params;
+  }
+  async create(params) {
+    const resolved = this.resolveAgentId(params);
+    const { idempotency_key, ...body } = resolved;
+    if (resolved.stream) {
+      const response2 = await this.client._fetch("/v1/responses", {
+        method: "POST",
+        body: JSON.stringify(body),
+        retries: 0,
+        idempotencyKey: idempotency_key
+      });
+      return parseSSEStream(response2);
+    }
+    const response = await this.client._fetch("/v1/responses", {
+      method: "POST",
+      body: JSON.stringify(body),
+      idempotencyKey: idempotency_key
+    });
+    return response.json();
+  }
+  async get(id) {
+    const response = await this.client._fetch(`/v1/responses/${encodeURIComponent(id)}`);
+    return response.json();
+  }
+};
+var ConversationsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  resolveAgentId(params) {
+    if (!params.agent_id && this.client.getDefaultAgentId()) {
+      return { ...params, agent_id: this.client.getDefaultAgentId() };
+    }
+    return params;
+  }
+  async create(params) {
+    const resolved = this.resolveAgentId(params);
+    const { idempotency_key, ...body } = resolved;
+    const response = await this.client._fetch("/v1/conversations", {
+      method: "POST",
+      body: JSON.stringify(body),
+      idempotencyKey: idempotency_key
+    });
+    return response.json();
+  }
+  async get(id) {
+    const response = await this.client._fetch(`/v1/conversations/${encodeURIComponent(id)}`);
+    return response.json();
+  }
+  async list(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.agent_id) searchParams.set("agent_id", params.agent_id);
+    if (params?.status) searchParams.set("status", params.status);
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.cursor) searchParams.set("cursor", params.cursor);
+    const query = searchParams.toString();
+    const path = `/v1/conversations${query ? `?${query}` : ""}`;
+    const response = await this.client._fetch(path);
+    return response.json();
+  }
+  async messages(id, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.cursor) searchParams.set("cursor", params.cursor);
+    const query = searchParams.toString();
+    const response = await this.client._fetch(
+      `/v1/conversations/${encodeURIComponent(id)}/messages${query ? `?${query}` : ""}`
+    );
+    return response.json();
+  }
+  async close(id) {
+    await this.client._fetch(`/v1/conversations/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+};
+var AgentsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.cursor) searchParams.set("cursor", params.cursor);
+    const query = searchParams.toString();
+    const response = await this.client._fetch(`/v1/agents${query ? `?${query}` : ""}`);
+    return response.json();
+  }
+  async get(id) {
+    const response = await this.client._fetch(`/v1/agents/${encodeURIComponent(id)}`);
+    return response.json();
+  }
+  async update(id, params) {
+    const response = await this.client._fetch(`/v1/agents/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: JSON.stringify(params)
+    });
+    return response.json();
+  }
+};
+var UsageAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(days) {
+    const query = days ? `?days=${days}` : "";
+    const response = await this.client._fetch(`/v1/usage${query}`);
+    return response.json();
+  }
+};
+export {
+  AuthenticationError,
+  JourneyHiveClient,
+  JourneyHiveError,
+  NotFoundError,
+  PermissionError,
+  RateLimitError,
+  parseErrorResponse
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@journeyrewards/hive-sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for the Journey Hive Agent Orchestration API",
+  "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",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/journeyrewards/hive-sdk"
+  },
+  "homepage": "https://journey-hive.replit.app/api-docs",
+  "bugs": {
+    "url": "https://github.com/journeyrewards/hive-sdk/issues"
+  },
+  "license": "MIT",
+  "keywords": [
+    "journeyrewards",
+    "journey-hive",
+    "ai-agents",
+    "agent-orchestration",
+    "sdk",
+    "openclaw",
+    "hospitality"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}