@hoodcompute/sdk 0.1.0

package/dist/react.cjs

@@ -0,0 +1,642 @@
+'use strict';
+
+var react = require('react');
+
+// src/react.ts
+
+// src/errors.ts
+var HoodComputeError = class extends Error {
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "HoodComputeError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.type = opts.type;
+    this.param = opts.param;
+    this.details = opts.details;
+    this.requestId = opts.requestId;
+  }
+};
+var AuthenticationError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientCreditsError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var InvalidRequestError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "InvalidRequestError";
+  }
+};
+var NotFoundError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "RateLimitError";
+  }
+};
+var NoWorkersAvailableError = class extends HoodComputeError {
+  /** Suggested seconds to wait before retrying. */
+  get retryAfter() {
+    const value = this.details?.retry_after;
+    return typeof value === "number" ? value : void 0;
+  }
+  constructor(...args) {
+    super(...args);
+    this.name = "NoWorkersAvailableError";
+  }
+};
+var JobTimeoutError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "JobTimeoutError";
+  }
+};
+var ServerError = class extends HoodComputeError {
+  constructor(...args) {
+    super(...args);
+    this.name = "ServerError";
+  }
+};
+var ConnectionError = class extends HoodComputeError {
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "ConnectionError";
+    if (opts.cause !== void 0) this.cause = opts.cause;
+  }
+};
+function errorFromResponse(status, body, requestId) {
+  const code = body?.code;
+  const message = body?.message ?? `HoodCompute API request failed with status ${status}`;
+  const opts = {
+    status,
+    code,
+    type: body?.type,
+    param: body?.param ?? null,
+    details: body?.details,
+    requestId
+  };
+  if (code === "no_workers_available") return new NoWorkersAvailableError(message, opts);
+  if (code === "job_timeout") return new JobTimeoutError(message, opts);
+  if (code === "insufficient_credits") return new InsufficientCreditsError(message, opts);
+  switch (status) {
+    case 400:
+    case 422:
+      return new InvalidRequestError(message, opts);
+    case 401:
+    case 403:
+      return new AuthenticationError(message, opts);
+    case 402:
+      return new InsufficientCreditsError(message, opts);
+    case 404:
+      return new NotFoundError(message, opts);
+    case 429:
+      return new RateLimitError(message, opts);
+    case 503:
+      return new NoWorkersAvailableError(message, opts);
+    case 504:
+      return new JobTimeoutError(message, opts);
+    default:
+      if (status >= 500) return new ServerError(message, opts);
+      return new HoodComputeError(message, opts);
+  }
+}
+function isRetryable(err) {
+  if (err instanceof ConnectionError) return true;
+  if (err instanceof HoodComputeError) {
+    if (err.status === void 0) return false;
+    return err.status >= 500 || err.status === 429;
+  }
+  return false;
+}
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://api.hoodcompute.com/v1";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_RETRIES = 2;
+var SDK_VERSION = "0.1.0";
+
+// src/http.ts
+var HttpClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseURL = options.baseURL.replace(/\/$/, "");
+    this.timeout = options.timeout;
+    this.maxRetries = options.maxRetries;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+    const impl = options.fetch ?? globalThis.fetch;
+    if (!impl) {
+      throw new ConnectionError(
+        "No global fetch implementation found. Use Node 18+ or pass a `fetch` option."
+      );
+    }
+    this.fetchImpl = impl;
+  }
+  /** Perform a request and return the parsed JSON body plus response headers. */
+  async request(options) {
+    const response = await this.raw(options);
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : void 0;
+    return { data, response };
+  }
+  /**
+   * Perform a request and return the raw Response. Used by the streaming path,
+   * which reads `response.body` directly. Errors are still parsed and thrown.
+   */
+  async raw(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const headers = this.buildHeaders(options);
+    const init = {
+      method: options.method ?? "GET",
+      headers
+    };
+    if (options.body !== void 0) {
+      init.body = JSON.stringify(options.body);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, init, options.signal);
+        if (response.ok) return response;
+        const error = await this.toError(response);
+        if (isRetryable(error) && attempt < this.maxRetries) {
+          lastError = error;
+          await sleep(this.backoff(attempt, error));
+          continue;
+        }
+        throw error;
+      } catch (err) {
+        if (err instanceof ConnectionError && attempt < this.maxRetries) {
+          lastError = err;
+          await sleep(this.backoff(attempt));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError instanceof Error ? lastError : new ConnectionError("Request failed after exhausting retries.");
+  }
+  async fetchWithTimeout(url, init, userSignal) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const onAbort = () => controller.abort();
+    userSignal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await this.fetchImpl(url, { ...init, signal: controller.signal });
+    } catch (err) {
+      if (userSignal?.aborted) {
+        throw new ConnectionError("Request aborted by caller.", { cause: err });
+      }
+      if (controller.signal.aborted) {
+        throw new ConnectionError(`Request timed out after ${this.timeout}ms.`, { cause: err });
+      }
+      throw new ConnectionError("Failed to reach the HoodCompute API.", { cause: err });
+    } finally {
+      clearTimeout(timer);
+      userSignal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async toError(response) {
+    let body;
+    try {
+      const parsed = await response.json();
+      body = "error" in parsed && parsed.error ? parsed.error : parsed;
+    } catch {
+      body = void 0;
+    }
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    return errorFromResponse(response.status, body, requestId);
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseURL}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(options) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: options.stream ? "text/event-stream" : "application/json",
+      "User-Agent": `hoodcompute-sdk-js/${SDK_VERSION}`,
+      ...this.defaultHeaders
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  backoff(attempt, error) {
+    const retryAfter = error && typeof error === "object" && "details" in error && typeof error.details?.retry_after === "number" ? error.details.retry_after * 1e3 : void 0;
+    if (retryAfter !== void 0) return retryAfter;
+    return Math.min(1e3 * 2 ** attempt, 8e3);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/streaming.ts
+var ChatCompletionStream = class {
+  constructor(response) {
+    this.response = response;
+    this.jobId = response.headers.get("x-hoodcompute-job-id");
+    this.receipt = this.readReceipt();
+  }
+  async *[Symbol.asyncIterator]() {
+    const body = this.response.body;
+    if (!body) {
+      throw new ConnectionError("The streaming response contained no body.");
+    }
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf("\n\n");
+        while (boundary !== -1) {
+          const rawEvent = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          const chunk = parseEvent(rawEvent);
+          if (chunk === DONE) {
+            return;
+          }
+          if (chunk) {
+            yield chunk;
+          }
+          boundary = buffer.indexOf("\n\n");
+        }
+      }
+      const trailing = parseEvent(buffer);
+      if (trailing && trailing !== DONE) {
+        yield trailing;
+      }
+    } finally {
+      reader.releaseLock();
+      this.receipt = this.readReceipt();
+    }
+  }
+  /** Convenience: collect the full concatenated text of the stream. */
+  async text() {
+    let out = "";
+    for await (const chunk of this) {
+      out += chunk.choices[0]?.delta?.content ?? "";
+    }
+    return out;
+  }
+  readReceipt() {
+    const h = this.response.headers;
+    const creditsRemaining = h.get("x-hoodcompute-credits-remaining");
+    return {
+      jobId: h.get("x-hoodcompute-job-id"),
+      settlementTx: h.get("x-hoodcompute-settlement-tx"),
+      escrowTx: h.get("x-hoodcompute-tx-hash"),
+      workerAddress: h.get("x-hoodcompute-worker"),
+      creditsRemaining: creditsRemaining !== null ? Number(creditsRemaining) : null
+    };
+  }
+};
+var DONE = /* @__PURE__ */ Symbol("done");
+function parseEvent(raw) {
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trimEnd();
+    if (trimmed.startsWith(":") || trimmed === "") continue;
+    if (trimmed.startsWith("data:")) {
+      dataLines.push(trimmed.slice(5).trimStart());
+    }
+  }
+  if (dataLines.length === 0) return null;
+  const data = dataLines.join("\n");
+  if (data === "[DONE]") return DONE;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/resources/chat.ts
+var Completions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params, options = {}) {
+    if (params.stream) {
+      const response2 = await this.http.raw({
+        method: "POST",
+        path: "/chat/completions",
+        body: params,
+        stream: true,
+        signal: options.signal
+      });
+      return new ChatCompletionStream(response2);
+    }
+    const { data, response } = await this.http.request({
+      method: "POST",
+      path: "/chat/completions",
+      body: params,
+      signal: options.signal
+    });
+    const creditsRemaining = response.headers.get("x-hoodcompute-credits-remaining");
+    return {
+      ...data,
+      jobId: response.headers.get("x-hoodcompute-job-id") ?? data.id,
+      settlementTx: response.headers.get("x-hoodcompute-settlement-tx"),
+      creditsCharged: null,
+      creditsRemaining: creditsRemaining !== null ? Number(creditsRemaining) : null
+    };
+  }
+};
+var Chat = class {
+  constructor(http) {
+    this.completions = new Completions(http);
+  }
+};
+
+// src/resources/models.ts
+function normalize(raw) {
+  return {
+    id: raw.id,
+    object: raw.object,
+    created: raw.created,
+    ownedBy: raw.owned_by,
+    hoodcompute: {
+      tier: raw.hoodcompute.tier,
+      creditsPerRequest: raw.hoodcompute.credits_per_request,
+      creditsPer1kTokens: raw.hoodcompute.credits_per_1k_tokens,
+      activeWorkers: raw.hoodcompute.active_workers,
+      medianLatencyMs: raw.hoodcompute.median_latency_ms,
+      parameters: raw.hoodcompute.parameters,
+      contextWindow: raw.hoodcompute.context_window
+    }
+  };
+}
+var Models = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List every model currently available on the network. */
+  async list(options = {}) {
+    const { data } = await this.http.request({
+      path: "/models",
+      signal: options.signal
+    });
+    return { object: "list", data: data.data.map(normalize) };
+  }
+  /** Retrieve a single model by ID, including its live worker count. */
+  async retrieve(modelId, options = {}) {
+    const { data } = await this.http.request({
+      path: `/models/${encodeURIComponent(modelId)}`,
+      signal: options.signal
+    });
+    return normalize(data);
+  }
+};
+
+// src/resources/jobs.ts
+function normalize2(raw) {
+  return {
+    id: raw.id,
+    object: raw.object,
+    status: raw.status,
+    model: raw.model,
+    tier: raw.tier,
+    creditsCharged: raw.credits_charged,
+    usdgValue: raw.usdg_value,
+    workerAddress: raw.worker_address,
+    createdAt: raw.created_at,
+    completedAt: raw.completed_at,
+    onChain: raw.on_chain ? {
+      escrowTx: raw.on_chain.escrow_tx,
+      settlementTx: raw.on_chain.settlement_tx,
+      escrowAddress: raw.on_chain.escrow_address,
+      blockNumber: raw.on_chain.block_number,
+      proofHash: raw.on_chain.proof_hash
+    } : null,
+    usage: raw.usage
+  };
+}
+var Jobs = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Retrieve a job by ID, including its on-chain settlement detail. */
+  async get(jobId, options = {}) {
+    const { data } = await this.http.request({
+      path: `/jobs/${encodeURIComponent(jobId)}`,
+      signal: options.signal
+    });
+    return normalize2(data);
+  }
+  /** List jobs for the authenticated key, most recent first. */
+  async list(params = {}, options = {}) {
+    const { data } = await this.http.request({
+      path: "/jobs",
+      query: {
+        limit: params.limit,
+        before: params.before,
+        after: params.after,
+        status: params.status,
+        model: params.model
+      },
+      signal: options.signal
+    });
+    return {
+      object: "list",
+      data: data.data.map(normalize2),
+      hasMore: data.has_more,
+      nextCursor: data.next_cursor
+    };
+  }
+  /**
+   * Fetch the on-chain receipt for a settled job. Throws if the job exists but
+   * has not settled yet.
+   */
+  async getReceipt(jobId, options = {}) {
+    const job = await this.get(jobId, options);
+    if (!job.onChain) {
+      throw new NotFoundError(
+        `Job ${jobId} has status "${job.status}" and no on-chain receipt yet.`,
+        { code: "receipt_not_ready" }
+      );
+    }
+    return {
+      jobId: job.id,
+      model: job.model,
+      tier: job.tier,
+      creditsCharged: job.creditsCharged,
+      usdgValue: job.usdgValue,
+      workerAddress: job.workerAddress,
+      escrowTx: job.onChain.escrowTx,
+      settlementTx: job.onChain.settlementTx,
+      blockNumber: job.onChain.blockNumber,
+      proofHash: job.onChain.proofHash
+    };
+  }
+  /**
+   * Open a dispute on a completed job. Must be called within 60 seconds of
+   * receiving the final output token.
+   *
+   * @param receivedOutputHash SHA-256 of the full response text you received,
+   *   formatted as `sha256:<hex>`.
+   */
+  async dispute(jobId, receivedOutputHash, options = {}) {
+    const { data } = await this.http.request({
+      method: "POST",
+      path: `/jobs/${encodeURIComponent(jobId)}/dispute`,
+      body: { received_output_hash: receivedOutputHash },
+      signal: options.signal
+    });
+    return {
+      jobId: data.job_id,
+      disputeOpened: data.dispute_opened,
+      yourHash: data.your_hash,
+      workerHash: data.worker_hash,
+      disputeTx: data.dispute_tx ?? null,
+      arbitrationWindowHours: data.arbitration_window_hours ?? null
+    };
+  }
+};
+
+// src/resources/account.ts
+var AccountResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Retrieve the current account, including the live credit balance. */
+  async get(options = {}) {
+    const { data } = await this.http.request({
+      path: "/account",
+      signal: options.signal
+    });
+    return {
+      wallet: data.wallet,
+      creditsRemaining: data.credits_remaining,
+      usdgValue: data.usdg_value,
+      lastTopupAt: data.last_topup_at ?? null,
+      apiKeyCreatedAt: data.api_key_created_at ?? null
+    };
+  }
+};
+
+// src/client.ts
+var HoodComputeClient = class {
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? readEnv("HOODCOMPUTE_API_KEY");
+    if (!apiKey) {
+      throw new HoodComputeError(
+        "Missing API key. Pass `apiKey` to the client or set the HOODCOMPUTE_API_KEY environment variable.",
+        { code: "missing_api_key" }
+      );
+    }
+    const http = new HttpClient({
+      apiKey,
+      baseURL: options.baseURL ?? DEFAULT_BASE_URL,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT_MS,
+      maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+      defaultHeaders: options.defaultHeaders,
+      fetch: options.fetch
+    });
+    this.chat = new Chat(http);
+    this.models = new Models(http);
+    this.jobs = new Jobs(http);
+    this.account = new AccountResource(http);
+  }
+};
+function readEnv(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+
+// src/react.ts
+function useHoodComputeChat(options) {
+  const { model, apiKey, baseURL, client: providedClient, systemPrompt, onComplete, onError } = options;
+  const [messages, setMessages] = react.useState([]);
+  const [status, setStatus] = react.useState("idle");
+  const [balance, setBalance] = react.useState(null);
+  const [lastReceipt, setLastReceipt] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const client = react.useMemo(
+    () => providedClient ?? new HoodComputeClient({ apiKey, baseURL }),
+    [providedClient, apiKey, baseURL]
+  );
+  const callbacks = react.useRef({ onComplete, onError });
+  callbacks.current = { onComplete, onError };
+  const send = react.useCallback(
+    async (message) => {
+      setError(null);
+      setStatus("streaming");
+      const userMessage = { role: "user", content: message };
+      const history = [...messages, userMessage];
+      setMessages((prev) => [...prev, userMessage, { role: "assistant", content: "" }]);
+      const outbound = systemPrompt ? [{ role: "system", content: systemPrompt }, ...history] : history;
+      try {
+        const stream = await client.chat.completions.create({
+          model,
+          messages: outbound,
+          stream: true
+        });
+        for await (const chunk of stream) {
+          const delta = chunk.choices[0]?.delta?.content;
+          if (!delta) continue;
+          setMessages((prev) => {
+            const next = [...prev];
+            const last = next[next.length - 1];
+            if (last && last.role === "assistant") {
+              next[next.length - 1] = { ...last, content: last.content + delta };
+            }
+            return next;
+          });
+        }
+        setStatus("settling");
+        const receipt = stream.receipt;
+        setLastReceipt(receipt);
+        if (receipt.creditsRemaining !== null) {
+          setBalance({
+            creditsRemaining: receipt.creditsRemaining,
+            usdgValue: Number((receipt.creditsRemaining * 0.01).toFixed(2))
+          });
+        }
+        callbacks.current.onComplete?.(receipt);
+        setStatus("idle");
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        setStatus("error");
+        callbacks.current.onError?.(normalized);
+      }
+    },
+    [client, model, messages, systemPrompt]
+  );
+  const reset = react.useCallback(() => {
+    setMessages([]);
+    setStatus("idle");
+    setError(null);
+    setLastReceipt(null);
+  }, []);
+  return { send, messages, status, balance, lastReceipt, error, reset };
+}
+
+exports.useHoodComputeChat = useHoodComputeChat;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map