@tokenite/shared 1.0.1

package/dist/schemas/proxy-response.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export declare const proxyUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type ProxyUsage = z.infer<typeof proxyUsageSchema>;
+export declare const proxySuccessSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    model: z.ZodString;
+    usage: z.ZodNullable<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+export type ProxySuccess = z.infer<typeof proxySuccessSchema>;
+export declare const proxyResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    model: z.ZodString;
+    usage: z.ZodNullable<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    data: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        source: z.ZodEnum<{
+            proxy: "proxy";
+            provider: "provider";
+        }>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type ProxyResponse = z.infer<typeof proxyResponseSchema>;
+//# sourceMappingURL=proxy-response.d.ts.map

package/dist/schemas/proxy-response.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { providerSchema } from './provider.js';
+import { errorResponseSchema } from './error.js';
+export const proxyUsageSchema = z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+});
+export const proxySuccessSchema = z.object({
+    provider: providerSchema,
+    model: z.string(),
+    usage: proxyUsageSchema.nullable(),
+    data: z.unknown(),
+});
+export const proxyResponseSchema = z.union([proxySuccessSchema, errorResponseSchema]);
+//# sourceMappingURL=proxy-response.js.map

package/dist/schemas/sponsored-api-key.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const sponsoredApiKeySchema: z.ZodObject<{
+    id: z.ZodString;
+    appId: z.ZodString;
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    encryptedKey: z.ZodString;
+    keyHint: z.ZodString;
+    totalBudgetUsd: z.ZodNumber;
+    totalSpentUsd: z.ZodDefault<z.ZodNumber>;
+    perUserBudgetUsd: z.ZodNullable<z.ZodNumber>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type SponsoredApiKey = z.infer<typeof sponsoredApiKeySchema>;
+export declare const addSponsoredApiKeyRequest: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>;
+    apiKey: z.ZodString;
+    totalBudgetUsd: z.ZodNumber;
+    perUserBudgetUsd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AddSponsoredApiKeyRequest = z.infer<typeof addSponsoredApiKeyRequest>;
+export declare const sponsoredKeyConsumerSchema: z.ZodObject<{
+    userId: z.ZodString;
+    email: z.ZodString;
+    spentUsd: z.ZodNumber;
+    requestCount: z.ZodNumber;
+}, z.core.$strip>;
+export type SponsoredKeyConsumer = z.infer<typeof sponsoredKeyConsumerSchema>;
+export declare const sponsoredApiKeyResponse: z.ZodObject<{
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    keyHint: z.ZodString;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    appId: z.ZodString;
+    totalBudgetUsd: z.ZodNumber;
+    totalSpentUsd: z.ZodDefault<z.ZodNumber>;
+    perUserBudgetUsd: z.ZodNullable<z.ZodNumber>;
+    consumers: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        email: z.ZodString;
+        spentUsd: z.ZodNumber;
+        requestCount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SponsoredApiKeyResponse = z.infer<typeof sponsoredApiKeyResponse>;
+//# sourceMappingURL=sponsored-api-key.d.ts.map

package/dist/schemas/sponsored-api-key.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { providerSchema } from './provider.js';
+export const sponsoredApiKeySchema = z.object({
+    id: z.string().uuid(),
+    appId: z.string().uuid(),
+    provider: providerSchema,
+    encryptedKey: z.string(),
+    keyHint: z.string().max(8),
+    totalBudgetUsd: z.number(),
+    totalSpentUsd: z.number().default(0),
+    perUserBudgetUsd: z.number().nullable(),
+    isActive: z.boolean().default(true),
+    createdAt: z.string().datetime(),
+});
+export const addSponsoredApiKeyRequest = z.object({
+    provider: providerSchema.optional(),
+    apiKey: z.string().min(1),
+    totalBudgetUsd: z.number().positive(),
+    perUserBudgetUsd: z.number().positive().optional(),
+});
+export const sponsoredKeyConsumerSchema = z.object({
+    userId: z.string().uuid(),
+    email: z.string(),
+    spentUsd: z.number(),
+    requestCount: z.number().int(),
+});
+export const sponsoredApiKeyResponse = sponsoredApiKeySchema
+    .omit({ encryptedKey: true })
+    .extend({ consumers: z.array(sponsoredKeyConsumerSchema) });
+//# sourceMappingURL=sponsored-api-key.js.map

package/dist/schemas/usage.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const usageLogSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    appId: z.ZodString;
+    accessTokenId: z.ZodString;
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    costUsd: z.ZodNumber;
+    platformFeeUsd: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type UsageLog = z.infer<typeof usageLogSchema>;
+export declare const PLATFORM_FEE_RATE = 0.05;
+export declare const calculatePlatformFee: (costUsd: number) => number;
+export declare const calculateTotalDebit: (costUsd: number) => number;
+//# sourceMappingURL=usage.d.ts.map

package/dist/schemas/usage.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { providerSchema } from './provider.js';
+export const usageLogSchema = z.object({
+    id: z.string().uuid(),
+    userId: z.string().uuid(),
+    appId: z.string().uuid(),
+    accessTokenId: z.string().uuid(),
+    provider: providerSchema,
+    model: z.string(),
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    costUsd: z.number().nonnegative(),
+    platformFeeUsd: z.number().nonnegative(),
+    createdAt: z.string().datetime(),
+});
+export const PLATFORM_FEE_RATE = 0.05;
+export const calculatePlatformFee = (costUsd) => Math.round(costUsd * PLATFORM_FEE_RATE * 1_000_000) / 1_000_000;
+export const calculateTotalDebit = (costUsd) => costUsd + calculatePlatformFee(costUsd);
+//# sourceMappingURL=usage.js.map

package/dist/schemas/user.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    passwordHash: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type User = z.infer<typeof userSchema>;
+export declare const createUserRequest: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateUserRequest = z.infer<typeof createUserRequest>;
+export declare const userResponse: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type UserResponse = z.infer<typeof userResponse>;
+//# sourceMappingURL=user.d.ts.map

package/dist/schemas/user.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export const userSchema = z.object({
+    id: z.string().uuid(),
+    email: z.string().email(),
+    passwordHash: z.string().optional(),
+    createdAt: z.string().datetime(),
+});
+export const createUserRequest = z.object({
+    email: z.string().email(),
+    password: z.string().min(8).max(128).optional(),
+});
+export const userResponse = userSchema.omit({ passwordHash: true });
+//# sourceMappingURL=user.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@tokenite/shared",
+  "version": "1.0.1",
+  "description": "Shared types, schemas, and model catalog for the Tokenite SDK and CLI. Public protocol surface.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./providers": {
+      "types": "./dist/providers/index.d.ts",
+      "import": "./dist/providers/index.js"
+    },
+    "./catalog": {
+      "types": "./dist/catalog/index.d.ts",
+      "import": "./dist/catalog/index.js"
+    },
+    "./schemas/cli-login": {
+      "types": "./dist/schemas/cli-login.d.ts",
+      "import": "./dist/schemas/cli-login.js"
+    },
+    "./schemas/discovery": {
+      "types": "./dist/schemas/discovery.d.ts",
+      "import": "./dist/schemas/discovery.js"
+    },
+    "./result": {
+      "types": "./dist/result.d.ts",
+      "import": "./dist/result.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eran-broder/tokenite-shared.git"
+  },
+  "homepage": "https://github.com/eran-broder/tokenite-shared#readme",
+  "bugs": {
+    "url": "https://github.com/eran-broder/tokenite-shared/issues"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}