okrapdf 0.8.0

package/dist/chunk-HITG34US.js

@@ -0,0 +1,626 @@
+// src/errors.ts
+var OkraRuntimeError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status = 500, details) {
+    super(message);
+    this.name = "OkraRuntimeError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var StructuredOutputError = class extends OkraRuntimeError {
+  code;
+  constructor(code, message, status, details) {
+    super(code, message, status, details);
+    this.name = "StructuredOutputError";
+    this.code = code;
+  }
+};
+
+// src/client.ts
+import { z } from "zod";
+var DEFAULT_BASE_URL = "https://api.okrapdf.com";
+var DEFAULT_WAIT_TIMEOUT_MS = 5 * 6e4;
+var DEFAULT_WAIT_POLL_MS = 1500;
+var COMPLETE_PHASES = /* @__PURE__ */ new Set(["complete", "awaiting_review"]);
+var TERMINAL_ERROR_PHASES = /* @__PURE__ */ new Set(["error"]);
+var STRUCTURED_CODES = /* @__PURE__ */ new Set([
+  "SCHEMA_VALIDATION_FAILED",
+  "EXTRACTION_FAILED",
+  "TIMEOUT",
+  "DOCUMENT_NOT_FOUND"
+]);
+var NODE_FS_PROMISES_SPECIFIER = `node:${"fs/promises"}`;
+var NODE_PATH_SPECIFIER = `node:${"path"}`;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isHttpUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function isDocumentId(value) {
+  return /^(?:ocr|doc)-[A-Za-z0-9_-]+$/.test(value);
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function makeDocId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `doc-${crypto.randomUUID().replace(/-/g, "").slice(0, 20)}`;
+  }
+  const rand = Math.random().toString(36).slice(2, 22);
+  return `doc-${rand}`;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  return new Uint8Array(input);
+}
+function isBlobLike(input) {
+  if (typeof Blob !== "undefined" && input instanceof Blob) return true;
+  return !!input && typeof input === "object" && typeof input.arrayBuffer === "function";
+}
+function inferBlobName(input, fallback) {
+  const named = input;
+  if (typeof named.name === "string" && named.name.trim() !== "") {
+    return named.name;
+  }
+  return fallback;
+}
+async function readLocalFileFromNode(inputPath) {
+  try {
+    const [fsModule, pathModule] = await Promise.all([
+      import(NODE_FS_PROMISES_SPECIFIER),
+      import(NODE_PATH_SPECIFIER)
+    ]);
+    const raw = await fsModule.readFile(inputPath);
+    return {
+      bytes: toUint8Array(raw),
+      fileName: pathModule.basename(inputPath)
+    };
+  } catch (error) {
+    throw new OkraRuntimeError(
+      "INVALID_REQUEST",
+      "Local file path uploads are only supported in Node.js. In browser runtimes, pass File/Blob, ArrayBuffer, Uint8Array, or URL.",
+      400,
+      error
+    );
+  }
+}
+function normalizeSchema(schema) {
+  const maybeZod = schema;
+  const hasSafeParse = typeof maybeZod.safeParse === "function";
+  if (hasSafeParse) {
+    return {
+      jsonSchema: z.toJSONSchema(maybeZod, { target: "draft-2020-12" }),
+      parser: maybeZod
+    };
+  }
+  return { jsonSchema: schema };
+}
+function isStructuredCode(code) {
+  return !!code && STRUCTURED_CODES.has(code);
+}
+var OkraSessionHandle = class {
+  id;
+  modelEndpoint;
+  #model;
+  #client;
+  constructor(client, documentId, model) {
+    this.#client = client;
+    this.id = documentId;
+    this.modelEndpoint = client.modelEndpoint(documentId);
+    this.#model = model;
+  }
+  get model() {
+    return this.#model;
+  }
+  state() {
+    return {
+      id: this.id,
+      model: this.#model,
+      modelEndpoint: this.modelEndpoint
+    };
+  }
+  async setModel(model) {
+    const normalized = model.trim();
+    if (!normalized) {
+      throw new OkraRuntimeError("INVALID_REQUEST", "session.setModel requires a non-empty model", 400);
+    }
+    this.#model = normalized;
+  }
+  status(signal) {
+    return this.#client.status(this.id, signal);
+  }
+  wait(options) {
+    return this.#client.wait(this.id, options);
+  }
+  pages(options) {
+    return this.#client.pages(this.id, options);
+  }
+  page(pageNumber, signal) {
+    return this.#client.page(this.id, pageNumber, signal);
+  }
+  entities(options) {
+    return this.#client.entities(this.id, options);
+  }
+  downloadUrl() {
+    return this.#client.downloadUrl(this.id);
+  }
+  query(sql, signal) {
+    return this.#client.query(this.id, sql, signal);
+  }
+  publish(signal) {
+    return this.#client.publish(this.id, signal);
+  }
+  shareLink(options) {
+    return this.#client.shareLink(this.id, options);
+  }
+  prompt(query, options) {
+    const model = options?.model ?? this.#model;
+    const merged = model ? { ...options, model } : options;
+    if (merged?.schema !== void 0) {
+      return this.#client.generate(
+        this.id,
+        query,
+        merged
+      );
+    }
+    return this.#client.generate(
+      this.id,
+      query,
+      merged
+    );
+  }
+  stream(query, options) {
+    const model = options?.model ?? this.#model;
+    const merged = model ? { ...options, model } : options;
+    return this.#client.stream(this.id, query, merged);
+  }
+};
+var OkraClient = class {
+  baseUrl;
+  apiKey;
+  sharedSecret;
+  fetchImpl;
+  sessions;
+  deployments;
+  constructor(options) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl || DEFAULT_BASE_URL);
+    this.apiKey = options.apiKey;
+    this.sharedSecret = options.sharedSecret;
+    this.fetchImpl = options.fetch || globalThis.fetch.bind(globalThis);
+    if (!this.apiKey && !this.sharedSecret) {
+      throw new OkraRuntimeError(
+        "UNAUTHORIZED",
+        "OkraClient requires either apiKey or sharedSecret",
+        401
+      );
+    }
+    if (typeof globalThis !== "undefined" && "window" in globalThis && this.apiKey && !this.apiKey.startsWith("okra_pk_")) {
+      console.warn(
+        "[OkraPDF] Secret API key detected in browser. Use a publishable key (okra_pk_...) for client-side usage. See https://docs.okrapdf.dev/api-keys#publishable-keys"
+      );
+    }
+    this.sessions = {
+      create: async (sourceOrDocId, sessionOptions = {}) => {
+        let documentId;
+        if (typeof sourceOrDocId === "string" && isDocumentId(sourceOrDocId.trim())) {
+          documentId = sourceOrDocId.trim();
+        } else {
+          const session2 = await this.upload(sourceOrDocId, sessionOptions.upload);
+          documentId = session2.id;
+        }
+        const session = this.sessions.from(documentId, { model: sessionOptions.model });
+        if (sessionOptions.wait ?? true) {
+          await session.wait(sessionOptions.waitOptions);
+        }
+        return session;
+      },
+      from: (documentId, sessionOptions = {}) => {
+        const normalized = documentId.trim();
+        if (!normalized) {
+          throw new OkraRuntimeError(
+            "INVALID_REQUEST",
+            "sessions.from requires a non-empty documentId",
+            400
+          );
+        }
+        return new OkraSessionHandle(
+          this,
+          normalized,
+          sessionOptions.model?.trim() || void 0
+        );
+      }
+    };
+    this.deployments = {
+      create: async (opts) => {
+        return this.requestJson("/v1/deployments", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(opts)
+        });
+      },
+      status: async (deploymentId) => {
+        return this.requestJson(`/d/${deploymentId}/status`, {
+          method: "GET"
+        });
+      },
+      completion: async (deploymentId, opts) => {
+        return this.requestJson(`/d/${deploymentId}/completion`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(opts)
+        });
+      },
+      tokens: {
+        create: async (deploymentId, opts) => {
+          return this.requestJson(`/d/${deploymentId}/tokens`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+        },
+        list: async (deploymentId) => {
+          return this.requestJson(`/d/${deploymentId}/tokens`, {
+            method: "GET"
+          });
+        },
+        revoke: async (deploymentId, tokenHint) => {
+          return this.requestJson(`/d/${deploymentId}/tokens/${tokenHint}`, {
+            method: "DELETE"
+          });
+        }
+      }
+    };
+  }
+  // ─── Upload ──────────────────────────────────────────────────────────────
+  async upload(input, options = {}) {
+    const documentId = options.documentId || makeDocId();
+    const path = `/document/${encodeURIComponent(documentId)}`;
+    const visibility = options.visibility || "private";
+    if (typeof input === "string" && isHttpUrl(input)) {
+      const urlHeaders = { "Content-Type": "application/json" };
+      if (options.vendorKeys) {
+        urlHeaders["X-Vendor-Keys"] = JSON.stringify(options.vendorKeys);
+      }
+      await this.requestJson(`${path}/upload-url`, {
+        method: "POST",
+        headers: urlHeaders,
+        body: JSON.stringify({
+          url: input,
+          capabilities: options.capabilities,
+          visibility,
+          redact: options.redact
+        })
+      });
+      return this.sessions.from(documentId);
+    }
+    let bytes;
+    let fileName = options.fileName || "document.pdf";
+    if (typeof input === "string") {
+      const local = await readLocalFileFromNode(input);
+      bytes = local.bytes;
+      if (!options.fileName) fileName = local.fileName;
+    } else if (isBlobLike(input)) {
+      bytes = toUint8Array(await input.arrayBuffer());
+      if (!options.fileName) {
+        fileName = inferBlobName(input, fileName);
+      }
+    } else {
+      bytes = toUint8Array(input);
+    }
+    const headers = {
+      "Content-Type": "application/pdf",
+      "X-File-Name": fileName
+    };
+    if (options.capabilities) {
+      headers["X-Capabilities"] = JSON.stringify(options.capabilities);
+    }
+    if (options.vendorKeys) {
+      headers["X-Vendor-Keys"] = JSON.stringify(options.vendorKeys);
+    }
+    if (options.redact) {
+      headers["X-Redact"] = JSON.stringify(options.redact);
+    }
+    if (visibility === "public") {
+      headers["X-Visibility"] = "public";
+    }
+    await this.requestJson(`${path}/upload`, {
+      method: "POST",
+      headers,
+      body: bytes
+    });
+    return this.sessions.from(documentId);
+  }
+  // ─── Status / Wait ───────────────────────────────────────────────────────
+  async status(documentId, signal) {
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/status`,
+      { method: "GET", signal }
+    );
+  }
+  async wait(documentId, options = {}) {
+    const startedAt = Date.now();
+    const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_WAIT_POLL_MS;
+    while (true) {
+      if (options.signal?.aborted) {
+        throw new OkraRuntimeError("TIMEOUT", "Wait aborted", 499);
+      }
+      const current = await this.status(documentId, options.signal);
+      if (COMPLETE_PHASES.has(current.phase)) {
+        return current;
+      }
+      if (TERMINAL_ERROR_PHASES.has(current.phase)) {
+        throw new OkraRuntimeError(
+          "EXTRACTION_FAILED",
+          `Document entered terminal error phase (${current.phase})`,
+          500,
+          current
+        );
+      }
+      const elapsed = Date.now() - startedAt;
+      if (elapsed >= timeoutMs) {
+        throw new OkraRuntimeError(
+          "TIMEOUT",
+          `Timed out waiting for document ${documentId} after ${timeoutMs}ms`,
+          504,
+          current
+        );
+      }
+      await sleep(pollIntervalMs);
+    }
+  }
+  // ─── Pages ───────────────────────────────────────────────────────────────
+  async pages(documentId, options) {
+    const params = options?.range ? `?range=${encodeURIComponent(options.range)}` : "";
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/pages${params}`,
+      { method: "GET", signal: options?.signal }
+    );
+  }
+  async page(documentId, pageNumber, signal) {
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/page/${pageNumber}`,
+      { method: "GET", signal }
+    );
+  }
+  // ─── Download ──────────────────────────────────────────────────────────
+  downloadUrl(documentId) {
+    return `${this.baseUrl}/document/${encodeURIComponent(documentId)}/download`;
+  }
+  // ─── Entities ────────────────────────────────────────────────────────────
+  async entities(documentId, options) {
+    const params = new URLSearchParams();
+    if (options?.type) params.set("type", options.type);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    const qs = params.toString();
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/nodes${qs ? `?${qs}` : ""}`,
+      { method: "GET", signal: options?.signal }
+    );
+  }
+  // ─── Query (SQL) ─────────────────────────────────────────────────────────
+  async query(documentId, sql, signal) {
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/query?select=${encodeURIComponent(sql)}`,
+      { method: "GET", signal }
+    );
+  }
+  // ─── Stream (streaming completion) ────────────────────────────────────────
+  async *stream(documentId, query, options) {
+    const response = await this.rawRequest(
+      `/document/${encodeURIComponent(documentId)}/completion`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          prompt: query,
+          stream: options?.stream !== false,
+          ...options?.model ? { model: options.model } : {}
+        }),
+        signal: options?.signal
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new OkraRuntimeError("HTTP_ERROR", `Completion failed: ${text}`, response.status);
+    }
+    if (!response.body) {
+      throw new OkraRuntimeError("INVALID_RESPONSE", "No response body for completion stream", 500);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      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() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            yield JSON.parse(trimmed);
+          } catch {
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          yield JSON.parse(buffer.trim());
+        } catch {
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async generate(documentId, query, options) {
+    if (options?.schema) {
+      return this.generateStructured(documentId, query, options);
+    }
+    const result = await this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/completion`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          prompt: query,
+          ...options?.model ? { model: options.model } : {}
+        }),
+        signal: options?.signal
+      }
+    );
+    return {
+      answer: result.answer,
+      costUsd: result.usage?.costUsd
+    };
+  }
+  async generateStructured(documentId, query, options) {
+    if (!query || query.trim() === "") {
+      throw new OkraRuntimeError("INVALID_REQUEST", "generate with schema requires a non-empty query", 400);
+    }
+    const normalized = normalizeSchema(options.schema);
+    const body = await this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/completion`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          prompt: query,
+          schema: normalized.jsonSchema,
+          ...options.model ? { model: options.model } : {},
+          ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {}
+        }),
+        signal: options.signal
+      }
+    );
+    let data;
+    if (normalized.parser) {
+      const parsed = normalized.parser.safeParse(body.data);
+      if (!parsed.success) {
+        throw new StructuredOutputError(
+          "SCHEMA_VALIDATION_FAILED",
+          "Client-side schema validation failed for structured output response",
+          422,
+          parsed.error.issues
+        );
+      }
+      data = parsed.data;
+    } else {
+      data = body.data;
+    }
+    return {
+      answer: "",
+      data,
+      meta: body.meta
+    };
+  }
+  // ─── Model Endpoint ──────────────────────────────────────────────────────
+  modelEndpoint(documentId) {
+    return `${this.baseUrl}/v1/documents/${encodeURIComponent(documentId)}`;
+  }
+  // ─── Publish / Share ────────────────────────────────────────────────────
+  async publish(documentId, signal) {
+    const result = await this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/publish`,
+      { method: "POST", signal }
+    );
+    return {
+      ...result,
+      url: `${this.baseUrl}/v1/documents/${encodeURIComponent(documentId)}`
+    };
+  }
+  async shareLink(documentId, options) {
+    return this.requestJson(
+      `/document/${encodeURIComponent(documentId)}/share-link`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          role: options?.role,
+          label: options?.label,
+          expiresInMs: options?.expiresInMs,
+          maxViews: options?.maxViews
+        }),
+        signal: options?.signal
+      }
+    );
+  }
+  // ─── Public HTTP ─────────────────────────────────────────────────────────
+  async request(path, init = {}) {
+    return this.requestJson(path, init);
+  }
+  get url() {
+    return this.baseUrl;
+  }
+  // ─── Internal HTTP ───────────────────────────────────────────────────────
+  authHeaders() {
+    if (this.apiKey) return { Authorization: `Bearer ${this.apiKey}` };
+    if (this.sharedSecret) return { "x-document-agent-secret": this.sharedSecret };
+    return {};
+  }
+  async rawRequest(path, init) {
+    const headers = new Headers(init.headers);
+    for (const [key, value] of Object.entries(this.authHeaders())) {
+      if (!headers.has(key)) headers.set(key, value);
+    }
+    try {
+      return await this.fetchImpl(`${this.baseUrl}${path}`, { ...init, headers });
+    } catch (err) {
+      throw new OkraRuntimeError(
+        "HTTP_ERROR",
+        err instanceof Error ? err.message : String(err),
+        502
+      );
+    }
+  }
+  async requestJson(path, init) {
+    const response = await this.rawRequest(path, init);
+    const text = await response.text();
+    const parsed = this.parseBody(text);
+    if (!response.ok) {
+      const envelope = parsed;
+      const code = envelope?.code;
+      const message = envelope?.message || envelope?.error || `Request failed with status ${response.status}`;
+      const details = envelope?.details ?? parsed ?? text;
+      if (isStructuredCode(code)) {
+        throw new StructuredOutputError(code, message, response.status, details);
+      }
+      const runtimeCode = response.status === 401 ? "UNAUTHORIZED" : "HTTP_ERROR";
+      throw new OkraRuntimeError(runtimeCode, message, response.status, details);
+    }
+    if (parsed === null) {
+      throw new OkraRuntimeError(
+        "INVALID_RESPONSE",
+        `Expected JSON response for ${path}`,
+        response.status,
+        text
+      );
+    }
+    return parsed;
+  }
+  parseBody(text) {
+    const trimmed = text.trim();
+    if (!trimmed) return null;
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  OkraRuntimeError,
+  StructuredOutputError,
+  OkraClient
+};
+//# sourceMappingURL=chunk-HITG34US.js.map