@pdfvector/instance-contract 0.2.7 → 0.2.9

package/.tsc/lib/router/academic/search-grants.js

@@ -1,171 +0,0 @@
-import { oc } from "@orpc/contract";
-import { getOpenApiCodeSamples } from "@pdfvector/api-docs";
-import { academicCreditCosts } from "@pdfvector/util";
-import { z } from "zod";
-import { grantProviderSchema } from "./provider.js";
-const grantSchema = z.object({
-    sourceId: z.string().nullish(),
-    title: z.string().nullish(),
-    url: z.string().nullish(),
-    agency: z.string().nullish(),
-    program: z.string().nullish(),
-    description: z.string().nullish(),
-    eligibility: z.string().nullish(),
-    fundingAmountMin: z.number().nullish(),
-    fundingAmountMax: z.number().nullish(),
-    currency: z.string().nullish(),
-    deadlineDate: z.string().nullish(),
-    openDate: z.string().nullish(),
-    closeDate: z.string().nullish(),
-    grantType: z.string().nullish(),
-    region: z.string().nullish(),
-    keywords: z.array(z.string()).nullish(),
-    piName: z.string().nullish(),
-    organizationName: z.string().nullish(),
-    provider: grantProviderSchema.nullish(),
-    providerData: z.record(z.string(), z.unknown()).nullish(),
-});
-const providerErrorSchema = z.object({
-    provider: grantProviderSchema,
-    message: z.string(),
-    code: z.string().nullish(),
-    details: z.record(z.string(), z.unknown()).nullish(),
-});
-const requestExamples = {
-    "Search all providers": {
-        summary: "Search grants across all funding databases",
-        value: {
-            query: "machine learning healthcare",
-        },
-    },
-    "Search with filters": {
-        summary: "Search with funding and deadline filters",
-        value: {
-            query: "climate change research",
-            providers: ["grants-gov", "cordis"],
-            fundingMin: 50000,
-            fundingMax: 500000,
-            deadlineFrom: "2026-01-01",
-            deadlineTo: "2026-12-31",
-            limit: 20,
-        },
-    },
-    "Search specific provider": {
-        summary: "Search NIH grants only",
-        value: {
-            query: "CRISPR gene therapy",
-            providers: ["nih-reporter"],
-            limit: 10,
-        },
-    },
-};
-export const searchGrants = oc
-    .input(z.object({
-    query: z
-        .string({ message: "query is required and must be a string" })
-        .min(1, "query must not be empty")
-        .max(400, "query must be at most 400 characters")
-        .describe("Search query string for grants"),
-    providers: z
-        .array(grantProviderSchema, {
-        message: "providers must be an array of valid grant provider names",
-    })
-        .default(["grants-gov", "nih-reporter", "cordis", "ukri"])
-        .describe("Grant databases to search. Defaults to all providers."),
-    offset: z
-        .number({ message: "offset must be a number" })
-        .int("offset must be a whole number")
-        .min(0, "offset must be 0 or greater")
-        .default(0)
-        .describe("Results offset for pagination"),
-    limit: z
-        .number({ message: "limit must be a number" })
-        .int("limit must be a whole number")
-        .min(1, "limit must be at least 1")
-        .max(50, "limit must be at most 50")
-        .default(10)
-        .describe("Maximum results per provider"),
-    deadlineFrom: z
-        .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, "deadlineFrom must be in ISO date format (YYYY-MM-DD)")
-        .nullish()
-        .describe("Filter grants with deadlines from this date (ISO format, e.g. 2026-01-01)"),
-    deadlineTo: z
-        .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, "deadlineTo must be in ISO date format (YYYY-MM-DD)")
-        .nullish()
-        .describe("Filter grants with deadlines up to this date (ISO format, e.g. 2026-12-31)"),
-    fundingMin: z
-        .number({ message: "fundingMin must be a number" })
-        .min(0, "fundingMin must be 0 or greater")
-        .nullish()
-        .describe("Minimum funding amount filter"),
-    fundingMax: z
-        .number({ message: "fundingMax must be a number" })
-        .min(0, "fundingMax must be 0 or greater")
-        .nullish()
-        .describe("Maximum funding amount filter"),
-    fields: z
-        .array(z.enum([
-        "sourceId",
-        "title",
-        "url",
-        "agency",
-        "program",
-        "description",
-        "eligibility",
-        "fundingAmountMin",
-        "fundingAmountMax",
-        "currency",
-        "deadlineDate",
-        "openDate",
-        "closeDate",
-        "grantType",
-        "region",
-        "keywords",
-        "piName",
-        "organizationName",
-        "provider",
-        "providerData",
-    ]), {
-        message: "fields must be an array of valid grant field names",
-    })
-        .nullish()
-        .describe("Specific grant fields to return. If omitted, returns all fields except providerData."),
-    callback: z
-        .object({
-        url: z
-            .url()
-            .describe("Webhook URL where results will be POSTed when processing completes"),
-        type: z
-            .string()
-            .optional()
-            .describe("Callback type identifier (e.g. 'zapier')"),
-    })
-        .optional()
-        .describe("Optional webhook callback for async processing. " +
-        "When provided, the server returns 202 immediately and POSTs the full response payload to the callback URL when processing completes. " +
-        "On error, the callback receives a POST with X-Pdfvector-Callback-Failed: true header and error details in the body."),
-}))
-    .output(z.object({
-    estimatedTotalResults: z.number(),
-    results: z.array(grantSchema),
-    errors: z.array(providerErrorSchema).nullish(),
-    requestId: z.number().int(),
-}))
-    .route({
-    summary: "Search grants",
-    description: `Search for research grants and funding opportunities across multiple databases (Grants.gov, NIH RePORTER, CORDIS, UKRI) with unified results, relevance ranking, and filtering by deadline and funding amount. Costs ${academicCreditCosts.grantSearch} credits per request.`,
-    tags: ["Academic"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        const reqBody = op.requestBody;
-        if (reqBody?.content) {
-            for (const mediaType of Object.values(reqBody.content)) {
-                mediaType["examples"] = requestExamples;
-            }
-        }
-        op["x-codeSamples"] = getOpenApiCodeSamples("academic-search-grants");
-        return op;
-    },
-});

package/.tsc/lib/router/academic/search.d.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-export declare const search: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
-    query: z.ZodString;
-    providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        arxiv: "arxiv";
-        crossref: "crossref";
-        eric: "eric";
-        "europe-pmc": "europe-pmc";
-        "google-scholar": "google-scholar";
-        openalex: "openalex";
-        pubmed: "pubmed";
-        "semantic-scholar": "semantic-scholar";
-    }>>>;
-    offset: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-    yearFrom: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    yearTo: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        abstract: "abstract";
-        authors: "authors";
-        date: "date";
-        doi: "doi";
-        pdfURL: "pdfURL";
-        provider: "provider";
-        providerData: "providerData";
-        providerURL: "providerURL";
-        title: "title";
-        totalCitations: "totalCitations";
-        totalReferences: "totalReferences";
-        url: "url";
-        year: "year";
-    }>>>>;
-    callback: z.ZodOptional<z.ZodObject<{
-        url: z.ZodURL;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    estimatedTotalResults: z.ZodNumber;
-    results: z.ZodArray<z.ZodObject<{
-        doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>>>;
-        date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>;
-    errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-        provider: z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>;
-        message: z.ZodString;
-        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>>>;
-    requestId: z.ZodNumber;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=search.d.ts.map

package/.tsc/lib/router/academic/search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/search.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0DxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAkHhB,CAAC"}

package/.tsc/lib/router/academic/search.js

@@ -1,154 +0,0 @@
-import { oc } from "@orpc/contract";
-import { getOpenApiCodeSamples } from "@pdfvector/api-docs";
-import { academicCreditCosts } from "@pdfvector/util";
-import { z } from "zod";
-import { providerSchema } from "./provider.js";
-const authorSchema = z.object({
-    name: z.string(),
-    url: z.string().nullish(),
-});
-const publicationSchema = z.object({
-    doi: z.string().nullish(),
-    title: z.string().nullish(),
-    url: z.string().nullish(),
-    providerURL: z.string().nullish(),
-    authors: z.array(authorSchema).nullish(),
-    date: z.string().nullish(),
-    year: z.number().nullish(),
-    totalCitations: z.number().nullish(),
-    totalReferences: z.number().nullish(),
-    abstract: z.string().nullish(),
-    pdfURL: z.string().nullish(),
-    provider: providerSchema.nullish(),
-    providerData: z.record(z.string(), z.unknown()).nullish(),
-});
-const providerErrorSchema = z.object({
-    provider: providerSchema,
-    message: z.string(),
-    code: z.string().nullish(),
-    details: z.record(z.string(), z.unknown()).nullish(),
-});
-const requestExamples = {
-    "Search with default provider": {
-        summary: "Search with Semantic Scholar",
-        value: {
-            query: "deep learning for natural language processing",
-        },
-    },
-    "Search multiple providers": {
-        summary: "Search across multiple databases",
-        value: {
-            query: "CRISPR gene editing",
-            providers: ["semantic-scholar", "pubmed", "openalex"],
-            limit: 10,
-        },
-    },
-    "Search with year filter": {
-        summary: "Search recent papers",
-        value: {
-            query: "large language models",
-            providers: ["semantic-scholar"],
-            yearFrom: 2023,
-            yearTo: 2026,
-            limit: 20,
-        },
-    },
-};
-export const search = oc
-    .input(z.object({
-    query: z
-        .string({ message: "query is required and must be a string" })
-        .min(1, "query must not be empty")
-        .max(400, "query must be at most 400 characters")
-        .describe("Search query string for academic papers"),
-    providers: z
-        .array(providerSchema, {
-        message: "providers must be an array of valid provider names",
-    })
-        .default(["semantic-scholar"])
-        .describe("Academic databases to search"),
-    offset: z
-        .number({ message: "offset must be a number" })
-        .int("offset must be a whole number")
-        .min(0, "offset must be 0 or greater")
-        .default(0)
-        .describe("Results offset"),
-    limit: z
-        .number({ message: "limit must be a number" })
-        .int("limit must be a whole number")
-        .min(1, "limit must be at least 1")
-        .max(100, "limit must be at most 100")
-        .default(20)
-        .describe("Results per provider"),
-    yearFrom: z
-        .number({ message: "yearFrom must be a number" })
-        .int("yearFrom must be a whole number")
-        .min(1900, "yearFrom must be 1900 or later")
-        .max(2100, "yearFrom must be 2100 or earlier")
-        .nullish()
-        .describe("Filter papers published from this year"),
-    yearTo: z
-        .number({ message: "yearTo must be a number" })
-        .int("yearTo must be a whole number")
-        .min(1900, "yearTo must be 1900 or later")
-        .max(2100, "yearTo must be 2100 or earlier")
-        .nullish()
-        .describe("Filter papers published up to this year"),
-    fields: z
-        .array(z.enum([
-        "doi",
-        "title",
-        "url",
-        "providerURL",
-        "authors",
-        "date",
-        "year",
-        "totalCitations",
-        "totalReferences",
-        "abstract",
-        "pdfURL",
-        "provider",
-        "providerData",
-    ]), {
-        message: "fields must be an array of valid publication field names",
-    })
-        .nullish()
-        .describe("Specific publication fields to return. If omitted, returns all fields except providerData."),
-    callback: z
-        .object({
-        url: z
-            .url()
-            .describe("Webhook URL where results will be POSTed when processing completes"),
-        type: z
-            .string()
-            .optional()
-            .describe("Callback type identifier (e.g. 'zapier')"),
-    })
-        .optional()
-        .describe("Optional webhook callback for async processing. " +
-        "When provided, the server returns 202 immediately and POSTs the full response payload to the callback URL when processing completes. " +
-        "On error, the callback receives a POST with X-Pdfvector-Callback-Failed: true header and error details in the body. " +
-        "Useful for long-running operations that may exceed client timeout limits."),
-}))
-    .output(z.object({
-    estimatedTotalResults: z.number(),
-    results: z.array(publicationSchema),
-    errors: z.array(providerErrorSchema).nullish(),
-    requestId: z.number().int(),
-}))
-    .route({
-    summary: "Search academic papers",
-    description: `Search for academic publications across multiple databases with relevance ranking. Costs ${academicCreditCosts.academicSearch} credits per request.`,
-    tags: ["Academic"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        const reqBody = op.requestBody;
-        if (reqBody?.content) {
-            for (const mediaType of Object.values(reqBody.content)) {
-                mediaType["examples"] = requestExamples;
-            }
-        }
-        op["x-codeSamples"] = getOpenApiCodeSamples("academic-search");
-        return op;
-    },
-});

package/.tsc/lib/router/academic/similar-papers.d.ts

@@ -1,89 +0,0 @@
-import { z } from "zod";
-export declare const similarPapers: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
-    id: z.ZodString;
-    limit: z.ZodDefault<z.ZodNumber>;
-    includeEdges: z.ZodDefault<z.ZodBoolean>;
-    fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        abstract: "abstract";
-        authors: "authors";
-        date: "date";
-        doi: "doi";
-        pdfURL: "pdfURL";
-        provider: "provider";
-        providerData: "providerData";
-        providerURL: "providerURL";
-        title: "title";
-        totalCitations: "totalCitations";
-        totalReferences: "totalReferences";
-        url: "url";
-        year: "year";
-    }>>>>;
-    callback: z.ZodOptional<z.ZodObject<{
-        url: z.ZodURL;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    seed: z.ZodObject<{
-        doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>>>;
-        date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>;
-    results: z.ZodArray<z.ZodObject<{
-        publication: z.ZodObject<{
-            doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strip>>>>;
-            date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                arxiv: "arxiv";
-                crossref: "crossref";
-                eric: "eric";
-                "europe-pmc": "europe-pmc";
-                "google-scholar": "google-scholar";
-                openalex: "openalex";
-                pubmed: "pubmed";
-                "semantic-scholar": "semantic-scholar";
-            }>>>;
-            providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        }, z.core.$strip>;
-        similarity: z.ZodNumber;
-        pageRank: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        distance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        citingIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-        citedByIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>>;
-    requestId: z.ZodNumber;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=similar-papers.d.ts.map

package/.tsc/lib/router/academic/similar-papers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"similar-papers.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/similar-papers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0ExB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA+FvB,CAAC"}

package/.tsc/lib/router/academic/similar-papers.js

@@ -1,143 +0,0 @@
-import { oc } from "@orpc/contract";
-import { getOpenApiCodeSamples } from "@pdfvector/api-docs";
-import { academicCreditCosts } from "@pdfvector/util";
-import { z } from "zod";
-import { providerSchema } from "./provider.js";
-const authorSchema = z.object({
-    name: z.string(),
-    url: z.string().nullish(),
-});
-const publicationSchema = z.object({
-    doi: z.string().nullish(),
-    title: z.string().nullish(),
-    url: z.string().nullish(),
-    providerURL: z.string().nullish(),
-    authors: z.array(authorSchema).nullish(),
-    date: z.string().nullish(),
-    year: z.number().nullish(),
-    totalCitations: z.number().nullish(),
-    totalReferences: z.number().nullish(),
-    abstract: z.string().nullish(),
-    pdfURL: z.string().nullish(),
-    provider: providerSchema.nullish(),
-    providerData: z.record(z.string(), z.unknown()).nullish(),
-});
-const similarPaperSchema = z.object({
-    publication: publicationSchema,
-    similarity: z
-        .number()
-        .describe("Combined similarity score from citation network analysis"),
-    pageRank: z.number().nullish().describe("Citation network importance score"),
-    distance: z
-        .number()
-        .int()
-        .nullish()
-        .describe("Graph distance from seed paper"),
-    citingIds: z
-        .array(z.string())
-        .nullish()
-        .describe("OpenAlex IDs of papers in result set that cite this paper (only if includeEdges=true)"),
-    citedByIds: z
-        .array(z.string())
-        .nullish()
-        .describe("OpenAlex IDs of papers in result set cited by this paper (only if includeEdges=true)"),
-});
-const requestExamples = {
-    "Find similar papers by DOI": {
-        summary: "Find papers similar to a given paper",
-        value: {
-            id: "10.1038/nature12373",
-            limit: 20,
-        },
-    },
-    "Find similar with edges": {
-        summary: "Find similar papers with citation graph edges",
-        value: {
-            id: "10.1038/nature12373",
-            limit: 20,
-            includeEdges: true,
-        },
-    },
-    "Find similar by OpenAlex ID": {
-        summary: "Find similar papers using an OpenAlex ID",
-        value: {
-            id: "W2963403868",
-            limit: 10,
-        },
-    },
-};
-export const similarPapers = oc
-    .input(z.object({
-    id: z
-        .string({ message: "id is required and must be a string" })
-        .min(1, "id must not be empty")
-        .max(500, "id must be at most 500 characters")
-        .describe("Seed paper identifier. Supports DOI, Semantic Scholar ID, ArXiv ID, PubMed ID, OpenAlex ID, or URL."),
-    limit: z
-        .number({ message: "limit must be a number" })
-        .int("limit must be a whole number")
-        .min(1, "limit must be at least 1")
-        .max(100, "limit must be at most 100")
-        .default(30)
-        .describe("Maximum number of similar papers to return"),
-    includeEdges: z
-        .boolean({ message: "includeEdges must be a boolean" })
-        .default(false)
-        .describe("Whether to include citing/cited_by edge data for graph construction"),
-    fields: z
-        .array(z.enum([
-        "doi",
-        "title",
-        "url",
-        "providerURL",
-        "authors",
-        "date",
-        "year",
-        "totalCitations",
-        "totalReferences",
-        "abstract",
-        "pdfURL",
-        "provider",
-        "providerData",
-    ]), {
-        message: "fields must be an array of valid publication field names",
-    })
-        .nullish()
-        .describe("Specific publication fields to return. If omitted, returns all fields except providerData."),
-    callback: z
-        .object({
-        url: z
-            .url()
-            .describe("Webhook URL where results will be POSTed when processing completes"),
-        type: z
-            .string()
-            .optional()
-            .describe("Callback type identifier (e.g. 'zapier')"),
-    })
-        .optional()
-        .describe("Optional webhook callback for async processing. " +
-        "When provided, the server returns 202 immediately and POSTs the full response payload to the callback URL when processing completes. " +
-        "On error, the callback receives a POST with X-Pdfvector-Callback-Failed: true header and error details in the body. " +
-        "Useful for long-running operations that may exceed client timeout limits."),
-}))
-    .output(z.object({
-    seed: publicationSchema,
-    results: z.array(similarPaperSchema),
-    requestId: z.number().int(),
-}))
-    .route({
-    summary: "Find similar papers",
-    description: `Find papers similar to a seed paper using citation network analysis. Returns papers ranked by similarity with optional graph edge data for visualization. Costs ${academicCreditCosts.academicSimilarPapers} credits per request.`,
-    tags: ["Academic"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        const reqBody = op.requestBody;
-        if (reqBody?.content) {
-            for (const mediaType of Object.values(reqBody.content)) {
-                mediaType["examples"] = requestExamples;
-            }
-        }
-        op["x-codeSamples"] = getOpenApiCodeSamples("academic-similar-papers");
-        return op;
-    },
-});

package/.tsc/lib/router/admin/get-environment.d.ts

@@ -1,5 +0,0 @@
-import { z } from "zod";
-export declare const getEnvironment: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
-    environment: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=get-environment.d.ts.map

package/.tsc/lib/router/admin/get-environment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-environment.d.ts","sourceRoot":"","sources":["../../../../lib/router/admin/get-environment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;8DAW0C,CAAC"}

package/.tsc/lib/router/admin/get-environment.js

@@ -1,13 +0,0 @@
-import { oc } from "@orpc/contract";
-import { z } from "zod";
-export const getEnvironment = oc
-    .route({
-    summary: "Get instance server's environment",
-    description: "Return all environment variables available to the instance server process",
-    tags: ["Admin"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        return op;
-    },
-})
-    .output(z.object({ environment: z.record(z.string(), z.string()) }));