okrapdf 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { O as OkraClient } from './client-aHzx0a5x.js';
+import { l as OkraClientOptions, R as RuntimeErrorCode, u as StructuredOutputErrorCode } from './types-DEYgGUnH.js';
+export { o as CompletionEvent, C as CompletionOptions, c as DeploymentCreateOptions, d as DeploymentResult, D as DocUrlOptions, n as DocumentStatus, E as EntitiesResponse, v as Entity, G as GenerateOptions, p as GenerateResult, J as JsonSchema, O as OkraSession, P as Page, w as PageBlock, x as PageEntity, r as PublishResult, Q as QueryResult, b as SessionAttachOptions, S as SessionCreateOptions, y as SessionState, z as ShareLinkCapabilities, A as ShareLinkLinks, s as ShareLinkOptions, t as ShareLinkResult, B as StructuredOutputMeta, q as StructuredSchema, a as UploadInput, m as UploadOptions, F as UploadRedactOptions, H as UploadRedactPiiOptions, U as UrlBuilderOptions, W as WaitOptions } from './types-DEYgGUnH.js';
+export { doc } from './url.js';
+import 'zod';
+
+type ExtractionPhase = 'ocr' | 'enhance' | 'metadata' | 'verify';
+interface OkraProvider {
+    name: string;
+    supportedPhases: ExtractionPhase[];
+}
+interface OkraMiddleware {
+    name: string;
+    config: Record<string, unknown>;
+}
+interface CreateOkraOptions extends OkraClientOptions {
+    providers?: Record<string, OkraProvider>;
+    extraction?: Partial<Record<ExtractionPhase, string>>;
+    middleware?: OkraMiddleware[];
+    vendorKeys?: Record<string, string>;
+}
+/**
+ * Factory function — AI SDK-style provider abstraction.
+ *
+ * ```ts
+ * import { createOkra } from 'okrapdf';
+ *
+ * const okra = createOkra({
+ *   apiKey: 'okra_...',
+ *   providers: { azureDocAI },
+ *   extraction: { ocr: 'azureDocAI' },
+ * });
+ * ```
+ */
+declare function createOkra(options: CreateOkraOptions): OkraClient;
+declare function withCache(opts: {
+    by: 'pdf-hash' | 'content-hash';
+}): OkraMiddleware;
+declare function withQualityScore(opts: {
+    threshold: number;
+}): OkraMiddleware;
+declare function withSecret(namespace: string, opts?: {
+    required?: boolean;
+}): OkraMiddleware;
+
+declare class OkraRuntimeError extends Error {
+    readonly code: RuntimeErrorCode;
+    readonly status: number;
+    readonly details?: unknown;
+    constructor(code: RuntimeErrorCode, message: string, status?: number, details?: unknown);
+}
+declare class StructuredOutputError extends OkraRuntimeError {
+    readonly code: StructuredOutputErrorCode;
+    constructor(code: StructuredOutputErrorCode, message: string, status: number, details?: unknown);
+}
+
+export { type CreateOkraOptions, type ExtractionPhase, OkraClient, OkraClientOptions, type OkraMiddleware, type OkraProvider, OkraClient as OkraRuntime, OkraRuntimeError, RuntimeErrorCode, StructuredOutputError, StructuredOutputErrorCode, createOkra, withCache, withQualityScore, withSecret };

package/dist/index.js

@@ -0,0 +1,26 @@
+import {
+  doc
+} from "./chunk-C6ZT7DKX.js";
+import {
+  createOkra,
+  withCache,
+  withQualityScore,
+  withSecret
+} from "./chunk-AG3A2T3B.js";
+import {
+  OkraClient,
+  OkraRuntimeError,
+  StructuredOutputError
+} from "./chunk-HITG34US.js";
+export {
+  OkraClient,
+  OkraClient as OkraRuntime,
+  OkraRuntimeError,
+  StructuredOutputError,
+  createOkra,
+  doc,
+  withCache,
+  withQualityScore,
+  withSecret
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react/index.d.ts

@@ -0,0 +1,197 @@
+import * as react from 'react';
+import { O as OkraClient } from '../client-aHzx0a5x.js';
+import { O as OkraSession, n as DocumentStatus, P as Page, q as StructuredSchema, p as GenerateResult } from '../types-DEYgGUnH.js';
+export { o as CompletionEvent } from '../types-DEYgGUnH.js';
+import 'zod';
+
+interface OkraContextValue {
+    client: OkraClient;
+    apiKey: string;
+}
+interface OkraProviderProps {
+    apiKey: string;
+    baseUrl?: string;
+    children: React.ReactNode;
+}
+/**
+ * Provides the OkraPDF runtime client to all child hooks.
+ *
+ * ```tsx
+ * <OkraProvider apiKey={process.env.OKRA_API_KEY!}>
+ *   <App />
+ * </OkraProvider>
+ * ```
+ */
+declare function OkraProvider({ apiKey, baseUrl, children }: OkraProviderProps): react.FunctionComponentElement<react.ProviderProps<OkraContextValue | null>>;
+/**
+ * Access the OkraPDF runtime client from context.
+ *
+ * ```ts
+ * const { client } = useOkra();
+ * const session = await client.sessions.create(file);
+ * ```
+ */
+declare function useOkra(): OkraContextValue;
+
+interface Message {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    createdAt?: Date;
+    sources?: Array<{
+        page: number;
+        snippet: string;
+    }>;
+}
+type SessionStatus = 'idle' | 'uploading' | 'processing' | 'ready' | 'error';
+interface UseDocumentSessionReturn {
+    session: OkraSession | null;
+    status: SessionStatus;
+    error: Error | null;
+    upload: (source: string | File | Blob) => Promise<void>;
+    documentStatus: DocumentStatus | null;
+}
+interface UseChatReturn {
+    messages: Message[];
+    input: string;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    handleSubmit: (e?: {
+        preventDefault?: () => void;
+    }) => void;
+    isLoading: boolean;
+    stop: () => void;
+    append: (message: Pick<Message, 'role' | 'content'>) => void;
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+}
+interface ChatConfig {
+    session: OkraSession | null;
+    /** Use streaming (default: true) */
+    stream?: boolean;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+}
+
+interface UseDocumentSessionOptions {
+    /** If true (default), waits for extraction to complete before session is ready */
+    wait?: boolean;
+}
+/**
+ * Upload a document and get an interactive session.
+ *
+ * ```tsx
+ * const { session, status, upload } = useDocumentSession();
+ * await upload(file); // or upload('https://...')
+ * // session is ready when status === 'ready'
+ * ```
+ */
+declare function useDocumentSession(options?: UseDocumentSessionOptions): UseDocumentSessionReturn;
+
+interface UseDocumentStatusOptions {
+    /** Poll interval in ms while processing (default: 2000). 0 to disable. */
+    pollInterval?: number;
+    /** Skip fetching entirely */
+    enabled?: boolean;
+}
+interface UseDocumentStatusReturn {
+    data: DocumentStatus | null;
+    isLoading: boolean;
+    error: Error | null;
+    isComplete: boolean;
+    isProcessing: boolean;
+    refetch: () => void;
+}
+/**
+ * Poll document processing status from the CF Worker.
+ * Accepts either a session object or a raw document ID.
+ *
+ * ```tsx
+ * const { data, isComplete, isProcessing } = useDocumentStatus(session);
+ * // or
+ * const { data } = useDocumentStatus('doc-abc123');
+ * ```
+ */
+declare function useDocumentStatus(sessionOrId: OkraSession | string | null, options?: UseDocumentStatusOptions): UseDocumentStatusReturn;
+
+interface UsePagesOptions {
+    /** Skip fetching (default: true) */
+    enabled?: boolean;
+}
+interface UsePagesReturn {
+    data: Page[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+/**
+ * Fetch all pages for a document.
+ *
+ * ```tsx
+ * const { data: pages, isLoading } = usePages(session);
+ * // or with a document ID
+ * const { data: pages } = usePages('doc-abc123');
+ * ```
+ */
+declare function usePages(sessionOrId: OkraSession | string | null, options?: UsePagesOptions): UsePagesReturn;
+
+interface UsePageContentOptions {
+    /** Poll interval while content not yet ready (default: 3000). 0 to disable. */
+    pollInterval?: number;
+}
+interface UsePageContentReturn {
+    data: Page | null;
+    content: string;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+/**
+ * Fetch a single page's content (markdown + blocks + entities).
+ * Polls until content arrives if the page is still processing.
+ *
+ * ```tsx
+ * const { content, data, isLoading } = usePageContent(session, 1);
+ * ```
+ */
+declare function usePageContent(sessionOrId: OkraSession | string | null, pageNumber: number, options?: UsePageContentOptions): UsePageContentReturn;
+
+declare function useChat(config: ChatConfig): UseChatReturn;
+
+interface UseDocumentQueryOptions<T = undefined> {
+    /** Document ID (e.g. "doc-xxx" or "ocr-xxx") */
+    documentId: string | null;
+    /** The query/prompt to run against the document */
+    query: string;
+    /** JSON schema or Zod schema for structured output */
+    schema?: StructuredSchema<T>;
+    /** Skip the query (e.g. while waiting for doc to be ready) */
+    skip?: boolean;
+    /** Model override */
+    model?: string;
+    /** Timeout in ms */
+    timeoutMs?: number;
+    /** How long cached results stay valid in ms (default: 300000 / 5 min) */
+    cacheTime?: number;
+}
+interface UseDocumentQueryReturn<T = undefined> {
+    data: T | null;
+    result: GenerateResult<T> | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+/**
+ * Run a one-shot query against a document, optionally with structured output.
+ * Results are cached in-memory for `cacheTime` ms (default 5 min).
+ *
+ * ```tsx
+ * const { data } = useDocumentQuery({
+ *   documentId: "doc-xxx",
+ *   query: "Generate 4 chat suggestions",
+ *   schema: z.object({ suggestions: z.array(z.object({ id: z.string(), text: z.string() })) }),
+ *   skip: !isReady,
+ * })
+ * ```
+ */
+declare function useDocumentQuery<T = undefined>(options: UseDocumentQueryOptions<T>): UseDocumentQueryReturn<T>;
+
+export { type ChatConfig, DocumentStatus, GenerateResult, type Message, type OkraContextValue, OkraProvider, type OkraProviderProps, OkraSession, Page, type SessionStatus, type UseChatReturn, type UseDocumentQueryOptions, type UseDocumentQueryReturn, type UseDocumentSessionOptions, type UseDocumentSessionReturn, type UseDocumentStatusOptions, type UseDocumentStatusReturn, type UsePageContentOptions, type UsePageContentReturn, type UsePagesOptions, type UsePagesReturn, useChat, useDocumentQuery, useDocumentSession, useDocumentStatus, useOkra, usePageContent, usePages };