@tokenite/shared 1.0.1

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const apiKeySchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    encryptedKey: z.ZodString;
+    keyHint: z.ZodString;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ApiKey = z.infer<typeof apiKeySchema>;
+export declare const addApiKeyRequest: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>;
+    apiKey: z.ZodString;
+}, z.core.$strip>;
+export type AddApiKeyRequest = z.infer<typeof addApiKeyRequest>;
+export declare const apiKeyResponse: z.ZodObject<{
+    provider: z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>;
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    userId: z.ZodString;
+    keyHint: z.ZodString;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ApiKeyResponse = z.infer<typeof apiKeyResponse>;
+//# sourceMappingURL=api-key.d.ts.map

package/dist/schemas/api-key.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { providerSchema } from './provider.js';
+export const apiKeySchema = z.object({
+    id: z.string().uuid(),
+    userId: z.string().uuid(),
+    provider: providerSchema,
+    encryptedKey: z.string(),
+    keyHint: z.string().max(8),
+    isActive: z.boolean().default(true),
+    createdAt: z.string().datetime(),
+});
+export const addApiKeyRequest = z.object({
+    provider: providerSchema.optional(),
+    apiKey: z.string().min(1),
+});
+export const apiKeyResponse = apiKeySchema.omit({ encryptedKey: true });
+//# sourceMappingURL=api-key.js.map

package/dist/schemas/app.d.ts

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+export declare const modelStrategySchema: z.ZodEnum<{
+    any: "any";
+    tier: "tier";
+    models: "models";
+}>;
+export type ModelStrategy = z.infer<typeof modelStrategySchema>;
+export declare const tierSchema: z.ZodEnum<{
+    cheap: "cheap";
+    fast: "fast";
+    smart: "smart";
+    reasoning: "reasoning";
+}>;
+export type RequiredTier = z.infer<typeof tierSchema>;
+export declare const appSchema: z.ZodObject<{
+    id: z.ZodString;
+    builderId: z.ZodString;
+    name: z.ZodString;
+    callbackUrl: z.ZodString;
+    requiredProviders: z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>;
+    preferredProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>>;
+    allowSubstitution: z.ZodDefault<z.ZodBoolean>;
+    allowedModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelStrategy: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        tier: "tier";
+        models: "models";
+    }>>;
+    requiredTier: z.ZodOptional<z.ZodEnum<{
+        cheap: "cheap";
+        fast: "fast";
+        smart: "smart";
+        reasoning: "reasoning";
+    }>>;
+    allowsManagedAgents: z.ZodDefault<z.ZodBoolean>;
+    websiteUrl: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    iconUrl: z.ZodOptional<z.ZodString>;
+    appSecret: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type App = z.infer<typeof appSchema>;
+export declare const createAppRequestBase: z.ZodObject<{
+    name: z.ZodString;
+    callbackUrl: z.ZodString;
+    requiredProviders: z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>;
+    preferredProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>>;
+    allowSubstitution: z.ZodDefault<z.ZodBoolean>;
+    allowedModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelStrategy: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        tier: "tier";
+        models: "models";
+    }>>;
+    requiredTier: z.ZodOptional<z.ZodEnum<{
+        cheap: "cheap";
+        fast: "fast";
+        smart: "smart";
+        reasoning: "reasoning";
+    }>>;
+    allowsManagedAgents: z.ZodDefault<z.ZodBoolean>;
+    websiteUrl: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    iconUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createAppRequest: z.ZodType<{
+    name: string;
+    callbackUrl: string;
+    requiredProviders: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[];
+    preferredProviders: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[];
+    allowSubstitution: boolean;
+    modelStrategy: "any" | "tier" | "models";
+    allowsManagedAgents: boolean;
+    allowedModels?: string[] | undefined;
+    requiredTier?: "cheap" | "fast" | "smart" | "reasoning" | undefined;
+    websiteUrl?: string | undefined;
+    description?: string | undefined;
+    iconUrl?: string | undefined;
+}, unknown, z.core.$ZodTypeInternals<{
+    name: string;
+    callbackUrl: string;
+    requiredProviders: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[];
+    preferredProviders: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[];
+    allowSubstitution: boolean;
+    modelStrategy: "any" | "tier" | "models";
+    allowsManagedAgents: boolean;
+    allowedModels?: string[] | undefined;
+    requiredTier?: "cheap" | "fast" | "smart" | "reasoning" | undefined;
+    websiteUrl?: string | undefined;
+    description?: string | undefined;
+    iconUrl?: string | undefined;
+}, unknown>>;
+export type CreateAppRequest = z.infer<typeof createAppRequest>;
+export declare const updateAppRequest: z.ZodType<{
+    name?: string | undefined;
+    callbackUrl?: string | undefined;
+    requiredProviders?: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[] | undefined;
+    preferredProviders?: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[] | undefined;
+    allowSubstitution?: boolean | undefined;
+    allowedModels?: string[] | undefined;
+    modelStrategy?: "any" | "tier" | "models" | undefined;
+    requiredTier?: "cheap" | "fast" | "smart" | "reasoning" | undefined;
+    allowsManagedAgents?: boolean | undefined;
+    websiteUrl?: string | undefined;
+    description?: string | undefined;
+    iconUrl?: string | undefined;
+}, unknown, z.core.$ZodTypeInternals<{
+    name?: string | undefined;
+    callbackUrl?: string | undefined;
+    requiredProviders?: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[] | undefined;
+    preferredProviders?: ("anthropic" | "openai" | "bedrock" | "google" | "grok")[] | undefined;
+    allowSubstitution?: boolean | undefined;
+    allowedModels?: string[] | undefined;
+    modelStrategy?: "any" | "tier" | "models" | undefined;
+    requiredTier?: "cheap" | "fast" | "smart" | "reasoning" | undefined;
+    allowsManagedAgents?: boolean | undefined;
+    websiteUrl?: string | undefined;
+    description?: string | undefined;
+    iconUrl?: string | undefined;
+}, unknown>>;
+export type UpdateAppRequest = z.infer<typeof updateAppRequest>;
+export declare const appResponse: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    builderId: z.ZodString;
+    callbackUrl: z.ZodString;
+    requiredProviders: z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>;
+    preferredProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        bedrock: "bedrock";
+        google: "google";
+        grok: "grok";
+    }>>>;
+    allowSubstitution: z.ZodDefault<z.ZodBoolean>;
+    allowedModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelStrategy: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        tier: "tier";
+        models: "models";
+    }>>;
+    requiredTier: z.ZodOptional<z.ZodEnum<{
+        cheap: "cheap";
+        fast: "fast";
+        smart: "smart";
+        reasoning: "reasoning";
+    }>>;
+    allowsManagedAgents: z.ZodDefault<z.ZodBoolean>;
+    websiteUrl: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    iconUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AppResponse = z.infer<typeof appResponse>;
+//# sourceMappingURL=app.d.ts.map

package/dist/schemas/app.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { providerSchema } from './provider.js';
+export const modelStrategySchema = z.enum(['any', 'tier', 'models']);
+export const tierSchema = z.enum(['cheap', 'fast', 'smart', 'reasoning']);
+export const appSchema = z.object({
+    id: z.string().uuid(),
+    builderId: z.string().uuid(),
+    name: z.string().min(1).max(100),
+    callbackUrl: z.string().url(),
+    requiredProviders: z.array(providerSchema),
+    preferredProviders: z.array(providerSchema).default([]),
+    allowSubstitution: z.boolean().default(false),
+    allowedModels: z.array(z.string()).optional(),
+    modelStrategy: modelStrategySchema.default('any'),
+    requiredTier: tierSchema.optional(),
+    allowsManagedAgents: z.boolean().default(false),
+    websiteUrl: z.string().url().optional(),
+    description: z.string().max(500).optional(),
+    iconUrl: z.string().url().optional(),
+    appSecret: z.string(),
+    createdAt: z.string().datetime(),
+});
+export const createAppRequestBase = z.object({
+    name: z.string().min(1).max(100),
+    callbackUrl: z.string().url(),
+    requiredProviders: z.array(providerSchema).min(1),
+    preferredProviders: z.array(providerSchema).default([]),
+    allowSubstitution: z.boolean().default(false),
+    allowedModels: z.array(z.string()).optional(),
+    modelStrategy: modelStrategySchema.default('any'),
+    requiredTier: tierSchema.optional(),
+    allowsManagedAgents: z.boolean().default(false),
+    websiteUrl: z.string().url().optional(),
+    description: z.string().max(500).optional(),
+    iconUrl: z.string().url().optional(),
+});
+const refineStrategy = (s) => s.refine((v) => v.modelStrategy !== 'tier' || !!v.requiredTier, { message: "modelStrategy='tier' requires requiredTier", path: ['requiredTier'] }).refine((v) => v.modelStrategy !== 'models' || (v.allowedModels?.length ?? 0) > 0, { message: "modelStrategy='models' requires non-empty allowedModels", path: ['allowedModels'] });
+export const createAppRequest = refineStrategy(createAppRequestBase);
+export const updateAppRequest = refineStrategy(createAppRequestBase.partial());
+export const appResponse = appSchema.omit({ appSecret: true });
+//# sourceMappingURL=app.js.map

package/dist/schemas/budget.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const budgetSchema: z.ZodObject<{
+    limit: z.ZodNumber;
+    spent: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type Budget = z.infer<typeof budgetSchema>;
+export declare const DEBT_TOLERANCE_USD = 0.01;
+export declare const isBudgetAvailable: (budget: Budget) => boolean;
+export declare const remainingBudget: (budget: Budget) => number;
+//# sourceMappingURL=budget.d.ts.map

package/dist/schemas/budget.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const budgetSchema = z.object({
+    limit: z.number().positive(),
+    spent: z.number().default(0),
+});
+export const DEBT_TOLERANCE_USD = 0.01;
+export const isBudgetAvailable = (budget) => budget.spent < budget.limit + DEBT_TOLERANCE_USD;
+export const remainingBudget = (budget) => Math.max(0, budget.limit - budget.spent);
+//# sourceMappingURL=budget.js.map

package/dist/schemas/cli-login.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const CliLoopbackHost: {
+    readonly V4: "127.0.0.1";
+    readonly V6: "[::1]";
+    readonly Localhost: "localhost";
+};
+export type CliLoopbackHost = typeof CliLoopbackHost[keyof typeof CliLoopbackHost];
+export declare const cliLoginParamsSchema: z.ZodObject<{
+    port: z.ZodCoercedNumber<unknown>;
+    state: z.ZodString;
+    host: z.ZodEnum<{
+        "127.0.0.1": "127.0.0.1";
+        "[::1]": "[::1]";
+        localhost: "localhost";
+    }>;
+}, z.core.$strip>;
+export type CliLoginParams = z.infer<typeof cliLoginParamsSchema>;
+export declare const cliLoginMintRequestSchema: z.ZodObject<{
+    port: z.ZodCoercedNumber<unknown>;
+    state: z.ZodString;
+    host: z.ZodEnum<{
+        "127.0.0.1": "127.0.0.1";
+        "[::1]": "[::1]";
+        localhost: "localhost";
+    }>;
+}, z.core.$strip>;
+export type CliLoginMintRequest = z.infer<typeof cliLoginMintRequestSchema>;
+export declare const cliLoginMintResponseSchema: z.ZodObject<{
+    redirect_to: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>;
+export type CliLoginMintResponse = z.infer<typeof cliLoginMintResponseSchema>;
+export declare const cliLoginExchangeRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export type CliLoginExchangeRequest = z.infer<typeof cliLoginExchangeRequestSchema>;
+export declare const cliLoginExchangeResponseSchema: z.ZodObject<{
+    token: z.ZodString;
+    email: z.ZodString;
+}, z.core.$strip>;
+export type CliLoginExchangeResponse = z.infer<typeof cliLoginExchangeResponseSchema>;
+//# sourceMappingURL=cli-login.d.ts.map

package/dist/schemas/cli-login.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const CliLoopbackHost = {
+    V4: '127.0.0.1',
+    V6: '[::1]',
+    Localhost: 'localhost',
+};
+const cliLoopbackHostSchema = z.enum([CliLoopbackHost.V4, CliLoopbackHost.V6, CliLoopbackHost.Localhost]);
+export const cliLoginParamsSchema = z.object({
+    port: z.coerce.number().int().min(1).max(65535),
+    state: z.string().min(8).max(128),
+    host: cliLoopbackHostSchema,
+});
+export const cliLoginMintRequestSchema = cliLoginParamsSchema;
+export const cliLoginMintResponseSchema = z.object({
+    redirect_to: z.string().url(),
+    code: z.string(),
+});
+export const cliLoginExchangeRequestSchema = z.object({
+    code: z.string().min(1),
+});
+export const cliLoginExchangeResponseSchema = z.object({
+    token: z.string(),
+    email: z.string().email(),
+});
+//# sourceMappingURL=cli-login.js.map

package/dist/schemas/discovery.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const discoverySchema: z.ZodObject<{
+    appUrl: z.ZodString;
+    proxyUrl: z.ZodString;
+}, z.core.$strip>;
+export type Discovery = z.infer<typeof discoverySchema>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/schemas/discovery.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const discoverySchema = z.object({
+    appUrl: z.string().url(),
+    proxyUrl: z.string().url(),
+});
+//# sourceMappingURL=discovery.js.map

package/dist/schemas/error-codes.d.ts

@@ -0,0 +1,154 @@
+export declare const proxyErrorCodes: {
+    readonly TOKEN_INVALID: {
+        readonly code: "TOKEN_INVALID";
+        readonly status: 401;
+        readonly message: "Invalid access token";
+    };
+    readonly TOKEN_REVOKED: {
+        readonly code: "TOKEN_REVOKED";
+        readonly status: 401;
+        readonly message: "Access token has been revoked";
+    };
+    readonly TOKEN_SUSPENDED: {
+        readonly code: "TOKEN_SUSPENDED";
+        readonly status: 403;
+        readonly message: "Access has been suspended by the user";
+    };
+    readonly TOKEN_EXPIRED: {
+        readonly code: "TOKEN_EXPIRED";
+        readonly status: 401;
+        readonly message: "Access token has expired";
+    };
+    readonly BUDGET_EXCEEDED: {
+        readonly code: "BUDGET_EXCEEDED";
+        readonly status: 402;
+        readonly message: "Budget limit exceeded";
+    };
+    readonly POOL_EXHAUSTED: {
+        readonly code: "POOL_EXHAUSTED";
+        readonly status: 402;
+        readonly message: "Account pool budget exhausted";
+    };
+    readonly PROVIDER_KEY_MISSING: {
+        readonly code: "PROVIDER_KEY_MISSING";
+        readonly status: 402;
+        readonly message: "No API key or credits available for required provider";
+    };
+    readonly CREDITS_DEPLETED: {
+        readonly code: "CREDITS_DEPLETED";
+        readonly status: 402;
+        readonly message: "Insufficient credits";
+    };
+    readonly APP_NOT_FOUND: {
+        readonly code: "APP_NOT_FOUND";
+        readonly status: 404;
+        readonly message: "Application not found";
+    };
+    readonly MODEL_NOT_ALLOWED: {
+        readonly code: "MODEL_NOT_ALLOWED";
+        readonly status: 403;
+        readonly message: "Model not in allowed models list";
+    };
+    readonly AGENT_SCOPE_MISSING: {
+        readonly code: "AGENT_SCOPE_MISSING";
+        readonly status: 403;
+        readonly message: "App does not have the managed-agents scope";
+    };
+    readonly SPONSORED_POOL_EXHAUSTED: {
+        readonly code: "SPONSORED_POOL_EXHAUSTED";
+        readonly status: 402;
+        readonly message: "Sponsored credits pool is exhausted";
+    };
+    readonly SPONSORED_KEY_UNAVAILABLE: {
+        readonly code: "SPONSORED_KEY_UNAVAILABLE";
+        readonly status: 402;
+        readonly message: "Sponsored key is no longer active";
+    };
+    readonly SPONSORED_PROVIDER_MISMATCH: {
+        readonly code: "SPONSORED_PROVIDER_MISMATCH";
+        readonly status: 402;
+        readonly message: "Sponsored key does not cover requested provider";
+    };
+};
+export declare const providerErrorCodes: {
+    readonly RATE_LIMITED: {
+        readonly code: "RATE_LIMITED";
+        readonly status: 429;
+        readonly message: "Rate limited by the LLM provider";
+    };
+    readonly CONTEXT_LENGTH_EXCEEDED: {
+        readonly code: "CONTEXT_LENGTH_EXCEEDED";
+        readonly status: 400;
+        readonly message: "Request exceeds model context length";
+    };
+    readonly INVALID_REQUEST: {
+        readonly code: "INVALID_REQUEST";
+        readonly status: 400;
+        readonly message: "Invalid request rejected by the LLM provider";
+    };
+    readonly AUTHENTICATION_FAILED: {
+        readonly code: "AUTHENTICATION_FAILED";
+        readonly status: 401;
+        readonly message: "LLM provider rejected the API key";
+    };
+    readonly PROVIDER_OVERLOADED: {
+        readonly code: "PROVIDER_OVERLOADED";
+        readonly status: 503;
+        readonly message: "LLM provider is temporarily overloaded";
+    };
+    readonly CONTENT_FILTERED: {
+        readonly code: "CONTENT_FILTERED";
+        readonly status: 400;
+        readonly message: "Content blocked by the LLM provider safety filter";
+    };
+    readonly PROVIDER_TIMEOUT: {
+        readonly code: "PROVIDER_TIMEOUT";
+        readonly status: 504;
+        readonly message: "LLM provider did not respond";
+    };
+    readonly PROVIDER_ERROR: {
+        readonly code: "PROVIDER_ERROR";
+        readonly status: 502;
+        readonly message: "LLM provider returned an error";
+    };
+};
+export declare const apiErrorCodes: {
+    readonly VALIDATION: "VALIDATION";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly INTERNAL: "INTERNAL";
+    readonly UNKNOWN: "UNKNOWN";
+    readonly INSUFFICIENT_ROLE: "INSUFFICIENT_ROLE";
+    readonly EMAIL_TAKEN: "EMAIL_TAKEN";
+    readonly WRONG_EMAIL: "WRONG_EMAIL";
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly INVALID_CLIENT: "INVALID_CLIENT";
+    readonly INVALID_CODE: "INVALID_CODE";
+    readonly INVALID_INVITATION: "INVALID_INVITATION";
+    readonly INVITATION_EXPIRED: "INVITATION_EXPIRED";
+    readonly INVITE_PENDING: "INVITE_PENDING";
+    readonly ALREADY_CLAIMED: "ALREADY_CLAIMED";
+    readonly ALREADY_MEMBER: "ALREADY_MEMBER";
+    readonly PAT_NOT_FOUND: "PAT_NOT_FOUND";
+    readonly UNKNOWN_PROVIDER: "UNKNOWN_PROVIDER";
+    readonly CANNOT_DELETE_PERSONAL: "CANNOT_DELETE_PERSONAL";
+    readonly CANNOT_INVITE_TO_PERSONAL: "CANNOT_INVITE_TO_PERSONAL";
+    readonly TEAM_CANNOT_BUILD: "TEAM_CANNOT_BUILD";
+    readonly CANNOT_REMOVE_SELF: "CANNOT_REMOVE_SELF";
+    readonly SOLE_OWNER: "SOLE_OWNER";
+    readonly NO_KEY: "NO_KEY";
+    readonly NOT_ACTIVE: "NOT_ACTIVE";
+    readonly SPONSORED_INELIGIBLE: "SPONSORED_INELIGIBLE";
+    readonly BUDGET_UPDATE_FAILED: "BUDGET_UPDATE_FAILED";
+    readonly SPONSORED_POOL_UPDATE_FAILED: "SPONSORED_POOL_UPDATE_FAILED";
+    readonly ENCRYPTION_FAILED: "ENCRYPTION_FAILED";
+    readonly DECRYPTION_FAILED: "DECRYPTION_FAILED";
+    readonly DB_INSERT_FAILED: "DB_INSERT_FAILED";
+    readonly FETCH_FAILED: "FETCH_FAILED";
+};
+export type ProxyErrorCode = keyof typeof proxyErrorCodes;
+export type ProviderErrorCode = keyof typeof providerErrorCodes;
+export type ApiErrorCode = keyof typeof apiErrorCodes;
+export type ErrorCode = ProxyErrorCode | ProviderErrorCode | ApiErrorCode;
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/schemas/error-codes.js

@@ -0,0 +1,62 @@
+export const proxyErrorCodes = {
+    TOKEN_INVALID: { code: 'TOKEN_INVALID', status: 401, message: 'Invalid access token' },
+    TOKEN_REVOKED: { code: 'TOKEN_REVOKED', status: 401, message: 'Access token has been revoked' },
+    TOKEN_SUSPENDED: { code: 'TOKEN_SUSPENDED', status: 403, message: 'Access has been suspended by the user' },
+    TOKEN_EXPIRED: { code: 'TOKEN_EXPIRED', status: 401, message: 'Access token has expired' },
+    BUDGET_EXCEEDED: { code: 'BUDGET_EXCEEDED', status: 402, message: 'Budget limit exceeded' },
+    POOL_EXHAUSTED: { code: 'POOL_EXHAUSTED', status: 402, message: 'Account pool budget exhausted' },
+    PROVIDER_KEY_MISSING: { code: 'PROVIDER_KEY_MISSING', status: 402, message: 'No API key or credits available for required provider' },
+    CREDITS_DEPLETED: { code: 'CREDITS_DEPLETED', status: 402, message: 'Insufficient credits' },
+    APP_NOT_FOUND: { code: 'APP_NOT_FOUND', status: 404, message: 'Application not found' },
+    MODEL_NOT_ALLOWED: { code: 'MODEL_NOT_ALLOWED', status: 403, message: 'Model not in allowed models list' },
+    AGENT_SCOPE_MISSING: { code: 'AGENT_SCOPE_MISSING', status: 403, message: 'App does not have the managed-agents scope' },
+    SPONSORED_POOL_EXHAUSTED: { code: 'SPONSORED_POOL_EXHAUSTED', status: 402, message: 'Sponsored credits pool is exhausted' },
+    SPONSORED_KEY_UNAVAILABLE: { code: 'SPONSORED_KEY_UNAVAILABLE', status: 402, message: 'Sponsored key is no longer active' },
+    SPONSORED_PROVIDER_MISMATCH: { code: 'SPONSORED_PROVIDER_MISMATCH', status: 402, message: 'Sponsored key does not cover requested provider' },
+};
+export const providerErrorCodes = {
+    RATE_LIMITED: { code: 'RATE_LIMITED', status: 429, message: 'Rate limited by the LLM provider' },
+    CONTEXT_LENGTH_EXCEEDED: { code: 'CONTEXT_LENGTH_EXCEEDED', status: 400, message: 'Request exceeds model context length' },
+    INVALID_REQUEST: { code: 'INVALID_REQUEST', status: 400, message: 'Invalid request rejected by the LLM provider' },
+    AUTHENTICATION_FAILED: { code: 'AUTHENTICATION_FAILED', status: 401, message: 'LLM provider rejected the API key' },
+    PROVIDER_OVERLOADED: { code: 'PROVIDER_OVERLOADED', status: 503, message: 'LLM provider is temporarily overloaded' },
+    CONTENT_FILTERED: { code: 'CONTENT_FILTERED', status: 400, message: 'Content blocked by the LLM provider safety filter' },
+    PROVIDER_TIMEOUT: { code: 'PROVIDER_TIMEOUT', status: 504, message: 'LLM provider did not respond' },
+    PROVIDER_ERROR: { code: 'PROVIDER_ERROR', status: 502, message: 'LLM provider returned an error' },
+};
+export const apiErrorCodes = {
+    VALIDATION: 'VALIDATION',
+    FORBIDDEN: 'FORBIDDEN',
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    NOT_FOUND: 'NOT_FOUND',
+    INTERNAL: 'INTERNAL',
+    UNKNOWN: 'UNKNOWN',
+    INSUFFICIENT_ROLE: 'INSUFFICIENT_ROLE',
+    EMAIL_TAKEN: 'EMAIL_TAKEN',
+    WRONG_EMAIL: 'WRONG_EMAIL',
+    INVALID_CREDENTIALS: 'INVALID_CREDENTIALS',
+    INVALID_CLIENT: 'INVALID_CLIENT',
+    INVALID_CODE: 'INVALID_CODE',
+    INVALID_INVITATION: 'INVALID_INVITATION',
+    INVITATION_EXPIRED: 'INVITATION_EXPIRED',
+    INVITE_PENDING: 'INVITE_PENDING',
+    ALREADY_CLAIMED: 'ALREADY_CLAIMED',
+    ALREADY_MEMBER: 'ALREADY_MEMBER',
+    PAT_NOT_FOUND: 'PAT_NOT_FOUND',
+    UNKNOWN_PROVIDER: 'UNKNOWN_PROVIDER',
+    CANNOT_DELETE_PERSONAL: 'CANNOT_DELETE_PERSONAL',
+    CANNOT_INVITE_TO_PERSONAL: 'CANNOT_INVITE_TO_PERSONAL',
+    TEAM_CANNOT_BUILD: 'TEAM_CANNOT_BUILD',
+    CANNOT_REMOVE_SELF: 'CANNOT_REMOVE_SELF',
+    SOLE_OWNER: 'SOLE_OWNER',
+    NO_KEY: 'NO_KEY',
+    NOT_ACTIVE: 'NOT_ACTIVE',
+    SPONSORED_INELIGIBLE: 'SPONSORED_INELIGIBLE',
+    BUDGET_UPDATE_FAILED: 'BUDGET_UPDATE_FAILED',
+    SPONSORED_POOL_UPDATE_FAILED: 'SPONSORED_POOL_UPDATE_FAILED',
+    ENCRYPTION_FAILED: 'ENCRYPTION_FAILED',
+    DECRYPTION_FAILED: 'DECRYPTION_FAILED',
+    DB_INSERT_FAILED: 'DB_INSERT_FAILED',
+    FETCH_FAILED: 'FETCH_FAILED',
+};
+//# sourceMappingURL=error-codes.js.map

package/dist/schemas/error.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export { proxyErrorCodes, providerErrorCodes, apiErrorCodes, type ProxyErrorCode, type ProviderErrorCode, type ApiErrorCode, type ErrorCode, } from './error-codes.js';
+export declare const errorSourceSchema: z.ZodEnum<{
+    proxy: "proxy";
+    provider: "provider";
+}>;
+export type ErrorSource = z.infer<typeof errorSourceSchema>;
+export declare const errorResponseSchema: 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 ErrorResponse = z.infer<typeof errorResponseSchema>;
+//# sourceMappingURL=error.d.ts.map

package/dist/schemas/error.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export { proxyErrorCodes, providerErrorCodes, apiErrorCodes, } from './error-codes.js';
+export const errorSourceSchema = z.enum(['proxy', 'provider']);
+export const errorResponseSchema = z.object({
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+        source: errorSourceSchema,
+        details: z.record(z.string(), z.unknown()).optional(),
+    }),
+});
+//# sourceMappingURL=error.js.map

package/dist/schemas/provider.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type ProviderId } from '../catalog/providers/index.js';
+export declare const providerSchema: z.ZodEnum<{
+    anthropic: "anthropic";
+    openai: "openai";
+    bedrock: "bedrock";
+    google: "google";
+    grok: "grok";
+}>;
+export type Provider = ProviderId;
+//# sourceMappingURL=provider.d.ts.map

package/dist/schemas/provider.js

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { PROVIDER_IDS } from '../catalog/providers/index.js';
+export const providerSchema = z.enum(PROVIDER_IDS);
+//# sourceMappingURL=provider.js.map