@pdfvector/instance-client 0.0.18 → 0.0.20

package/.tsc/lib/index.d.ts

@@ -1,8 +1,59 @@
 import type { ContractRouterClient } from "@orpc/contract";
 import type { contract } from "@pdfvector/instance-contract";
 export interface CreateClientOptions {
-    url: string;
-    secret: string;
+    /** Domain of the PDFVector instance server (e.g., "your-instance.pdfvector.com"). Defaults to "global.pdfvector.com". */
+    domain?: string;
+    /** API key for Bearer token authentication */
+    apiKey?: string;
+    /** @internal Server secret */
+    secret?: string;
 }
-export declare function createClient(options: CreateClientOptions): Client;
-export type Client = ContractRouterClient<typeof contract>;
+/** Per-request context passed as the second argument to any API call. */
+export interface ClientContext {
+    /** Document ID for usage tracking. Returned in response for document, identity, invoice, and bank statement endpoints. */
+    documentId?: string;
+}
+/**
+ * Custom error class for PDFVector API errors.
+ *
+ * All API errors thrown by the client are instances of this class.
+ * Provides structured access to error code, HTTP status, message, and additional data.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.document.parse({ url: "..." });
+ * } catch (error) {
+ *   if (error instanceof PDFVectorError) {
+ *     console.error(error.code);    // "UNAUTHORIZED" | "BAD_REQUEST" | ...
+ *     console.error(error.status);  // 401 | 400 | 422 | 500
+ *     console.error(error.message); // "Invalid API key"
+ *     console.error(error.data);    // { requestId: 1 }
+ *   }
+ * }
+ * ```
+ */
+export declare class PDFVectorError extends Error {
+    /** Error code identifying the type of error */
+    readonly code: string;
+    /** HTTP status code */
+    readonly status: number;
+    /** Additional error data from the server (e.g., requestId) */
+    readonly data: unknown;
+    constructor(options: {
+        code: string;
+        message: string;
+        status: number;
+        data?: unknown;
+    });
+    /**
+     * Type guard to check if an unknown error is a PDFVectorError.
+     */
+    static is(error: unknown): error is PDFVectorError;
+}
+/** @internal */
+export declare function _buildClient(options?: CreateClientOptions): Client;
+export declare function createClient(options?: CreateClientOptions): PublicClient;
+type Client = ContractRouterClient<typeof contract, ClientContext>;
+export type PublicClient = Omit<ContractRouterClient<typeof contract, ClientContext>, "admin" | "free">;
+export type { ContractInputs, ContractOutputs, PDFVectorModel, } from "@pdfvector/instance-contract";

package/.tsc/lib/index.js

@@ -1,11 +1,83 @@
-import { createORPCClient } from "@orpc/client";
+import { createORPCClient, ORPCError, onError } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
-export function createClient(options) {
+const DEFAULT_DOMAIN = "global.pdfvector.com";
+/**
+ * Custom error class for PDFVector API errors.
+ *
+ * All API errors thrown by the client are instances of this class.
+ * Provides structured access to error code, HTTP status, message, and additional data.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.document.parse({ url: "..." });
+ * } catch (error) {
+ *   if (error instanceof PDFVectorError) {
+ *     console.error(error.code);    // "UNAUTHORIZED" | "BAD_REQUEST" | ...
+ *     console.error(error.status);  // 401 | 400 | 422 | 500
+ *     console.error(error.message); // "Invalid API key"
+ *     console.error(error.data);    // { requestId: 1 }
+ *   }
+ * }
+ * ```
+ */
+export class PDFVectorError extends Error {
+    /** Error code identifying the type of error */
+    code;
+    /** HTTP status code */
+    status;
+    /** Additional error data from the server (e.g., requestId) */
+    data;
+    constructor(options) {
+        super(options.message);
+        this.name = "PDFVectorError";
+        this.code = options.code;
+        this.status = options.status;
+        this.data = options.data;
+    }
+    /**
+     * Type guard to check if an unknown error is a PDFVectorError.
+     */
+    static is(error) {
+        return error instanceof PDFVectorError;
+    }
+}
+/** @internal */
+export function _buildClient(options) {
+    const domain = options?.domain ?? DEFAULT_DOMAIN;
+    const isLocal = domain.startsWith("localhost") || domain.startsWith("127.0.0.1");
+    const baseUrl = `${isLocal ? "http" : "https"}://${domain}`;
+    const token = options?.apiKey ?? options?.secret;
     const link = new RPCLink({
-        url: `${options.url}/rpc`,
-        headers: () => ({
-            authorization: `Bearer ${options.secret}`,
-        }),
+        url: `${baseUrl}/rpc`,
+        headers: ({ context }) => {
+            const headers = {};
+            if (token) {
+                headers.authorization = `Bearer ${token}`;
+            }
+            if (context?.documentId) {
+                headers["x-pdfvector-document-id"] = context.documentId;
+            }
+            return headers;
+        },
+        fetch: token
+            ? undefined
+            : (input, init) => fetch(input, { ...init, credentials: "include" }),
+        interceptors: [
+            onError((error) => {
+                if (error instanceof ORPCError) {
+                    throw new PDFVectorError({
+                        code: error.code,
+                        message: error.message,
+                        status: error.status,
+                        data: error.data,
+                    });
+                }
+            }),
+        ],
     });
     return createORPCClient(link);
 }
+export function createClient(options) {
+    return _buildClient(options);
+}

package/.tsc/lib/internal.d.ts

@@ -0,0 +1,5 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import type { contract } from "@pdfvector/instance-contract";
+import { type ClientContext, type CreateClientOptions } from ".";
+export type Client = ContractRouterClient<typeof contract, ClientContext>;
+export declare function createInternalClient(options?: CreateClientOptions): Client;

package/.tsc/lib/internal.js

@@ -0,0 +1,4 @@
+import { _buildClient } from ".";
+export function createInternalClient(options) {
+    return _buildClient(options);
+}

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @pdfvector/instance-client
 
+## 0.0.20
+### Patch Changes
+
+
+
+- [#129](https://github.com/phuctm97/pdfvector/pull/129) [`111c98f`](https://github.com/phuctm97/pdfvector/commit/111c98f003f1ffb29c0515b08ad3567505396d86) Thanks [@khanhduyvt0101](https://github.com/khanhduyvt0101)! - Add public/internal SDK client split, hide free API from docs, and update landing page code examples
+
+## 0.0.19
+### Patch Changes
+
+
+
+- [#126](https://github.com/phuctm97/pdfvector/pull/126) [`9f3db7d`](https://github.com/phuctm97/pdfvector/commit/9f3db7d4114169d2dff0f83cad7bf87e054e9206) Thanks [@khanhduyvt0101](https://github.com/khanhduyvt0101)! - Enhance instance client as publishable PDFVector SDK
+
+- Updated dependencies [[`9f3db7d`](https://github.com/phuctm97/pdfvector/commit/9f3db7d4114169d2dff0f83cad7bf87e054e9206)]:
+  - @pdfvector/instance-contract@0.0.22
+
 ## 0.0.18
 ### Patch Changes
 

package/README.md

@@ -0,0 +1,562 @@
+# PDFVector TypeScript/JavaScript SDK
+
+The official TypeScript/JavaScript SDK for the [PDFVector](https://www.pdfvector.com) API: Parse PDF, Word, Image, and Excel documents to clean, structured markdown format, ask questions about documents using AI, extract structured data from documents with JSON Schema, search across multiple academic databases with a unified API, fetch specific publications by DOI, PubMed ID, ArXiv ID, and more, and find relevant academic citations for paragraphs of text.
+
+## Installation
+
+```bash
+npm install @pdfvector/instance-client
+# or
+yarn add @pdfvector/instance-client
+# or
+pnpm add @pdfvector/instance-client
+# or
+bun add @pdfvector/instance-client
+```
+
+## Quick Start
+
+```typescript
+import { createClient } from "@pdfvector/instance-client";
+
+const client = createClient({
+  apiKey: "your-api-key",
+});
+
+// Parse a document
+const parseResult = await client.document.parse({
+  url: "https://example.com/document.pdf",
+});
+
+console.log(parseResult.markdown);
+console.log(`Pages: ${parseResult.pageCount}, Model: ${parseResult.model}`);
+
+// Ask questions about documents
+const askResult = await client.document.ask({
+  url: "https://example.com/research-paper.pdf",
+  question: "What are the key findings and conclusions?",
+});
+
+console.log(askResult.markdown);
+
+// Extract structured data using JSON Schema
+const extractResult = await client.document.extract({
+  url: "https://example.com/research-paper.pdf",
+  prompt: "Extract the research information",
+  schema: {
+    type: "object",
+    properties: {
+      title: { type: "string" },
+      authors: { type: "array", items: { type: "string" } },
+      abstract: { type: "string" },
+      findings: { type: "array", items: { type: "string" } },
+    },
+    required: ["title", "abstract"],
+  },
+});
+
+console.log(extractResult.data);
+```
+
+## Authentication
+
+Get your API key from the [PDFVector dashboard](https://app.pdfvector.com/instances/2?tab=settings).
+
+```typescript
+const client = createClient({
+  apiKey: "your-api-key",
+});
+```
+
+Verify your credentials:
+
+```typescript
+const status = await client.authenticate.validateCredential();
+console.log(status.version); // Server version
+```
+
+### Custom Domain
+
+By default, the SDK connects to `global.pdfvector.com`. For custom or self-hosted instances:
+
+```typescript
+const client = createClient({
+  domain: "your-instance.pdfvector.com",
+  apiKey: "your-api-key",
+});
+
+// For local development
+const localClient = createClient({
+  domain: "localhost:34000",
+  apiKey: "your-api-key",
+});
+```
+
+## Document Processing
+
+All document endpoints accept three input methods: `url`, `file` (File/Blob), or `base64`.
+
+**Supported file types:** PDF, Word (.docx), Excel (.xlsx), CSV, and Image (.png, .jpg).
+
+### Parse
+
+Extract text content from documents:
+
+```typescript
+const result = await client.document.parse(
+  {
+    url: "https://example.com/document.pdf",
+    model: "auto", // "auto" | "nano" | "mini" | "pro" | "max"
+  },
+  { context: { documentId: "my-doc-123" } }, // optional, for usage tracking
+);
+
+console.log(result.markdown);  // Extracted text
+console.log(result.pageCount); // Number of pages
+console.log(result.model);     // Model tier used
+console.log(result.html);      // Full HTML (only with 'max' model)
+console.log(result.documentId); // "my-doc-123"
+```
+
+### Parse from file data
+
+```typescript
+import { readFile } from "fs/promises";
+
+const result = await client.document.parse(
+  {
+    file: new File([await readFile("document.pdf")], "document.pdf", {
+      type: "application/pdf",
+    }),
+    model: "auto",
+  },
+  { context: { documentId: "uploaded-doc" } },
+);
+
+console.log(result.markdown);
+```
+
+### Ask
+
+Answer questions about a document:
+
+```typescript
+const result = await client.document.ask(
+  {
+    url: "https://example.com/research-paper.pdf",
+    question: "What are the main findings of this study?",
+    model: "auto",
+  },
+  { context: { documentId: "research-paper-1" } },
+);
+
+console.log(result.markdown);
+```
+
+### Extract
+
+Extract structured data using a JSON Schema:
+
+```typescript
+const result = await client.document.extract(
+  {
+    url: "https://example.com/research-paper.pdf",
+    prompt: "Extract the title, authors, and publication year",
+    schema: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        authors: { type: "array", items: { type: "string" } },
+        year: { type: "number" },
+      },
+      required: ["title", "authors", "year"],
+    },
+  },
+  { context: { documentId: "research-paper-1" } },
+);
+
+console.log(result.data); // { title: "...", authors: [...], year: 2024 }
+```
+
+## Invoice Processing
+
+Specialized methods for processing invoices. Parse supports `pro` and `max` models only. Ask and extract support all model tiers.
+
+### Parse Invoice
+
+```typescript
+const result = await client.invoice.parse(
+  { url: "https://example.com/invoice.pdf" },
+  { context: { documentId: "invoice-001" } },
+);
+
+console.log(result.markdown);
+```
+
+### Ask Questions About Invoices
+
+```typescript
+const result = await client.invoice.ask(
+  {
+    url: "https://example.com/invoice.pdf",
+    question: "What is the total amount and due date for this invoice?",
+  },
+  { context: { documentId: "invoice-001" } },
+);
+
+console.log(result.markdown);
+```
+
+### Extract Structured Invoice Data
+
+```typescript
+const result = await client.invoice.extract(
+  {
+    url: "https://example.com/invoice.pdf",
+    prompt: "Extract all invoice details including vendor, items, and totals",
+    schema: {
+      type: "object",
+      properties: {
+        invoiceNumber: { type: "string" },
+        date: { type: "string" },
+        totalAmount: { type: "number" },
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              description: { type: "string" },
+              quantity: { type: "number" },
+              price: { type: "number" },
+            },
+          },
+        },
+      },
+      required: ["invoiceNumber", "date", "totalAmount", "items"],
+    },
+  },
+  { context: { documentId: "invoice-001" } },
+);
+
+console.log(result.data);
+```
+
+## Identity Document Processing
+
+Specialized methods for processing ID documents (passports, driver's licenses, ID cards). Parse supports `pro` and `max` models only. Ask and extract support all model tiers.
+
+### Parse ID Document
+
+```typescript
+const result = await client.identity.parse(
+  { url: "https://example.com/passport.pdf" },
+  { context: { documentId: "passport-jane" } },
+);
+
+console.log(result.markdown);
+console.log(result.documentType); // e.g., "passport"
+```
+
+### Ask Questions About ID Documents
+
+```typescript
+const result = await client.identity.ask(
+  {
+    url: "https://example.com/passport.pdf",
+    question: "What is the full name and date of birth on this document?",
+  },
+  { context: { documentId: "passport-jane" } },
+);
+
+console.log(result.markdown);
+```
+
+### Extract Structured ID Document Data
+
+```typescript
+const result = await client.identity.extract(
+  {
+    url: "https://example.com/passport.pdf",
+    prompt: "Extract passport details from this document",
+    schema: {
+      type: "object",
+      properties: {
+        fullName: { type: "string" },
+        dateOfBirth: { type: "string" },
+        documentNumber: { type: "string" },
+        nationality: { type: "string" },
+        expirationDate: { type: "string" },
+      },
+      required: ["fullName", "documentNumber"],
+    },
+  },
+  { context: { documentId: "passport-jane" } },
+);
+
+console.log(result.data);
+```
+
+## Bank Statement Processing
+
+Specialized methods for processing bank statements. Parse supports `pro` and `max` models only. Ask and extract support all model tiers.
+
+```typescript
+const result = await client.bankStatement.parse(
+  { url: "https://example.com/statement.pdf" },
+  { context: { documentId: "statement-2024-03" } },
+);
+
+console.log(result.markdown);
+```
+
+Also supports `bankStatement.ask()` and `bankStatement.extract()` with the same patterns as above.
+
+## Academic Research
+
+### Search Academic Publications
+
+Search across multiple academic databases with a unified API. Costs 2 credits per request.
+
+```typescript
+const result = await client.academic.search({
+  query: "quantum computing",
+  providers: ["semantic-scholar", "arxiv", "pubmed"],
+  limit: 20,
+  yearFrom: 2021,
+  yearTo: 2024,
+});
+
+result.results.forEach((publication) => {
+  console.log(`Title: ${publication.title}`);
+  console.log(`Authors: ${publication.authors?.map((a) => a.name).join(", ")}`);
+  console.log(`Year: ${publication.year}`);
+  console.log("---");
+});
+```
+
+**Supported Providers:**
+
+- `"semantic-scholar"` (default) - [Semantic Scholar](https://www.semanticscholar.org/)
+- `"arxiv"` - [ArXiv](https://arxiv.org/)
+- `"pubmed"` - [PubMed](https://pubmed.ncbi.nlm.nih.gov/)
+- `"google-scholar"` - [Google Scholar](https://scholar.google.com/)
+- `"eric"` - [ERIC](https://eric.ed.gov/)
+- `"europe-pmc"` - [Europe PMC](https://europepmc.org/)
+- `"openalex"` - [OpenAlex](https://openalex.org/)
+
+**Search Parameters:**
+
+- `query` (required): 1-400 characters
+- `providers`: Array of provider names (default: `["semantic-scholar"]`)
+- `offset`: Pagination offset (default: 0)
+- `limit`: Results per provider, 1-100 (default: 20)
+- `yearFrom` / `yearTo`: Filter by publication year (1900-2100)
+- `fields`: Specific fields to return (`"doi"`, `"title"`, `"url"`, `"providerURL"`, `"authors"`, `"date"`, `"year"`, `"totalCitations"`, `"totalReferences"`, `"abstract"`, `"pdfURL"`, `"provider"`, `"providerData"`)
+
+### Fetch Academic Publications by ID
+
+Fetch specific papers by their identifiers with automatic provider detection. Costs 2 credits per request.
+
+```typescript
+const result = await client.academic.fetch({
+  ids: [
+    "10.1038/nature12373", // DOI
+    "12345678",            // PubMed ID
+    "2301.00001",          // ArXiv ID
+  ],
+  fields: ["title", "authors", "year", "abstract", "doi"],
+});
+
+result.results.forEach((pub) => {
+  console.log(`Title: ${pub.title}`);
+  console.log(`Provider: ${pub.detectedProvider}`);
+});
+
+result.errors?.forEach((error) => {
+  console.log(`Failed to fetch ${error.id}: ${error.error}`);
+});
+```
+
+**Supported ID types:** DOI, PubMed ID, ArXiv ID, Semantic Scholar ID, ERIC ID, Europe PMC ID, OpenAlex ID.
+
+### Find Citations for a Paragraph
+
+Find relevant academic citations for each sentence in a paragraph using semantic similarity. Costs 2 credits per sentence analyzed.
+
+```typescript
+const result = await client.academic.findCitations({
+  paragraph:
+    "Transformers have revolutionized natural language processing. Attention mechanisms allow models to focus on relevant parts of the input.",
+  providers: ["semantic-scholar", "arxiv", "pubmed"],
+});
+
+console.log(
+  `Found ${result.totalCitations} citations across ${result.sentenceCount} sentences`,
+);
+
+for (const item of result.results) {
+  console.log(`\nSentence: ${item.sentence}`);
+  for (const citation of item.citations) {
+    console.log(`  [Score: ${citation.score}/10] ${citation.title}`);
+  }
+}
+```
+
+## Document ID Tracking
+
+Pass a `documentId` per request to track API usage. The ID is sent as a header and returned in responses for document, identity, invoice, and bank statement endpoints. Academic endpoints do not use `documentId`.
+
+```typescript
+const result = await client.document.parse(
+  { url: "https://example.com/document.pdf" },
+  { context: { documentId: "invoice-456" } },
+);
+
+console.log(result.documentId); // "invoice-456"
+```
+
+Each request can have its own `documentId`:
+
+```typescript
+const [resultA, resultB] = await Promise.all([
+  client.document.parse(
+    { url: "https://example.com/doc-a.pdf" },
+    { context: { documentId: "doc-a" } },
+  ),
+  client.document.parse(
+    { url: "https://example.com/doc-b.pdf" },
+    { context: { documentId: "doc-b" } },
+  ),
+]);
+
+console.log(resultA.documentId); // "doc-a"
+console.log(resultB.documentId); // "doc-b"
+```
+
+## Model Tiers
+
+| Tier | Best for | Max pages | Max size | Supported formats |
+|------|----------|-----------|----------|-------------------|
+| `nano` | Simple text documents | 30 | 10MB | PDF, Word, Excel, CSV |
+| `mini` | Tables, structured content | 30 | 10MB | PDF, Word, Excel, CSV |
+| `pro` | Complex docs, images, handwriting | 30 | 40MB | PDF, Word, Excel, CSV, Image |
+| `max` | Large docs, full capabilities, HTML output | 1000 | 500MB | PDF, Word, Excel, CSV, Image |
+| `auto` | Automatic selection with fallback (default) | 1000 | 500MB | PDF, Word, Excel, CSV, Image |
+
+**Note:** Identity, invoice, and bank statement `parse` only support `pro`, `max`, and `auto` models. Their `ask` and `extract` support all model tiers.
+
+## Credit Costs
+
+| API | nano | mini | pro | max | Unit |
+|-----|------|------|-----|-----|------|
+| Document Parse | 1 | 2 | 4 | 8 | /page |
+| Document Ask | 2 | 4 | 8 | 16 | /page |
+| Document Extract | 2 | 4 | 8 | 16 | /page |
+| Identity Parse | — | — | 6 | 10 | /page |
+| Identity Ask | 6 | 10 | 14 | 18 | /page |
+| Identity Extract | 6 | 10 | 14 | 18 | /page |
+| Invoice Parse | — | — | 6 | 10 | /page |
+| Invoice Ask | 6 | 10 | 14 | 18 | /page |
+| Invoice Extract | 6 | 10 | 14 | 18 | /page |
+| Bank Statement Parse | — | — | 6 | 10 | /page |
+| Bank Statement Ask | 6 | 10 | 14 | 18 | /page |
+| Bank Statement Extract | 6 | 10 | 14 | 18 | /page |
+| Academic Search | 2 | 2 | 2 | 2 | /request |
+| Academic Fetch | 2 | 2 | 2 | 2 | /request |
+| Academic Find Citations | 2 | 2 | 2 | 2 | /sentence |
+
+## Error Handling
+
+All API errors are thrown as `PDFVectorError` instances with structured error information:
+
+```typescript
+import { createClient, PDFVectorError } from "@pdfvector/instance-client";
+
+const client = createClient({
+  apiKey: "your-api-key",
+});
+
+try {
+  const result = await client.document.parse({
+    url: "https://example.com/document.pdf",
+  });
+  console.log(result.markdown);
+} catch (error) {
+  if (error instanceof PDFVectorError) {
+    console.error(`API Error [${error.code}]: ${error.message}`);
+    console.error(`HTTP Status: ${error.status}`);
+    console.error(`Error Data:`, error.data);
+  } else {
+    console.error("Unexpected Error:", error);
+  }
+}
+```
+
+You can also use the static type guard:
+
+```typescript
+try {
+  await client.document.parse({ url: "..." });
+} catch (error) {
+  if (PDFVectorError.is(error)) {
+    switch (error.code) {
+      case "UNAUTHORIZED":
+        console.error("Invalid API key");
+        break;
+      case "BAD_REQUEST":
+        console.error("Validation error:", error.message);
+        break;
+      case "INTERNAL_SERVER_ERROR":
+        console.error("Server error:", error.message);
+        break;
+    }
+  }
+}
+```
+
+### Error Codes
+
+| Code | Status | Description |
+|------|--------|-------------|
+| `BAD_REQUEST` | 400 | Input validation failed (e.g., missing fields, invalid URL, question too short) |
+| `UNAUTHORIZED` | 401 | Missing or invalid API key |
+| `UNPROCESSABLE_CONTENT` | 422 | Document could not be processed by the requested model tier |
+| `TOO_MANY_REQUESTS` | 429 | Rate limit exceeded |
+| `INTERNAL_SERVER_ERROR` | 500 | Server-side failure |
+
+## TypeScript Support
+
+The SDK is written in TypeScript and includes full type definitions:
+
+```typescript
+import {
+  createClient,
+  PDFVectorError,
+} from "@pdfvector/instance-client";
+
+import type {
+  Client,
+  ClientContext,
+  CreateClientOptions,
+  ContractInputs,
+  ContractOutputs,
+  PDFVectorModel,
+} from "@pdfvector/instance-client";
+```
+
+## Runtime Support
+
+- **Node.js**: 20+
+- **Bun**: 1.0+
+- **ESM only** (CommonJS is not supported)
+- Uses standard `fetch` API
+
+## Support
+
+- **API Reference**: [global.pdfvector.com/api/reference](https://global.pdfvector.com/api/reference)
+- **Dashboard**: [app.pdfvector.com](https://app.pdfvector.com)
+- **Billing**: [app.pdfvector.com/workspace/billing](https://app.pdfvector.com/workspace/billing)
+
+## License
+
+MIT

package/package.json

@@ -1,12 +1,41 @@
 {
   "name": "@pdfvector/instance-client",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "type": "module",
+  "description": "Official TypeScript/JavaScript SDK for PDFVector API - Parse PDF/Word/Image/Excel documents to clean, structured markdown format and search academic publications across multiple databases",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phuctm97/pdfvector",
+    "directory": "packages/instance-client"
+  },
+  "homepage": "https://pdfvector.com",
+  "keywords": [
+    "pdfvector",
+    "pdf",
+    "word",
+    "markdown",
+    "api",
+    "sdk",
+    "academic",
+    "search",
+    "pubmed",
+    "semantic-scholar",
+    "google-scholar",
+    "arxiv",
+    "eric",
+    "research",
+    "papers",
+    "publications"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "main": ".tsc/lib/index.js",
   "dependencies": {
     "@orpc/client": "^1.13.13",
     "@orpc/contract": "^1.13.13",
-    "@pdfvector/instance-contract": "^0.0.20"
+    "@pdfvector/instance-contract": "^0.0.22"
   },
   "files": [
     ".tsc",