@pdfvector/util 0.5.0 → 0.6.0

package/.tsc/lib/contract/gateway/router/admin/billing-holds.d.ts

@@ -10,18 +10,47 @@ export declare const listBillingHolds: import("@orpc/contract").ContractProcedur
     holds: z.ZodArray<z.ZodObject<{
         workspaceId: z.ZodNumber;
         workspaceName: z.ZodString;
+        ownerEmail: z.ZodNullable<z.ZodString>;
+        stripeDashboardUrl: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            exempt: "exempt";
+            resolved: "resolved";
+        }>;
         reason: z.ZodString;
         code: z.ZodString;
+        message: z.ZodString;
         invoiceCount: z.ZodNumber;
         amountDue: z.ZodNumber;
         currency: z.ZodString;
+        invoices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            number: z.ZodNullable<z.ZodString>;
+            status: z.ZodString;
+            amountRemaining: z.ZodNumber;
+            currency: z.ZodString;
+            created: z.ZodDate;
+            dueDate: z.ZodNullable<z.ZodDate>;
+            hostedInvoiceUrl: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        dispute: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodString;
+            amount: z.ZodNumber;
+            currency: z.ZodString;
+            reason: z.ZodString;
+            created: z.ZodDate;
+        }, z.core.$strip>>;
+        paymentMethodRequired: z.ZodBoolean;
         linkedWorkspaceId: z.ZodNullable<z.ZodNumber>;
+        linkedWorkspaceName: z.ZodNullable<z.ZodString>;
         matchedBy: z.ZodNullable<z.ZodString>;
         manual: z.ZodBoolean;
         since: z.ZodDate;
         resolvedAt: z.ZodNullable<z.ZodDate>;
         exemptUntil: z.ZodNullable<z.ZodDate>;
         emailsSent: z.ZodNumber;
+        lastEmailAt: z.ZodNullable<z.ZodDate>;
     }, z.core.$strip>>;
     registry: z.ZodArray<z.ZodObject<{
         kind: z.ZodString;

package/.tsc/lib/contract/gateway/router/admin/billing-holds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"billing-holds.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/billing-holds.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyB3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;8DAQY,CAAC"}
+{"version":3,"file":"billing-holds.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/billing-holds.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAsD3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;8DAQY,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/billing-holds.js

@@ -7,18 +7,45 @@ export const listBillingHolds = oc
     holds: z.array(z.object({
         workspaceId: z.number(),
         workspaceName: z.string(),
+        ownerEmail: z.string().nullable(),
+        stripeDashboardUrl: z.string().nullable(),
+        status: z.enum(["active", "exempt", "resolved"]),
         reason: z.string(),
         code: z.string(),
+        message: z.string(),
         invoiceCount: z.number(),
         amountDue: z.number(),
         currency: z.string(),
+        invoices: z.array(z.object({
+            id: z.string(),
+            number: z.string().nullable(),
+            status: z.string(),
+            amountRemaining: z.number(),
+            currency: z.string(),
+            created: z.date(),
+            dueDate: z.date().nullable(),
+            hostedInvoiceUrl: z.string().nullable(),
+        })),
+        dispute: z
+            .object({
+            id: z.string(),
+            status: z.string(),
+            amount: z.number(),
+            currency: z.string(),
+            reason: z.string(),
+            created: z.date(),
+        })
+            .nullable(),
+        paymentMethodRequired: z.boolean(),
         linkedWorkspaceId: z.number().nullable(),
+        linkedWorkspaceName: z.string().nullable(),
         matchedBy: z.string().nullable(),
         manual: z.boolean(),
         since: z.date(),
         resolvedAt: z.date().nullable(),
         exemptUntil: z.date().nullable(),
         emailsSent: z.number(),
+        lastEmailAt: z.date().nullable(),
     })),
     registry: z.array(z.object({ kind: z.string(), count: z.number() })),
 }));

package/.tsc/lib/contract/gateway/router/admin/billing.d.ts

@@ -4,19 +4,39 @@ export declare const listBilling: import("@orpc/contract").ContractProcedureBuil
 }, z.core.$strip>, z.ZodObject<{
     users: z.ZodArray<z.ZodObject<{
         stripeCustomerId: z.ZodString;
+        stripeDashboardUrl: z.ZodString;
+        workspaceId: z.ZodNumber;
+        userId: z.ZodNullable<z.ZodString>;
+        organizationId: z.ZodNullable<z.ZodString>;
         userName: z.ZodString;
         userEmail: z.ZodString;
         planKey: z.ZodString;
+        annual: z.ZodNullable<z.ZodBoolean>;
         usedCredits: z.ZodNumber;
         aggregatedCredits: z.ZodNumber;
         subscriptionStatus: z.ZodNullable<z.ZodString>;
         subscriptionId: z.ZodNullable<z.ZodString>;
         currentPeriodStart: z.ZodNullable<z.ZodDate>;
         currentPeriodEnd: z.ZodNullable<z.ZodDate>;
+        nextRenewalAt: z.ZodNullable<z.ZodDate>;
         cancelAtPeriodEnd: z.ZodBoolean;
+        currency: z.ZodString;
+        mrr: z.ZodNumber;
+        addOnCount: z.ZodNumber;
+        paymentMethod: z.ZodNullable<z.ZodObject<{
+            brand: z.ZodString;
+            last4: z.ZodString;
+            expMonth: z.ZodNumber;
+            expYear: z.ZodNumber;
+            expired: z.ZodBoolean;
+        }, z.core.$strip>>;
         openInvoiceCount: z.ZodNumber;
         uncollectibleInvoiceCount: z.ZodNumber;
         totalAmountDue: z.ZodNumber;
+        amountOwed: z.ZodArray<z.ZodObject<{
+            currency: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
         hasIssues: z.ZodBoolean;
         reasons: z.ZodArray<z.ZodString>;
         oldestIssueDate: z.ZodNullable<z.ZodDate>;
@@ -46,5 +66,6 @@ export declare const listBilling: import("@orpc/contract").ContractProcedureBuil
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     cachedAt: z.ZodNullable<z.ZodDate>;
+    truncated: z.ZodBoolean;
 }, z.core.$strip>, Record<never, never>, Record<never, never>>;
 //# sourceMappingURL=billing.d.ts.map

package/.tsc/lib/contract/gateway/router/admin/billing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/billing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA0BzB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA6BtB,CAAC"}
+{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/billing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA0BzB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAmDtB,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/billing.js

@@ -28,19 +28,38 @@ export const listBilling = oc
     .output(z.object({
     users: z.array(z.object({
         stripeCustomerId: z.string(),
+        stripeDashboardUrl: z.string(),
+        workspaceId: z.number(),
+        userId: z.string().nullable(),
+        organizationId: z.string().nullable(),
         userName: z.string(),
         userEmail: z.string(),
         planKey: z.string(),
+        annual: z.boolean().nullable(),
         usedCredits: z.number(),
         aggregatedCredits: z.number(),
         subscriptionStatus: z.string().nullable(),
         subscriptionId: z.string().nullable(),
         currentPeriodStart: z.date().nullable(),
         currentPeriodEnd: z.date().nullable(),
+        nextRenewalAt: z.date().nullable(),
         cancelAtPeriodEnd: z.boolean(),
+        currency: z.string(),
+        mrr: z.number(),
+        addOnCount: z.number(),
+        paymentMethod: z
+            .object({
+            brand: z.string(),
+            last4: z.string(),
+            expMonth: z.number(),
+            expYear: z.number(),
+            expired: z.boolean(),
+        })
+            .nullable(),
         openInvoiceCount: z.number(),
         uncollectibleInvoiceCount: z.number(),
         totalAmountDue: z.number(),
+        amountOwed: z.array(z.object({ currency: z.string(), amount: z.number() })),
         hasIssues: z.boolean(),
         reasons: z.array(z.string()),
         oldestIssueDate: z.date().nullable(),
@@ -48,4 +67,5 @@ export const listBilling = oc
         invoices: z.array(invoiceSchema),
     })),
     cachedAt: z.date().nullable(),
+    truncated: z.boolean(),
 }));

package/.tsc/lib/contract/gateway/router/admin/usage/free.d.ts

@@ -2,7 +2,21 @@ import * as z from "zod";
 export declare const syncFreeUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     success: z.ZodBoolean;
 }, z.core.$strip>, Record<never, never>, Record<never, never>>;
-export declare const getFreeUsageOverview: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+export declare const getFreeUsageOverview: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    period: z.ZodDefault<z.ZodEnum<{
+        "30d": "30d";
+        "7d": "7d";
+        "90d": "90d";
+        all: "all";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    period: z.ZodEnum<{
+        "30d": "30d";
+        "7d": "7d";
+        "90d": "90d";
+        all: "all";
+    }>;
+    from: z.ZodNullable<z.ZodDate>;
     totalRequests: z.ZodNumber;
     successCount: z.ZodNumber;
     userErrorCount: z.ZodNumber;
@@ -12,6 +26,10 @@ export declare const getFreeUsageOverview: import("@orpc/contract").ContractProc
     uniqueIps: z.ZodNumber;
     avgPages: z.ZodNullable<z.ZodNumber>;
     totalFileSize: z.ZodNumber;
+    previous: z.ZodNullable<z.ZodObject<{
+        totalRequests: z.ZodNumber;
+        uniqueIps: z.ZodNumber;
+    }, z.core.$strip>>;
     daily: z.ZodArray<z.ZodObject<{
         date: z.ZodString;
         counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
@@ -20,10 +38,14 @@ export declare const getFreeUsageOverview: import("@orpc/contract").ContractProc
     byOperation: z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         count: z.ZodNumber;
+        dailyLimit: z.ZodNullable<z.ZodNumber>;
+        cappedIpDays: z.ZodNumber;
     }, z.core.$strip>>;
     byIp: z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         count: z.ZodNumber;
+        lastSeenAt: z.ZodDate;
+        cappedDays: z.ZodNumber;
     }, z.core.$strip>>;
     byModel: z.ZodArray<z.ZodObject<{
         label: z.ZodString;
@@ -33,13 +55,31 @@ export declare const getFreeUsageOverview: import("@orpc/contract").ContractProc
         label: z.ZodString;
         count: z.ZodNumber;
     }, z.core.$strip>>;
+    bySource: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    cappedIpDays: z.ZodNumber;
+    cappedRecent: z.ZodArray<z.ZodObject<{
+        ip: z.ZodString;
+        operation: z.ZodString;
+        date: z.ZodString;
+        count: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>>;
     topSystemErrors: z.ZodArray<z.ZodObject<{
         message: z.ZodString;
+        code: z.ZodNullable<z.ZodString>;
         count: z.ZodNumber;
+        operations: z.ZodArray<z.ZodString>;
+        lastSeenAt: z.ZodDate;
     }, z.core.$strip>>;
     topUserErrors: z.ZodArray<z.ZodObject<{
         message: z.ZodString;
+        code: z.ZodNullable<z.ZodString>;
         count: z.ZodNumber;
+        operations: z.ZodArray<z.ZodString>;
+        lastSeenAt: z.ZodDate;
     }, z.core.$strip>>;
 }, z.core.$strip>, Record<never, never>, Record<never, never>>;
 export declare const listFreeUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -61,6 +101,19 @@ export declare const listFreeUsage: import("@orpc/contract").ContractProcedureBu
         asc: "asc";
         desc: "desc";
     }>>;
+    operation: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        internal: "internal";
+        make: "make";
+        mcp: "mcp";
+        n8n: "n8n";
+        playground: "playground";
+        sdk: "sdk";
+        unknown: "unknown";
+        zapier: "zapier";
+    }>>;
+    ip: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodNumber;
@@ -91,6 +144,11 @@ export declare const listFreeUsage: import("@orpc/contract").ContractProcedureBu
             system_error: "system_error";
             user_error: "user_error";
         }>;
+        recordedStatus: z.ZodEnum<{
+            success: "success";
+            system_error: "system_error";
+            user_error: "user_error";
+        }>;
         errorStage: z.ZodNullable<z.ZodEnum<{
             auth: "auth";
             preprocessing: "preprocessing";

package/.tsc/lib/contract/gateway/router/admin/usage/free.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"free.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/free.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,aAAa;;8DAEkB,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAuDhC,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA6CxB,CAAC"}
+{"version":3,"file":"free.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/free.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,aAAa;;8DAEkB,CAAC;AAW7C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAoD/B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAiDxB,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/free.js

@@ -4,7 +4,19 @@ import * as z from "zod";
 export const syncFreeUsage = oc
     .input(z.object({}))
     .output(z.object({ success: z.boolean() }));
-export const getFreeUsageOverview = oc.input(z.object({})).output(z.object({
+const labelCount = z.object({ label: z.string(), count: z.number() });
+const topError = z.object({
+    message: z.string(),
+    code: z.string().nullable(),
+    count: z.number(),
+    operations: z.array(z.string()),
+    lastSeenAt: z.date(),
+});
+export const getFreeUsageOverview = oc
+    .input(z.object({ period: z.enum(["7d", "30d", "90d", "all"]).default("30d") }))
+    .output(z.object({
+    period: z.enum(["7d", "30d", "90d", "all"]),
+    from: z.date().nullable(),
     totalRequests: z.number(),
     successCount: z.number(),
     userErrorCount: z.number(),
@@ -14,35 +26,32 @@ export const getFreeUsageOverview = oc.input(z.object({})).output(z.object({
     uniqueIps: z.number(),
     avgPages: z.number().nullable(),
     totalFileSize: z.number(),
+    previous: z
+        .object({ totalRequests: z.number(), uniqueIps: z.number() })
+        .nullable(),
     daily: z.array(z.object({
         date: z.string(),
         counts: z.record(z.string(), z.number()),
     })),
     dailyOperations: z.array(z.string()),
-    byOperation: z.array(z.object({
-        label: z.string(),
-        count: z.number(),
-    })),
-    byIp: z.array(z.object({
-        label: z.string(),
-        count: z.number(),
+    byOperation: z.array(labelCount.extend({
+        dailyLimit: z.number().nullable(),
+        cappedIpDays: z.number(),
     })),
-    byModel: z.array(z.object({
-        label: z.string(),
-        count: z.number(),
-    })),
-    byDocumentType: z.array(z.object({
-        label: z.string(),
-        count: z.number(),
-    })),
-    topSystemErrors: z.array(z.object({
-        message: z.string(),
-        count: z.number(),
-    })),
-    topUserErrors: z.array(z.object({
-        message: z.string(),
+    byIp: z.array(labelCount.extend({ lastSeenAt: z.date(), cappedDays: z.number() })),
+    byModel: z.array(labelCount),
+    byDocumentType: z.array(labelCount),
+    bySource: z.array(labelCount),
+    cappedIpDays: z.number(),
+    cappedRecent: z.array(z.object({
+        ip: z.string(),
+        operation: z.string(),
+        date: z.string(),
         count: z.number(),
+        limit: z.number(),
     })),
+    topSystemErrors: z.array(topError),
+    topUserErrors: z.array(topError),
 }));
 export const listFreeUsage = oc
     .input(z.object({
@@ -55,6 +64,9 @@ export const listFreeUsage = oc
         .enum(["createdAt", "operation", "ip", "duration"])
         .default("createdAt"),
     sortOrder: z.enum(["asc", "desc"]).default("desc"),
+    operation: z.string().max(64).optional(),
+    source: z.enum(apiSources).optional(),
+    ip: z.string().max(64).optional(),
 }))
     .output(z.object({
     items: z.array(z.object({
@@ -72,6 +84,7 @@ export const listFreeUsage = oc
         pageCount: z.number().nullable(),
         error: z.string().nullable(),
         status: z.enum(["success", "user_error", "system_error"]),
+        recordedStatus: z.enum(["success", "user_error", "system_error"]),
         errorStage: z
             .enum(["auth", "validation", "preprocessing", "processing"])
             .nullable(),

package/.tsc/lib/contract/gateway/router/admin/usage/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./free.js";
 export * from "./overview.js";
 export * from "./provider-costs.js";
+export * from "./provider-health.js";
 export * from "./records.js";
 //# sourceMappingURL=index.d.ts.map

package/.tsc/lib/contract/gateway/router/admin/usage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/index.js

@@ -1,4 +1,5 @@
 export * from "./free.js";
 export * from "./overview.js";
 export * from "./provider-costs.js";
+export * from "./provider-health.js";
 export * from "./records.js";

package/.tsc/lib/contract/gateway/router/admin/usage/overview.d.ts

@@ -90,11 +90,35 @@ export declare const getUsageOverview: import("@orpc/contract").ContractProcedur
     }, z.core.$strip>>;
     topSystemErrors: z.ZodArray<z.ZodObject<{
         message: z.ZodString;
+        code: z.ZodNullable<z.ZodString>;
         count: z.ZodNumber;
+        share: z.ZodNumber;
+        operations: z.ZodArray<z.ZodObject<{
+            operation: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        workspaces: z.ZodNumber;
+        topModel: z.ZodNullable<z.ZodString>;
+        topSource: z.ZodNullable<z.ZodString>;
+        firstSeen: z.ZodDate;
+        lastSeen: z.ZodDate;
+        daily: z.ZodArray<z.ZodNumber>;
     }, z.core.$strip>>;
     topUserErrors: z.ZodArray<z.ZodObject<{
         message: z.ZodString;
+        code: z.ZodNullable<z.ZodString>;
         count: z.ZodNumber;
+        share: z.ZodNumber;
+        operations: z.ZodArray<z.ZodObject<{
+            operation: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        workspaces: z.ZodNumber;
+        topModel: z.ZodNullable<z.ZodString>;
+        topSource: z.ZodNullable<z.ZodString>;
+        firstSeen: z.ZodDate;
+        lastSeen: z.ZodDate;
+        daily: z.ZodArray<z.ZodNumber>;
     }, z.core.$strip>>;
     topUsers: z.ZodArray<z.ZodObject<{
         workspaceId: z.ZodNumber;

package/.tsc/lib/contract/gateway/router/admin/usage/overview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/overview.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAOzB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyE3B,CAAC"}
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/overview.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAqBzB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA+D3B,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/overview.js

@@ -5,6 +5,19 @@ const breakdownItemSchema = z.object({
     label: z.string(),
     count: z.number(),
 });
+const topErrorSchema = z.object({
+    message: z.string(),
+    code: z.string().nullable(),
+    count: z.number(),
+    share: z.number(),
+    operations: z.array(z.object({ operation: z.string(), count: z.number() })),
+    workspaces: z.number(),
+    topModel: z.string().nullable(),
+    topSource: z.string().nullable(),
+    firstSeen: z.date(),
+    lastSeen: z.date(),
+    daily: z.array(z.number()),
+});
 export const getUsageOverview = oc
     .input(z.object({
     period: z.enum(["7d", "30d", "90d", "all"]).default("30d"),
@@ -47,14 +60,8 @@ export const getUsageOverview = oc
     topModels: z.array(breakdownItemSchema),
     topRequestedModels: z.array(breakdownItemSchema),
     topSources: z.array(breakdownItemSchema),
-    topSystemErrors: z.array(z.object({
-        message: z.string(),
-        count: z.number(),
-    })),
-    topUserErrors: z.array(z.object({
-        message: z.string(),
-        count: z.number(),
-    })),
+    topSystemErrors: z.array(topErrorSchema),
+    topUserErrors: z.array(topErrorSchema),
     topUsers: z.array(z.object({
         workspaceId: z.number(),
         label: z.string(),

package/.tsc/lib/contract/gateway/router/admin/usage/provider-health.d.ts

@@ -0,0 +1,44 @@
+import * as z from "zod";
+/** Failure and hidden-fallback rates per provider/service for the admin console. */
+export declare const getProviderHealth: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    instanceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>>>, z.ZodObject<{
+    generatedAt: z.ZodString;
+    thresholds: z.ZodObject<{
+        downMinCalls1h: z.ZodNumber;
+        degradedMinCalls24h: z.ZodNumber;
+        degradedFailureRate24h: z.ZodNumber;
+    }, z.core.$strip>;
+    rows: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        service: z.ZodString;
+        status: z.ZodEnum<{
+            degraded: "degraded";
+            down: "down";
+            ok: "ok";
+        }>;
+        windows: z.ZodObject<{
+            "1h": z.ZodObject<{
+                calls: z.ZodNumber;
+                systemErrors: z.ZodNumber;
+                userErrors: z.ZodNumber;
+                fallbacks: z.ZodNumber;
+            }, z.core.$strip>;
+            "24h": z.ZodObject<{
+                calls: z.ZodNumber;
+                systemErrors: z.ZodNumber;
+                userErrors: z.ZodNumber;
+                fallbacks: z.ZodNumber;
+            }, z.core.$strip>;
+            "7d": z.ZodObject<{
+                calls: z.ZodNumber;
+                systemErrors: z.ZodNumber;
+                userErrors: z.ZodNumber;
+                fallbacks: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        lastError: z.ZodNullable<z.ZodString>;
+        lastErrorAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=provider-health.d.ts.map

package/.tsc/lib/contract/gateway/router/admin/usage/provider-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-health.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/provider-health.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAWzB,oFAAoF;AACpF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA8B5B,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/provider-health.js

@@ -0,0 +1,35 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const windowSchema = z.object({
+    calls: z.number(),
+    systemErrors: z.number(),
+    userErrors: z.number(),
+    fallbacks: z.number(),
+});
+const providerHealthStatuses = ["down", "degraded", "ok"];
+/** Failure and hidden-fallback rates per provider/service for the admin console. */
+export const getProviderHealth = oc
+    .input(z
+    .object({ instanceId: z.number().nullable().optional() })
+    .optional()
+    .default({}))
+    .output(z.object({
+    generatedAt: z.string(),
+    thresholds: z.object({
+        downMinCalls1h: z.number(),
+        degradedMinCalls24h: z.number(),
+        degradedFailureRate24h: z.number(),
+    }),
+    rows: z.array(z.object({
+        provider: z.string(),
+        service: z.string(),
+        status: z.enum(providerHealthStatuses),
+        windows: z.object({
+            "1h": windowSchema,
+            "24h": windowSchema,
+            "7d": windowSchema,
+        }),
+        lastError: z.string().nullable(),
+        lastErrorAt: z.string().nullable(),
+    })),
+}));

package/.tsc/lib/contract/gateway/router/admin/usage/records.d.ts

@@ -10,6 +10,8 @@ export declare const listUsage: import("@orpc/contract").ContractProcedureBuilde
         user_error: "user_error";
     }>>;
     instanceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodString>;
+    errorCode: z.ZodOptional<z.ZodString>;
     sortBy: z.ZodDefault<z.ZodEnum<{
         createdAt: "createdAt";
         credits: "credits";

package/.tsc/lib/contract/gateway/router/admin/usage/records.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/records.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyDpB,CAAC"}
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/records.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA2DpB,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/records.js

@@ -10,6 +10,8 @@ export const listUsage = oc
         .enum(["all", "success", "user_error", "system_error"])
         .default("all"),
     instanceId: z.number().nullable().optional(),
+    error: z.string().max(5000).optional(),
+    errorCode: z.string().max(200).optional(),
     sortBy: z
         .enum([
         "createdAt",

package/.tsc/lib/contract/gateway/router/instance/instances.d.ts

@@ -16,6 +16,8 @@ export declare const list: import("@orpc/contract").ContractProcedureBuilderWith
     kind: z.ZodDefault<z.ZodString>;
     managedStatus: z.ZodDefault<z.ZodString>;
     lastError: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageOutdated: z.ZodDefault<z.ZodBoolean>;
     id: z.ZodNumber;
     name: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
@@ -43,6 +45,8 @@ export declare const get: import("@orpc/contract").ContractProcedureBuilderWithI
     kind: z.ZodDefault<z.ZodString>;
     managedStatus: z.ZodDefault<z.ZodString>;
     lastError: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageOutdated: z.ZodDefault<z.ZodBoolean>;
     id: z.ZodNumber;
     name: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
@@ -96,6 +100,8 @@ export declare const create: import("@orpc/contract").ContractProcedureBuilderWi
     kind: z.ZodDefault<z.ZodString>;
     managedStatus: z.ZodDefault<z.ZodString>;
     lastError: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageOutdated: z.ZodDefault<z.ZodBoolean>;
     id: z.ZodNumber;
     name: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
@@ -123,6 +129,8 @@ export declare const retry: import("@orpc/contract").ContractProcedureBuilderWit
     kind: z.ZodDefault<z.ZodString>;
     managedStatus: z.ZodDefault<z.ZodString>;
     lastError: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    imageOutdated: z.ZodDefault<z.ZodBoolean>;
     id: z.ZodNumber;
     name: z.ZodString;
     description: z.ZodNullable<z.ZodString>;

package/.tsc/lib/contract/gateway/router/instance/instances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/instances.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA+BzB,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;+DAAqC,CAAC;AAEvD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAEsD,CAAC;AAEvE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAUK,CAAC;AAEzB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;8DAEM,CAAC;AAEzB,eAAO,MAAM,MAAM;;;;8DAEyB,CAAC;AAE7C,eAAO,MAAM,UAAU;;;;;;;;;+DAarB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;+DAW1B,CAAC"}
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/instances.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAiCzB,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;+DAAqC,CAAC;AAEvD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAEsD,CAAC;AAEvE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAUK,CAAC;AAEzB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAEM,CAAC;AAEzB,eAAO,MAAM,MAAM;;;;8DAEyB,CAAC;AAE7C,eAAO,MAAM,UAAU;;;;;;;;;+DAarB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;+DAW1B,CAAC"}

package/.tsc/lib/contract/gateway/router/instance/instances.js

@@ -18,6 +18,8 @@ const instanceSchema = z.object({
     kind: z.string().default("full"),
     managedStatus: z.string().default("ready"),
     lastError: z.string().nullable().default(null),
+    imageVersion: z.string().nullable().default(null),
+    imageOutdated: z.boolean().default(false),
     id: z.number(),
     name: z.string(),
     description: z.string().nullable(),

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

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

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

@@ -133,7 +133,12 @@ export const search = oc
     .output(z.object({
     estimatedTotalResults: z.number(),
     results: z.array(publicationSchema),
-    errors: z.array(providerErrorSchema).nullish(),
+    errors: z
+        .array(providerErrorSchema)
+        .nullish()
+        .describe("Providers that failed for this request (for example rate limited or unavailable). " +
+        "When present, `results` only contain papers from the providers that succeeded, so treat the response as partial. " +
+        "Credits are the same either way."),
     requestId: z.number().int(),
 }))
     .route({

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @pdfvector/util
 
+## 0.6.0
+
+### Minor Changes
+
+- [#521](https://github.com/phuctm97/pdfvector/pull/521) [`43f714f`](https://github.com/phuctm97/pdfvector/commit/43f714f0a28af7f3d213bfd1042dd2013cb39459) Thanks [@khanhduyvt0101](https://github.com/khanhduyvt0101)! - Add admin provider health: failure and hidden-fallback rates per provider/service over 1 h, 24 h and 7 d, a Provider health card on the admin usage page and a "Needs attention" item on the admin overview.
+
+### Patch Changes
+
+- [#521](https://github.com/phuctm97/pdfvector/pull/521) [`43f714f`](https://github.com/phuctm97/pdfvector/commit/43f714f0a28af7f3d213bfd1042dd2013cb39459) Thanks [@khanhduyvt0101](https://github.com/khanhduyvt0101)! - Stop hiding provider failures behind fallbacks:
+  
+  - Semantic Scholar: pace requests per process, retry 429s after `Retry-After` with bounded backoff instead of retrying through the proxy (S2 limits per API key), and record 429/5xx as system errors with the endpoint and response message.
+  - Webshare proxy usage now reflects proxy health only; the target's HTTP status is kept in `rawUsage.targetStatus`.
+  - Google Document AI: send `imagelessMode` so PDFs of up to 30 pages parse in one call (was 15), and let the max-tier fallback parse larger PDFs in 15-page chunks (up to 200 pages). PDFs over 30 pages skip the failing Document AI call in auto mode.
+  - Nano: a PDF without a usable text layer (scanned or image-only) now fails with a clear user-side error that says Nano only reads embedded text, instead of a generic system error.
+  - Azure image pre-check failures now record the Azure error code and message.
+  - API reference: document the academic search `errors` field (partial results when a provider fails).
+
+## 0.5.1
+
+### Patch Changes
+
+- [#516](https://github.com/phuctm97/pdfvector/pull/516) [`1b5e378`](https://github.com/phuctm97/pdfvector/commit/1b5e3786741f1d34b663be68211cb2c887e239b4) Thanks [@khanhduyvt0101](https://github.com/khanhduyvt0101)! - Redesign the Overview, Instances and instance Overview pages as a dashboard: KPI cards with trends against the previous period, a usage-over-time chart (requests by outcome, credits or pages) with a 7/30/90-day and all-time range, a breakdown by operation, source and model, recent requests, plan credits with low and out-of-credit states, and an instances table with search, status and type filters, sorting, column visibility, pagination, row actions, a mobile list, region, version and update badges. The Overview page opens on Usage; the API tab keeps the endpoint, API key, code examples and automations. Admin pages move into their own area with a dedicated sidebar, a new admin overview and a rebuilt billing holds page; the app sidebar shows a single Admin link. `instance.list` and `instance.get` now return the managed image `imageVersion` and whether a newer image is pending (`imageOutdated`).
+
 ## 0.5.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfvector/util",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "./.tsc/lib/index.js",
   "exports": {