@scrawn/core 0.0.2 → 0.0.6

package/dist/gen/event/v1/event_grpc_pb.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceClientConstructor } from "@grpc/grpc-js";
+
+export const EventServiceClient: ServiceClientConstructor;

package/dist/gen/event/v1/event_grpc_pb.js

@@ -0,0 +1,79 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var event_v1_event_pb = require('../../event/v1/event_pb.js');
+
+function serialize_event_v1_RegisterEventRequest(arg) {
+  if (!(arg instanceof event_v1_event_pb.RegisterEventRequest)) {
+    throw new Error('Expected argument of type event.v1.RegisterEventRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_event_v1_RegisterEventRequest(buffer_arg) {
+  return event_v1_event_pb.RegisterEventRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_event_v1_RegisterEventResponse(arg) {
+  if (!(arg instanceof event_v1_event_pb.RegisterEventResponse)) {
+    throw new Error('Expected argument of type event.v1.RegisterEventResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_event_v1_RegisterEventResponse(buffer_arg) {
+  return event_v1_event_pb.RegisterEventResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_event_v1_StreamEventRequest(arg) {
+  if (!(arg instanceof event_v1_event_pb.StreamEventRequest)) {
+    throw new Error('Expected argument of type event.v1.StreamEventRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_event_v1_StreamEventRequest(buffer_arg) {
+  return event_v1_event_pb.StreamEventRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_event_v1_StreamEventResponse(arg) {
+  if (!(arg instanceof event_v1_event_pb.StreamEventResponse)) {
+    throw new Error('Expected argument of type event.v1.StreamEventResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_event_v1_StreamEventResponse(buffer_arg) {
+  return event_v1_event_pb.StreamEventResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var EventServiceService = exports.EventServiceService = {
+  // RegisterEvent registers an event as being done by a user
+registerEvent: {
+    path: '/event.v1.EventService/RegisterEvent',
+    requestStream: false,
+    responseStream: false,
+    requestType: event_v1_event_pb.RegisterEventRequest,
+    responseType: event_v1_event_pb.RegisterEventResponse,
+    requestSerialize: serialize_event_v1_RegisterEventRequest,
+    requestDeserialize: deserialize_event_v1_RegisterEventRequest,
+    responseSerialize: serialize_event_v1_RegisterEventResponse,
+    responseDeserialize: deserialize_event_v1_RegisterEventResponse,
+  },
+  // StreamEvents streams events from client to server (e.g., AI token usage)
+streamEvents: {
+    path: '/event.v1.EventService/StreamEvents',
+    requestStream: true,
+    responseStream: false,
+    requestType: event_v1_event_pb.StreamEventRequest,
+    responseType: event_v1_event_pb.StreamEventResponse,
+    requestSerialize: serialize_event_v1_StreamEventRequest,
+    requestDeserialize: deserialize_event_v1_StreamEventRequest,
+    responseSerialize: serialize_event_v1_StreamEventResponse,
+    responseDeserialize: deserialize_event_v1_StreamEventResponse,
+  },
+};
+
+exports.EventServiceClient = grpc.makeGenericClientConstructor(EventServiceService, 'EventService');

package/dist/gen/event/v1/event_pb.d.ts

@@ -1,105 +1,278 @@
-import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
-import { Message, proto3 } from "@bufbuild/protobuf";
-/**
- * @generated from enum event.v1.EventType
- */
-export declare enum EventType {
-    /**
-     * @generated from enum value: EVENT_TYPE_UNSPECIFIED = 0;
-     */
-    EVENT_TYPE_UNSPECIFIED = 0,
-    /**
-     * @generated from enum value: SDK_CALL = 1;
-     */
-    SDK_CALL = 1
+// package: event.v1
+// file: event/v1/event.proto
+
+import * as jspb from "google-protobuf";
+
+export class RegisterEventRequest extends jspb.Message {
+  getType(): EventTypeMap[keyof EventTypeMap];
+  setType(value: EventTypeMap[keyof EventTypeMap]): void;
+
+  getUserid(): string;
+  setUserid(value: string): void;
+
+  getReportedtimestamp(): number;
+  setReportedtimestamp(value: number): void;
+
+  hasSdkcall(): boolean;
+  clearSdkcall(): void;
+  getSdkcall(): SDKCall | undefined;
+  setSdkcall(value?: SDKCall): void;
+
+  getDataCase(): RegisterEventRequest.DataCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RegisterEventRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RegisterEventRequest): RegisterEventRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RegisterEventRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RegisterEventRequest;
+  static deserializeBinaryFromReader(message: RegisterEventRequest, reader: jspb.BinaryReader): RegisterEventRequest;
 }
-/**
- * @generated from enum event.v1.SDKCallType
- */
-export declare enum SDKCallType {
-    /**
-     * @generated from enum value: SDKCallType_UNSPECIFIED = 0;
-     */
-    SDKCallType_UNSPECIFIED = 0,
-    /**
-     * @generated from enum value: RAW = 1;
-     */
-    RAW = 1,
-    /**
-     * @generated from enum value: MIDDLEWARE_CALL = 2;
-     */
-    MIDDLEWARE_CALL = 2
+
+export namespace RegisterEventRequest {
+  export type AsObject = {
+    type: EventTypeMap[keyof EventTypeMap],
+    userid: string,
+    reportedtimestamp: number,
+    sdkcall?: SDKCall.AsObject,
+  }
+
+  export enum DataCase {
+    DATA_NOT_SET = 0,
+    SDKCALL = 4,
+  }
 }
-/**
- * @generated from message event.v1.RegisterEventRequest
- */
-export declare class RegisterEventRequest extends Message<RegisterEventRequest> {
-    /**
-     * @generated from field: event.v1.EventType type = 1;
-     */
-    type: EventType;
-    /**
-     * @generated from field: string userId = 2;
-     */
-    userId: string;
-    /**
-     * @generated from oneof event.v1.RegisterEventRequest.data
-     */
-    data: {
-        /**
-         * @generated from field: event.v1.SDKCall sdkCall = 3;
-         */
-        value: SDKCall;
-        case: "sdkCall";
-    } | {
-        case: undefined;
-        value?: undefined;
-    };
-    constructor(data?: PartialMessage<RegisterEventRequest>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "event.v1.RegisterEventRequest";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterEventRequest;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterEventRequest;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterEventRequest;
-    static equals(a: RegisterEventRequest | PlainMessage<RegisterEventRequest> | undefined, b: RegisterEventRequest | PlainMessage<RegisterEventRequest> | undefined): boolean;
+
+export class SDKCall extends jspb.Message {
+  getSdkcalltype(): SDKCallTypeMap[keyof SDKCallTypeMap];
+  setSdkcalltype(value: SDKCallTypeMap[keyof SDKCallTypeMap]): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): number;
+  setAmount(value: number): void;
+
+  hasTag(): boolean;
+  clearTag(): void;
+  getTag(): string;
+  setTag(value: string): void;
+
+  hasExpr(): boolean;
+  clearExpr(): void;
+  getExpr(): string;
+  setExpr(value: string): void;
+
+  getDebitCase(): SDKCall.DebitCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SDKCall.AsObject;
+  static toObject(includeInstance: boolean, msg: SDKCall): SDKCall.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: SDKCall, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SDKCall;
+  static deserializeBinaryFromReader(message: SDKCall, reader: jspb.BinaryReader): SDKCall;
 }
-/**
- * @generated from message event.v1.SDKCall
- */
-export declare class SDKCall extends Message<SDKCall> {
-    /**
-     * @generated from field: event.v1.SDKCallType sdkCallType = 1;
-     */
-    sdkCallType: SDKCallType;
-    /**
-     * @generated from field: float debitAmount = 2;
-     */
-    debitAmount: number;
-    constructor(data?: PartialMessage<SDKCall>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "event.v1.SDKCall";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SDKCall;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SDKCall;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SDKCall;
-    static equals(a: SDKCall | PlainMessage<SDKCall> | undefined, b: SDKCall | PlainMessage<SDKCall> | undefined): boolean;
+
+export namespace SDKCall {
+  export type AsObject = {
+    sdkcalltype: SDKCallTypeMap[keyof SDKCallTypeMap],
+    amount: number,
+    tag: string,
+    expr: string,
+  }
+
+  export enum DebitCase {
+    DEBIT_NOT_SET = 0,
+    AMOUNT = 2,
+    TAG = 3,
+    EXPR = 4,
+  }
 }
-/**
- * @generated from message event.v1.RegisterEventResponse
- */
-export declare class RegisterEventResponse extends Message<RegisterEventResponse> {
-    /**
-     * @generated from field: string random = 1;
-     */
-    random: string;
-    constructor(data?: PartialMessage<RegisterEventResponse>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "event.v1.RegisterEventResponse";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterEventResponse;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterEventResponse;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterEventResponse;
-    static equals(a: RegisterEventResponse | PlainMessage<RegisterEventResponse> | undefined, b: RegisterEventResponse | PlainMessage<RegisterEventResponse> | undefined): boolean;
+
+export class RegisterEventResponse extends jspb.Message {
+  getRandom(): string;
+  setRandom(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RegisterEventResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RegisterEventResponse): RegisterEventResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RegisterEventResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RegisterEventResponse;
+  static deserializeBinaryFromReader(message: RegisterEventResponse, reader: jspb.BinaryReader): RegisterEventResponse;
 }
-//# sourceMappingURL=event_pb.d.ts.map
+
+export namespace RegisterEventResponse {
+  export type AsObject = {
+    random: string,
+  }
+}
+
+export class StreamEventRequest extends jspb.Message {
+  getType(): EventTypeMap[keyof EventTypeMap];
+  setType(value: EventTypeMap[keyof EventTypeMap]): void;
+
+  getUserid(): string;
+  setUserid(value: string): void;
+
+  getReportedtimestamp(): number;
+  setReportedtimestamp(value: number): void;
+
+  hasSdkcall(): boolean;
+  clearSdkcall(): void;
+  getSdkcall(): SDKCall | undefined;
+  setSdkcall(value?: SDKCall): void;
+
+  hasAitokenusage(): boolean;
+  clearAitokenusage(): void;
+  getAitokenusage(): AITokenUsage | undefined;
+  setAitokenusage(value?: AITokenUsage): void;
+
+  getDataCase(): StreamEventRequest.DataCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StreamEventRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StreamEventRequest): StreamEventRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: StreamEventRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StreamEventRequest;
+  static deserializeBinaryFromReader(message: StreamEventRequest, reader: jspb.BinaryReader): StreamEventRequest;
+}
+
+export namespace StreamEventRequest {
+  export type AsObject = {
+    type: EventTypeMap[keyof EventTypeMap],
+    userid: string,
+    reportedtimestamp: number,
+    sdkcall?: SDKCall.AsObject,
+    aitokenusage?: AITokenUsage.AsObject,
+  }
+
+  export enum DataCase {
+    DATA_NOT_SET = 0,
+    SDKCALL = 4,
+    AITOKENUSAGE = 5,
+  }
+}
+
+export class AITokenUsage extends jspb.Message {
+  getModel(): string;
+  setModel(value: string): void;
+
+  getInputtokens(): number;
+  setInputtokens(value: number): void;
+
+  getOutputtokens(): number;
+  setOutputtokens(value: number): void;
+
+  hasInputamount(): boolean;
+  clearInputamount(): void;
+  getInputamount(): number;
+  setInputamount(value: number): void;
+
+  hasInputtag(): boolean;
+  clearInputtag(): void;
+  getInputtag(): string;
+  setInputtag(value: string): void;
+
+  hasInputexpr(): boolean;
+  clearInputexpr(): void;
+  getInputexpr(): string;
+  setInputexpr(value: string): void;
+
+  hasOutputamount(): boolean;
+  clearOutputamount(): void;
+  getOutputamount(): number;
+  setOutputamount(value: number): void;
+
+  hasOutputtag(): boolean;
+  clearOutputtag(): void;
+  getOutputtag(): string;
+  setOutputtag(value: string): void;
+
+  hasOutputexpr(): boolean;
+  clearOutputexpr(): void;
+  getOutputexpr(): string;
+  setOutputexpr(value: string): void;
+
+  getInputdebitCase(): AITokenUsage.InputdebitCase;
+  getOutputdebitCase(): AITokenUsage.OutputdebitCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AITokenUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: AITokenUsage): AITokenUsage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: AITokenUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AITokenUsage;
+  static deserializeBinaryFromReader(message: AITokenUsage, reader: jspb.BinaryReader): AITokenUsage;
+}
+
+export namespace AITokenUsage {
+  export type AsObject = {
+    model: string,
+    inputtokens: number,
+    outputtokens: number,
+    inputamount: number,
+    inputtag: string,
+    inputexpr: string,
+    outputamount: number,
+    outputtag: string,
+    outputexpr: string,
+  }
+
+  export enum InputdebitCase {
+    INPUTDEBIT_NOT_SET = 0,
+    INPUTAMOUNT = 4,
+    INPUTTAG = 5,
+    INPUTEXPR = 8,
+  }
+
+  export enum OutputdebitCase {
+    OUTPUTDEBIT_NOT_SET = 0,
+    OUTPUTAMOUNT = 6,
+    OUTPUTTAG = 7,
+    OUTPUTEXPR = 9,
+  }
+}
+
+export class StreamEventResponse extends jspb.Message {
+  getEventsprocessed(): number;
+  setEventsprocessed(value: number): void;
+
+  getMessage(): string;
+  setMessage(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StreamEventResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StreamEventResponse): StreamEventResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: StreamEventResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StreamEventResponse;
+  static deserializeBinaryFromReader(message: StreamEventResponse, reader: jspb.BinaryReader): StreamEventResponse;
+}
+
+export namespace StreamEventResponse {
+  export type AsObject = {
+    eventsprocessed: number,
+    message: string,
+  }
+}
+
+export interface EventTypeMap {
+  EVENT_TYPE_UNSPECIFIED: 0;
+  SDK_CALL: 1;
+  AI_TOKEN_USAGE: 2;
+}
+
+export const EventType: EventTypeMap;
+
+export interface SDKCallTypeMap {
+  SDKCALLTYPE_UNSPECIFIED: 0;
+  RAW: 1;
+  MIDDLEWARE_CALL: 2;
+}
+
+export const SDKCallType: SDKCallTypeMap;
+