@scrawn/core 0.0.2 → 0.0.6

package/dist/core/scrawn.js

@@ -1,31 +1,58 @@
-import { ApiKeyAuth } from './auth/apiKeyAuth.js';
-import { ScrawnLogger } from '../utils/logger.js';
-import { matchPath } from '../utils/pathMatcher.js';
-import { EventPayloadSchema } from './types/event.js';
-import { GrpcClient } from './grpc/index.js';
-import { EventService } from '../gen/event/v1/event_connect.js';
-import { EventType, SDKCallType, SDKCall } from '../gen/event/v1/event_pb.js';
-import { PaymentService } from '../gen/payment/v1/payment_connect.js';
-const log = new ScrawnLogger('Scrawn');
+import { ApiKeyAuth } from "./auth/apiKeyAuth.js";
+import { ScrawnLogger } from "../utils/logger.js";
+import { matchPath } from "../utils/pathMatcher.js";
+import { forkAsyncIterable } from "../utils/forkAsyncIterable.js";
+import { EventPayloadSchema, AITokenUsagePayloadSchema, } from "./types/event.js";
+import { GrpcClient } from "./grpc/index.js";
+import { EventServiceClient } from "../gen/event/v1/event_grpc_pb.js";
+import { RegisterEventRequest, StreamEventRequest, EventType, SDKCallType, SDKCall, AITokenUsage, } from "../gen/event/v1/event_pb.js";
+import { PaymentServiceClient } from "../gen/payment/v1/payment_grpc_pb.js";
+import { CreateCheckoutLinkRequest, } from "../gen/payment/v1/payment_pb.js";
+import { ScrawnConfigError, ScrawnValidationError, convertGrpcError, isScrawnError, } from "./errors/index.js";
+import { serializeExpr, resolveTokens, prettyPrintExpr, tag as _tag } from "./pricing/index.js";
+import { ScrawnConfig } from "../config.js";
+const log = new ScrawnLogger("Scrawn");
 /**
  * Main SDK class for Scrawn billing infrastructure.
  *
  * Manages authentication, event tracking, and credential caching.
  * All event consumption methods are available directly on the SDK instance.
  *
+ * @typeParam TTags - Union of valid tag names for compile-time type checking
+ *
  * @example
  * ```typescript
- * import { Scrawn } from '@scrawn/core';
+ * import { createScrawn } from '@scrawn/core';
  *
- * // Initialize SDK
- * const scrawn = new Scrawn({ apiKey: process.env.SCRAWN_KEY });
- * await scrawn.init();
+ * const biller = createScrawn({
+ *   apiKey: process.env.SCRAWN_KEY,
+ *   baseURL: 'http://localhost:8069',
+ *   tags: ["PREMIUM_CALL", "EXTRA_FEE"] as const,
+ * });
  *
- * // Track SDK calls
- * await scrawn.sdkCallEventConsumer({ userId: 'u123', debitAmount: 3 });
+ * // Tags are compile-time checked
+ * biller.sdkCallEventConsumer({ userId: 'u123', debitTag: 'PREMIUM_FEATURE' });
+ * // biller.sdkCallEventConsumer({ userId: 'u123', debitTag: 'UNKNOWN' }); // Type error!
  * ```
  */
 export class Scrawn {
+    /** Public access to the gRPC client for use by other packages (e.g. @scrawn/analytics) */
+    get grpc() {
+        return this.grpcClient;
+    }
+    /** API key used for authorizing gRPC calls */
+    get apikey() {
+        return this.apiKey;
+    }
+    notifyEventConsumerError(error, onError) {
+        const converted = isScrawnError(error) ? error : convertGrpcError(error);
+        onError?.(converted);
+        return converted;
+    }
+    notifyValidationError(error, onError) {
+        onError?.(error);
+        return error;
+    }
     /**
      * Creates a new Scrawn SDK instance.
      *
@@ -51,15 +78,60 @@ export class Scrawn {
          */
         this.credCache = new Map();
         try {
+            // Validate configuration
+            if (!config.apiKey || typeof config.apiKey !== "string") {
+                throw new ScrawnConfigError("API key is required and must be a string", {
+                    details: { provided: typeof config.apiKey },
+                });
+            }
+            if (!config.baseURL || typeof config.baseURL !== "string") {
+                throw new ScrawnConfigError("baseURL is required and must be a string", {
+                    details: { provided: typeof config.baseURL },
+                });
+            }
             this.apiKey = config.apiKey;
-            this.grpcClient = new GrpcClient(config.baseURL);
-            this.registerAuthMethod('api', new ApiKeyAuth(this.apiKey));
+            this.grpcClient = new GrpcClient(this.parseURLToTarget(config.baseURL), { secure: config.secure ?? true, credentials: config.credentials });
+            this.registerAuthMethod("api", new ApiKeyAuth(this.apiKey));
         }
         catch (error) {
-            log.error('Failed to initialize Scrawn SDK');
+            log.error("Failed to initialize Scrawn SDK");
             throw error;
         }
     }
+    parseURLToTarget(baseURL) {
+        if (baseURL.includes("://")) {
+            const url = new URL(baseURL);
+            return `${url.hostname}:${url.port || ScrawnConfig.grpc.defaultPort}`;
+        }
+        return baseURL.includes(":")
+            ? baseURL
+            : `${baseURL}:${ScrawnConfig.grpc.defaultPort}`;
+    }
+    /**
+     * Create a type-safe tag reference.
+     *
+     * Only tag names known to this biller instance are accepted at compile time.
+     * Tag values are resolved to cent amounts by the backend at runtime.
+     *
+     * @param name - The tag name (must be one of the known tags for this instance)
+     * @returns A TagExpr referencing the named tag
+     * @throws PricingExpressionError at runtime if name format is invalid
+     *
+     * @example
+     * ```typescript
+     * const expr = mul(biller.tag("PREMIUM_CALL"), 3);
+     * ```
+     */
+    tag(name) {
+        return _tag(name);
+    }
+    expr(value) {
+        return {
+            _expr: typeof value === "string"
+                ? { kind: "exprRef", name: value }
+                : value,
+        };
+    }
     /**
      * Register an authentication method with the SDK.
      *
@@ -102,7 +174,9 @@ export class Scrawn {
         // Get fresh creds from auth method
         const auth = this.authMethods.get(authMethodName);
         if (!auth) {
-            throw new Error(`No auth method registered: ${authMethodName}`);
+            throw new ScrawnConfigError(`No auth method registered: ${authMethodName}`, {
+                details: { requestedMethod: authMethodName },
+            });
         }
         const creds = await auth.getCreds();
         this.credCache.set(authMethodName, creds);
@@ -116,32 +190,74 @@ export class Scrawn {
      *
      * @param payload - The SDK call data to track
      * @param payload.userId - Unique identifier of the user making the call
-     * @param payload.debitAmount - Amount to debit from the user's account
-     * @returns A promise that resolves when the event is tracked
-     * @throws Error if payload validation fails
+     * @param payload.debitAmount - (Optional) Direct amount in cents to debit from the user's account
+     * @param payload.debitTag - (Optional) Named price tag for backend-managed pricing
+     * @param payload.debitExpr - (Optional) Pricing expression for complex calculations
+     * @param options - Optional configuration
+     * @param options.onError - Optional callback for handling validation or gRPC errors
+     * @returns A promise that resolves when the event is tracked or returns early on error
      *
      * @example
      * ```typescript
+     * import { add, mul, tag } from '@scrawn/core';
+     *
+     * // Using direct amount (500 cents = $5.00)
+     * await scrawn.sdkCallEventConsumer({
+     *   userId: 'user_abc123',
+     *   debitAmount: 500
+     * });
+     *
+     * // Using price tag
+     * await scrawn.sdkCallEventConsumer({
+     *   userId: 'user_abc123',
+     *   debitTag: 'PREMIUM_FEATURE'
+     * });
+     *
+     * // Using pricing expression: (PREMIUM_CALL * 3) + EXTRA_FEE + 250 cents
      * await scrawn.sdkCallEventConsumer({
      *   userId: 'user_abc123',
-     *   debitAmount: 10
+     *   debitExpr: add(mul(tag('PREMIUM_CALL'), 3), tag('EXTRA_FEE'), 250)
      * });
      * ```
      */
-    async sdkCallEventConsumer(payload) {
-        const validationResult = EventPayloadSchema.safeParse(payload);
+    async sdkCallEventConsumer(payload, options) {
+        const rawPayload = {
+            userId: payload.userId,
+            debitAmount: payload.debitAmount,
+            debitTag: payload.debitTag,
+            debitExpr: payload.debitExpr?._expr,
+        };
+        const validationResult = EventPayloadSchema.safeParse(rawPayload);
         if (!validationResult.success) {
-            const errors = validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
+            const errors = validationResult.error.issues
+                .map((e) => `${e.path.join(".")}: ${e.message}`)
+                .join(", ");
             log.error(`Invalid payload for sdkCallEventConsumer: ${errors}`);
-            throw new Error(`Payload validation failed: ${errors}`); // TODO: for error shit implement the callback shit
+            const error = new ScrawnValidationError("Payload validation failed", {
+                details: {
+                    errors: validationResult.error.issues.map((e) => ({
+                        field: e.path.join("."),
+                        message: e.message,
+                    })),
+                },
+            });
+            this.notifyValidationError(error, options?.onError);
+            return;
+        }
+        try {
+            await this.consumeEvent(validationResult.data, "api", "SDK_CALL");
+        }
+        catch (error) {
+            log.error(`Failed to track sdkCallEventConsumer event: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.notifyEventConsumerError(error, options?.onError);
+            return;
         }
-        return this.consumeEvent(validationResult.data, 'api', 'SDK_CALL'); // TODO: change this event type when jaydeep changes it in backend
     }
     /**
      * Create an Express-compatible middleware for tracking API endpoint usage.
      *
      * This middleware automatically tracks requests to your API endpoints for billing purposes.
-     * You provide an extractor function that determines the userId and debitAmount from each request.
+     * You provide an extractor function that determines the userId and debit info (amount or tag) from each request.
      * Optionally, you can provide a whitelist array to only track specific endpoints,
      * or a blacklist array to exclude specific endpoints from tracking.
      *
@@ -157,6 +273,7 @@ export class Scrawn {
      *                            Takes precedence over blacklist. If omitted, all requests will be tracked.
      * @param config.blacklist - Optional array of endpoint patterns to exclude. Same wildcard support as whitelist.
      *                            Only applies to endpoints not in the whitelist.
+     * @param config.onError - Optional callback for handling validation or gRPC errors
      *
      * @returns Express-compatible middleware function
      *
@@ -192,17 +309,17 @@ export class Scrawn {
     middlewareEventConsumer(config) {
         return async (req, res, next) => {
             try {
-                const requestPath = req.path || req.url || '';
+                const requestPath = req.path || req.url || "";
                 // Check whitelist first (takes precedence)
                 if (config.whitelist && config.whitelist.length > 0) {
-                    const isWhitelisted = config.whitelist.some(pattern => matchPath(requestPath, pattern));
+                    const isWhitelisted = config.whitelist.some((pattern) => matchPath(requestPath, pattern));
                     if (!isWhitelisted) {
                         return next();
                     }
                 }
                 // Then check blacklist
                 if (config.blacklist && config.blacklist.length > 0) {
-                    const isBlacklisted = config.blacklist.some(pattern => matchPath(requestPath, pattern));
+                    const isBlacklisted = config.blacklist.some((pattern) => matchPath(requestPath, pattern));
                     if (isBlacklisted) {
                         return next();
                     }
@@ -213,22 +330,40 @@ export class Scrawn {
                     log.warn(`Extractor returned null for path: ${requestPath}. Skipping event tracking.`);
                     return next();
                 }
-                const validationResult = EventPayloadSchema.safeParse(extractedPayload);
+                const rawPayload = {
+                    userId: extractedPayload.userId,
+                    debitAmount: extractedPayload.debitAmount,
+                    debitTag: extractedPayload.debitTag,
+                    debitExpr: extractedPayload.debitExpr?._expr,
+                };
+                const validationResult = EventPayloadSchema.safeParse(rawPayload);
                 if (!validationResult.success) {
-                    const errors = validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
-                    log.error(`Invalid payload extracted in middlewareEventConsumer: ${errors}`); // TODO: for error shit implement the callback shit
+                    const errors = validationResult.error.issues
+                        .map((e) => `${e.path.join(".")}: ${e.message}`)
+                        .join(", ");
+                    log.error(`Invalid payload extracted in middlewareEventConsumer: ${errors}`);
+                    const error = new ScrawnValidationError("Payload validation failed", {
+                        details: {
+                            errors: validationResult.error.issues.map((e) => ({
+                                field: e.path.join("."),
+                                message: e.message,
+                            })),
+                        },
+                    });
+                    this.notifyValidationError(error, config.onError);
                     return next();
                 }
-                this.consumeEvent(validationResult.data, 'api', 'MIDDLEWARE_CALL')
-                    .catch(error => {
+                this.consumeEvent(validationResult.data, "api", "MIDDLEWARE_CALL").catch((error) => {
                     log.error(`Failed to track middleware event: ${error.message}`);
-                }); // TODO: for error shit implement the callback shit
+                    this.notifyEventConsumerError(error, config.onError);
+                });
                 next();
             }
             catch (error) {
-                log.error(`Error in middlewareEventConsumer: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                log.error(`Error in middlewareEventConsumer: ${error instanceof Error ? error.message : "Unknown error"}`);
+                this.notifyEventConsumerError(error, config.onError);
                 next();
-            } // TODO: for error shit implement the callback shit
+            }
         };
     }
     /**
@@ -250,25 +385,29 @@ export class Scrawn {
      */
     async collectPayment(userId) {
         // Validate input
-        if (!userId || typeof userId !== 'string' || userId.trim().length === 0) {
-            log.error('Invalid userId provided to collectPayment');
-            throw new Error('userId must be a non-empty string');
+        if (!userId || typeof userId !== "string" || userId.trim().length === 0) {
+            log.error("Invalid userId provided to collectPayment");
+            throw new ScrawnValidationError("userId must be a non-empty string", {
+                details: { provided: typeof userId },
+            });
         }
         // Get credentials for authentication
-        const creds = await this.getCredsFor('api');
+        const creds = await this.getCredsFor("api");
         try {
             log.info(`Creating checkout link for user: ${userId}`);
+            const request = new CreateCheckoutLinkRequest();
+            request.setUserid(userId);
             const response = await this.grpcClient
-                .newCall(PaymentService, 'createCheckoutLink')
-                .addHeader('Authorization', `Bearer ${creds.apiKey}`)
-                .addPayload({ userId })
+                .newCall(PaymentServiceClient, "createCheckoutLink")
+                .addMetadata("authorization", `Bearer ${creds.apiKey}`)
+                .addPayload(request)
                 .request();
-            log.info(`Checkout link created successfully: ${response.checkoutLink}`);
-            return response.checkoutLink;
+            log.info(`Checkout link created successfully: ${response.getCheckoutlink()}`);
+            return response.getCheckoutlink();
         }
         catch (error) {
-            log.error(`Failed to create checkout link: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            throw error;
+            log.error(`Failed to create checkout link: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw convertGrpcError(error);
         }
     }
     /**
@@ -290,42 +429,301 @@ export class Scrawn {
      */
     async consumeEvent(payload, authMethodName, eventType) {
         const auth = this.authMethods.get(authMethodName);
-        if (!auth)
-            throw new Error(`No auth registered for type ${authMethodName}`);
+        if (!auth) {
+            throw new ScrawnConfigError(`No auth registered for type ${authMethodName}`, {
+                details: { requestedAuth: authMethodName },
+            });
+        }
         // Run pre-hook if exists
         if (auth.preRun)
             await auth.preRun();
         // Get creds (from cache or fresh)
         const creds = await this.getCredsFor(authMethodName);
         // Map event type to SDKCallType
-        const sdkCallType = eventType === 'SDK_CALL'
-            ? SDKCallType.RAW
-            : SDKCallType.MIDDLEWARE_CALL;
+        const sdkCallType = eventType === "SDK_CALL" ? SDKCallType.RAW : SDKCallType.MIDDLEWARE_CALL;
         try {
             log.info(`Ingesting event (type: ${eventType}) with creds: ${JSON.stringify(creds)}, payload: ${JSON.stringify(payload)}`);
+            // Build debit field based on which debit option is provided
+            let debitField;
+            if (payload.debitAmount !== undefined) {
+                debitField = { case: "amount", value: payload.debitAmount };
+            }
+            else if (payload.debitTag !== undefined) {
+                debitField = { case: "tag", value: payload.debitTag };
+            }
+            else {
+                // debitExpr is defined (validated by schema)
+                const serialized = serializeExpr(payload.debitExpr);
+                log.debug(`Serialized pricing expression: ${serialized}\n${prettyPrintExpr(payload.debitExpr)}`);
+                debitField = {
+                    case: "expr",
+                    value: serialized,
+                };
+            }
+            const sdkCall = new SDKCall();
+            sdkCall.setSdkcalltype(sdkCallType);
+            if (debitField.case === "amount") {
+                sdkCall.setAmount(debitField.value);
+            }
+            else if (debitField.case === "tag") {
+                sdkCall.setTag(debitField.value);
+            }
+            else {
+                sdkCall.setExpr(debitField.value);
+            }
+            const request = new RegisterEventRequest();
+            request.setType(EventType.SDK_CALL);
+            request.setUserid(payload.userId);
+            request.setSdkcall(sdkCall);
             const response = await this.grpcClient
-                .newCall(EventService, 'registerEvent')
-                .addHeader('Authorization', `Bearer ${creds.apiKey}`)
-                .addPayload({
-                type: EventType.SDK_CALL,
-                userId: payload.userId,
-                data: {
-                    case: 'sdkCall',
-                    value: new SDKCall({
-                        sdkCallType: sdkCallType,
-                        debitAmount: payload.debitAmount,
-                    }),
-                },
-            })
+                .newCall(EventServiceClient, "registerEvent")
+                .addMetadata("authorization", `Bearer ${creds.apiKey}`)
+                .addPayload(request)
                 .request();
             log.info(`Event registered successfully: ${JSON.stringify(response)}`);
         }
         catch (error) {
-            log.error(`Failed to register event: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            throw error;
+            log.error(`Failed to register event: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw convertGrpcError(error);
         }
         if (auth.postRun)
             await auth.postRun();
     }
+    /**
+     * Stream AI token usage events to the Scrawn backend.
+     *
+     * Consumes an async iterable of AI token usage payloads and streams them
+     * to the backend for billing tracking. This is designed for real-time
+     * AI token tracking where usage is reported as tokens are consumed.
+     *
+     * The streaming is non-blocking: the iterable is consumed in the background
+     * and streamed to the server without blocking the caller's code path.
+     *
+     * When `return: true`, the stream is forked internally - one fork goes to
+     * billing (non-blocking), and another is returned to the caller for streaming
+     * to the user.
+     *
+     * @param stream - An async iterable of AI token usage payloads
+     * @param config - Optional configuration object
+     * @param config.return - If true, returns a forked stream alongside the response promise
+     * @param config.onError - Optional callback for handling validation or gRPC errors
+     * @returns Depends on config.return:
+     *   - false/undefined: Promise<StreamEventResponse | undefined>
+     *   - true: { response: Promise<StreamEventResponse | undefined>, stream: AsyncIterable<AITokenUsagePayload> }
+     *
+     * @example
+     * ```typescript
+     * // Fire-and-forget mode (default)
+     * async function* tokenUsageStream() {
+     *   yield {
+     *     userId: 'user_abc123',
+     *     model: 'gpt-4',
+     *     inputTokens: 100,
+     *     outputTokens: 50,
+     *     inputDebit: { amount: 0.003 },
+     *     outputDebit: { amount: 0.006 }
+     *   };
+     * }
+     *
+     * const response = await scrawn.aiTokenStreamConsumer(tokenUsageStream());
+     * if (response) {
+     *   console.log(`Processed ${response.getEventsprocessed()} events`);
+     * }
+     *
+     * // Return mode - stream to user while billing
+     * const { response, stream } = await scrawn.aiTokenStreamConsumer(
+     *   tokenUsageStream(),
+     *   { return: true }
+     * );
+     *
+     * for await (const token of stream) {
+     *   // Stream to user
+     * }
+     *
+     * const result = await response;
+     * if (!result) return;
+     * ```
+     */
+    // fallow-ignore-next-line unused-class-member
+    async aiTokenStreamConsumer(stream, config) {
+        const onError = config?.onError;
+        // Get credentials for authentication
+        const creds = await this.getCredsFor("api");
+        // If return mode, fork the stream
+        if (config?.return === true) {
+            const [billingStream, userStream] = forkAsyncIterable(stream);
+            // Transform billing stream and send to backend (non-blocking)
+            const transformedStream = this.transformAITokenStream(billingStream, onError);
+            const responsePromise = (async () => {
+                try {
+                    log.info("Starting AI token usage stream (return mode)");
+                    const response = await this.grpcClient
+                        .newStreamCall(EventServiceClient, "streamEvents")
+                        .addMetadata("authorization", `Bearer ${creds.apiKey}`)
+                        .stream(transformedStream);
+                    log.info(`AI token stream completed: ${response.getEventsprocessed()} events processed`);
+                    return response;
+                }
+                catch (error) {
+                    log.error(`Failed to stream AI token usage: ${error instanceof Error ? error.message : "Unknown error"}`);
+                    this.notifyEventConsumerError(error, onError);
+                    return undefined;
+                }
+            })();
+            return { response: responsePromise, stream: userStream };
+        }
+        // Default: fire-and-forget mode
+        const transformedStream = this.transformAITokenStream(stream, onError);
+        try {
+            log.info("Starting AI token usage stream");
+            const response = await this.grpcClient
+                .newStreamCall(EventServiceClient, "streamEvents")
+                .addMetadata("authorization", `Bearer ${creds.apiKey}`)
+                .stream(transformedStream);
+            log.info(`AI token stream completed: ${response.getEventsprocessed()} events processed`);
+            return response;
+        }
+        catch (error) {
+            log.error(`Failed to stream AI token usage: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.notifyEventConsumerError(error, onError);
+            return undefined;
+        }
+    }
+    /**
+     * Transform user-provided AI token usage payloads into StreamEventRequest format.
+     *
+     * Validates each payload and maps it to the gRPC request format.
+     * Invalid payloads are logged and skipped.
+     *
+     * @param stream - The user's async iterable of AITokenUsagePayload
+     * @returns An async iterable of StreamEventRequest payloads
+     * @internal
+     */
+    async *transformAITokenStream(stream, onError) {
+        for await (const payload of stream) {
+            // Unwrap ScrawnExpr before Zod validation
+            const rawPayload = {
+                userId: payload.userId,
+                model: payload.model,
+                inputTokens: payload.inputTokens,
+                outputTokens: payload.outputTokens,
+                inputDebit: {
+                    amount: payload.inputDebit.amount,
+                    tag: payload.inputDebit.tag,
+                    expr: payload.inputDebit.expr?._expr,
+                },
+                outputDebit: {
+                    amount: payload.outputDebit.amount,
+                    tag: payload.outputDebit.tag,
+                    expr: payload.outputDebit.expr?._expr,
+                },
+            };
+            // Validate each payload
+            const validationResult = AITokenUsagePayloadSchema.safeParse(rawPayload);
+            if (!validationResult.success) {
+                const errors = validationResult.error.issues
+                    .map((e) => `${e.path.join(".")}: ${e.message}`)
+                    .join(", ");
+                log.error(`Invalid AI token usage payload, skipping: ${errors}`);
+                const error = new ScrawnValidationError("AI token usage payload validation failed", {
+                    details: {
+                        errors: validationResult.error.issues.map((e) => ({
+                            field: e.path.join("."),
+                            message: e.message,
+                        })),
+                    },
+                });
+                this.notifyValidationError(error, onError);
+                continue;
+            }
+            const validated = validationResult.data;
+            // Token context for resolving inputTokens()/outputTokens() placeholders
+            const tokenContext = {
+                inputTokens: validated.inputTokens,
+                outputTokens: validated.outputTokens,
+            };
+            // Build input debit field (amount, tag, or expr)
+            let inputDebit;
+            if (validated.inputDebit.amount !== undefined) {
+                inputDebit = {
+                    case: "inputAmount",
+                    value: validated.inputDebit.amount,
+                };
+            }
+            else if (validated.inputDebit.tag !== undefined) {
+                inputDebit = {
+                    case: "inputTag",
+                    value: validated.inputDebit.tag,
+                };
+            }
+            else {
+                const resolved = resolveTokens(validated.inputDebit.expr, tokenContext);
+                const serialized = serializeExpr(resolved);
+                log.debug(`Resolved input debit expression (inputTokens=${validated.inputTokens}): ${serialized}\n${prettyPrintExpr(resolved)}`);
+                inputDebit = {
+                    case: "inputExpr",
+                    value: serialized,
+                };
+            }
+            // Build output debit field (amount, tag, or expr)
+            let outputDebit;
+            if (validated.outputDebit.amount !== undefined) {
+                outputDebit = {
+                    case: "outputAmount",
+                    value: validated.outputDebit.amount,
+                };
+            }
+            else if (validated.outputDebit.tag !== undefined) {
+                outputDebit = {
+                    case: "outputTag",
+                    value: validated.outputDebit.tag,
+                };
+            }
+            else {
+                const resolved = resolveTokens(validated.outputDebit.expr, tokenContext);
+                const serialized = serializeExpr(resolved);
+                log.debug(`Resolved output debit expression (outputTokens=${validated.outputTokens}): ${serialized}\n${prettyPrintExpr(resolved)}`);
+                outputDebit = {
+                    case: "outputExpr",
+                    value: serialized,
+                };
+            }
+            const aiTokenUsage = new AITokenUsage();
+            aiTokenUsage.setModel(validated.model);
+            aiTokenUsage.setInputtokens(validated.inputTokens);
+            aiTokenUsage.setOutputtokens(validated.outputTokens);
+            if (inputDebit.case === "inputAmount") {
+                aiTokenUsage.setInputamount(inputDebit.value);
+            }
+            else if (inputDebit.case === "inputTag") {
+                aiTokenUsage.setInputtag(inputDebit.value);
+            }
+            else {
+                aiTokenUsage.setInputexpr(inputDebit.value);
+            }
+            if (outputDebit.case === "outputAmount") {
+                aiTokenUsage.setOutputamount(outputDebit.value);
+            }
+            else if (outputDebit.case === "outputTag") {
+                aiTokenUsage.setOutputtag(outputDebit.value);
+            }
+            else {
+                aiTokenUsage.setOutputexpr(outputDebit.value);
+            }
+            const request = new StreamEventRequest();
+            request.setType(EventType.AI_TOKEN_USAGE);
+            request.setUserid(validated.userId);
+            request.setAitokenusage(aiTokenUsage);
+            yield request;
+        }
+    }
+}
+export function createScrawn(config) {
+    return new Scrawn({
+        apiKey: config.apiKey,
+        baseURL: config.baseURL,
+        secure: config.secure,
+        credentials: config.credentials,
+    });
 }
 //# sourceMappingURL=scrawn.js.map