@eventmodelers/node-kit 0.0.2

package/templates/realtime-agent/node_modules/@supabase/functions-js/src/FunctionsClient.ts

@@ -0,0 +1,335 @@
+import { resolveFetch } from './helper'
+import {
+  Fetch,
+  FunctionInvokeOptions,
+  FunctionRegion,
+  FunctionsFetchError,
+  FunctionsHttpError,
+  FunctionsRelayError,
+  FunctionsResponse,
+} from './types'
+
+/**
+ * Client for invoking Supabase Edge Functions.
+ */
+export class FunctionsClient {
+  protected url: string
+  protected headers: Record<string, string>
+  protected region: FunctionRegion
+  protected fetch: Fetch
+
+  /**
+   * Creates a new Functions client bound to an Edge Functions URL.
+   *
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   * const { data, error } = await supabase.functions.invoke('hello-world')
+   * ```
+   *
+   * @category Edge Functions
+   *
+   * @example Standalone import for bundle-sensitive environments
+   * ```ts
+   * import { FunctionsClient, FunctionRegion } from '@supabase/functions-js'
+   *
+   * const functions = new FunctionsClient('https://xyzcompany.supabase.co/functions/v1', {
+   *   headers: { apikey: 'your-publishable-key' },
+   *   region: FunctionRegion.UsEast1,
+   * })
+   * ```
+   */
+  constructor(
+    url: string,
+    {
+      headers = {},
+      customFetch,
+      region = FunctionRegion.Any,
+    }: {
+      headers?: Record<string, string>
+      customFetch?: Fetch
+      region?: FunctionRegion
+    } = {}
+  ) {
+    this.url = url
+    this.headers = headers
+    this.region = region
+    this.fetch = resolveFetch(customFetch)
+  }
+
+  /**
+   * Updates the authorization header
+   * @param token - the new jwt token sent in the authorisation header
+   *
+   * @category Edge Functions
+   *
+   * @example Setting the authorization header
+   * ```ts
+   * functions.setAuth(session.access_token)
+   * ```
+   */
+  setAuth(token: string) {
+    this.headers.Authorization = `Bearer ${token}`
+  }
+
+  /**
+   * Invokes a function
+   * @param functionName - The name of the Function to invoke.
+   * @param options - Options for invoking the Function.
+   * @example
+   * ```ts
+   * const { data, error } = await functions.invoke('hello-world', {
+   *   body: { name: 'Ada' },
+   * })
+   * ```
+   *
+   * @category Edge Functions
+   *
+   * @remarks
+   * - Requires an Authorization header.
+   * - Invoke params generally match the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) spec.
+   * - When you pass in a body to your function, we automatically attach the Content-Type header for `Blob`, `ArrayBuffer`, `File`, `FormData` and `String`. If it doesn't match any of these types we assume the payload is `json`, serialize it and attach the `Content-Type` header as `application/json`. You can override this behavior by passing in a `Content-Type` header of your own.
+   * - Responses are automatically parsed as `json`, `blob` and `form-data` depending on the `Content-Type` header sent by your function. Responses are parsed as `text` by default.
+   *
+   * @example Basic invocation
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   body: { foo: 'bar' }
+   * })
+   * ```
+   *
+   * @exampleDescription Error handling
+   * A `FunctionsHttpError` error is returned if your function throws an error, `FunctionsRelayError` if the Supabase Relay has an error processing your function and `FunctionsFetchError` if there is a network error in calling your function.
+   *
+   * @example Error handling
+   * ```js
+   * import { FunctionsHttpError, FunctionsRelayError, FunctionsFetchError } from "@supabase/supabase-js";
+   *
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' }
+   * })
+   *
+   * if (error instanceof FunctionsHttpError) {
+   *   const errorMessage = await error.context.json()
+   *   console.log('Function returned an error', errorMessage)
+   * } else if (error instanceof FunctionsRelayError) {
+   *   console.log('Relay error:', error.message)
+   * } else if (error instanceof FunctionsFetchError) {
+   *   console.log('Fetch error:', error.message)
+   * }
+   * ```
+   *
+   * @exampleDescription Passing custom headers
+   * You can pass custom headers to your function. Note: supabase-js automatically passes the `Authorization` header with the signed in user's JWT.
+   *
+   * @example Passing custom headers
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' }
+   * })
+   * ```
+   *
+   * @exampleDescription Calling with DELETE HTTP verb
+   * You can also set the HTTP verb to `DELETE` when calling your Edge Function.
+   *
+   * @example Calling with DELETE HTTP verb
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' },
+   *   method: 'DELETE'
+   * })
+   * ```
+   *
+   * @exampleDescription Invoking a Function in the UsEast1 region
+   * Here are the available regions:
+   * - `FunctionRegion.Any`
+   * - `FunctionRegion.ApNortheast1`
+   * - `FunctionRegion.ApNortheast2`
+   * - `FunctionRegion.ApSouth1`
+   * - `FunctionRegion.ApSoutheast1`
+   * - `FunctionRegion.ApSoutheast2`
+   * - `FunctionRegion.CaCentral1`
+   * - `FunctionRegion.EuCentral1`
+   * - `FunctionRegion.EuWest1`
+   * - `FunctionRegion.EuWest2`
+   * - `FunctionRegion.EuWest3`
+   * - `FunctionRegion.SaEast1`
+   * - `FunctionRegion.UsEast1`
+   * - `FunctionRegion.UsWest1`
+   * - `FunctionRegion.UsWest2`
+   *
+   * @example Invoking a Function in the UsEast1 region
+   * ```js
+   * import { createClient, FunctionRegion } from '@supabase/supabase-js'
+   *
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   body: { foo: 'bar' },
+   *   region: FunctionRegion.UsEast1
+   * })
+   * ```
+   *
+   * @exampleDescription Calling with GET HTTP verb
+   * You can also set the HTTP verb to `GET` when calling your Edge Function.
+   *
+   * @example Calling with GET HTTP verb
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   method: 'GET'
+   * })
+   * ```
+   *
+   * @example Standalone client invoke
+   * ```ts
+   * const { data, error } = await functions.invoke('hello-world', {
+   *   body: { name: 'Ada' },
+   * })
+   * ```
+   */
+  async invoke<T = any>(
+    functionName: string,
+    options: FunctionInvokeOptions = {}
+  ): Promise<FunctionsResponse<T>> {
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+    let timeoutController: AbortController | undefined
+
+    try {
+      const { headers, method, body: functionArgs, signal, timeout } = options
+      let _headers: Record<string, string> = {}
+      let { region } = options
+      if (!region) {
+        region = this.region
+      }
+      // Add region as query parameter using URL API
+      const url = new URL(`${this.url}/${functionName}`)
+      if (region && region !== 'any') {
+        _headers['x-region'] = region
+        url.searchParams.set('forceFunctionRegion', region)
+      }
+      let body: any
+      if (
+        functionArgs &&
+        ((headers && !Object.prototype.hasOwnProperty.call(headers, 'Content-Type')) || !headers)
+      ) {
+        if (
+          (typeof Blob !== 'undefined' && functionArgs instanceof Blob) ||
+          functionArgs instanceof ArrayBuffer
+        ) {
+          // will work for File as File inherits Blob
+          // also works for ArrayBuffer as it is the same underlying structure as a Blob
+          _headers['Content-Type'] = 'application/octet-stream'
+          body = functionArgs
+        } else if (typeof functionArgs === 'string') {
+          // plain string
+          _headers['Content-Type'] = 'text/plain'
+          body = functionArgs
+        } else if (typeof FormData !== 'undefined' && functionArgs instanceof FormData) {
+          // don't set content-type headers
+          // Request will automatically add the right boundary value
+          body = functionArgs
+        } else {
+          // default, assume this is JSON
+          _headers['Content-Type'] = 'application/json'
+          body = JSON.stringify(functionArgs)
+        }
+      } else {
+        if (
+          functionArgs &&
+          typeof functionArgs !== 'string' &&
+          !(typeof Blob !== 'undefined' && functionArgs instanceof Blob) &&
+          !(functionArgs instanceof ArrayBuffer) &&
+          !(typeof FormData !== 'undefined' && functionArgs instanceof FormData)
+        ) {
+          body = JSON.stringify(functionArgs)
+        } else {
+          body = functionArgs
+        }
+      }
+
+      // Handle timeout by creating an AbortController
+      let effectiveSignal = signal
+      if (timeout) {
+        timeoutController = new AbortController()
+        timeoutId = setTimeout(() => timeoutController!.abort(), timeout)
+
+        // If user provided their own signal, we need to respect both
+        if (signal) {
+          effectiveSignal = timeoutController.signal
+          // If the user's signal is aborted, abort our timeout controller too
+          signal.addEventListener('abort', () => timeoutController!.abort())
+        } else {
+          effectiveSignal = timeoutController.signal
+        }
+      }
+
+      const response = await this.fetch(url.toString(), {
+        method: method || 'POST',
+        // headers priority is (high to low):
+        // 1. invoke-level headers
+        // 2. client-level headers
+        // 3. default Content-Type header
+        headers: { ..._headers, ...this.headers, ...headers },
+        body,
+        signal: effectiveSignal,
+      }).catch((fetchError) => {
+        throw new FunctionsFetchError(fetchError)
+      })
+
+      const isRelayError = response.headers.get('x-relay-error')
+      if (isRelayError && isRelayError === 'true') {
+        throw new FunctionsRelayError(response)
+      }
+
+      if (!response.ok) {
+        throw new FunctionsHttpError(response)
+      }
+
+      let responseType = (response.headers.get('Content-Type') ?? 'text/plain').split(';')[0].trim()
+      let data: any
+      if (responseType === 'application/json') {
+        data = await response.json()
+      } else if (
+        responseType === 'application/octet-stream' ||
+        responseType === 'application/pdf'
+      ) {
+        data = await response.blob()
+      } else if (responseType === 'text/event-stream') {
+        data = response
+      } else if (responseType === 'multipart/form-data') {
+        data = await response.formData()
+      } else {
+        // default to text
+        data = await response.text()
+      }
+
+      return { data, error: null, response }
+    } catch (error) {
+      return {
+        data: null,
+        error,
+        response:
+          error instanceof FunctionsHttpError || error instanceof FunctionsRelayError
+            ? error.context
+            : undefined,
+      }
+    } finally {
+      // Clear the timeout if it was set
+      if (timeoutId) {
+        clearTimeout(timeoutId)
+      }
+    }
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/functions-js/src/edge-runtime.d.ts

@@ -0,0 +1,214 @@
+declare type BeforeunloadReason =
+  | 'cpu'
+  | 'memory'
+  | 'wall_clock'
+  | 'early_drop'
+  | 'termination'
+  | (string & {})
+
+declare interface WindowEventMap {
+  load: Event
+  unload: Event
+  beforeunload: CustomEvent<BeforeunloadReason>
+  drain: Event
+}
+
+// TODO(Nyannyacha): These two type defs will be provided later.
+
+// deno-lint-ignore no-explicit-any
+type S3FsConfig = any
+
+// deno-lint-ignore no-explicit-any
+type TmpFsConfig = any
+
+type OtelPropagators = 'TraceContext' | 'Baggage'
+type OtelConsoleConfig = 'Ignore' | 'Capture' | 'Replace'
+type OtelConfig = {
+  tracing_enabled?: boolean
+  metrics_enabled?: boolean
+  console?: OtelConsoleConfig
+  propagators?: OtelPropagators[]
+}
+
+interface UserWorkerFetchOptions {
+  signal?: AbortSignal
+}
+
+interface PermissionsOptions {
+  allow_all?: boolean | null
+  allow_env?: string[] | null
+  deny_env?: string[] | null
+  allow_net?: string[] | null
+  deny_net?: string[] | null
+  allow_ffi?: string[] | null
+  deny_ffi?: string[] | null
+  allow_read?: string[] | null
+  deny_read?: string[] | null
+  allow_run?: string[] | null
+  deny_run?: string[] | null
+  allow_sys?: string[] | null
+  deny_sys?: string[] | null
+  allow_write?: string[] | null
+  deny_write?: string[] | null
+  allow_import?: string[] | null
+}
+
+interface UserWorkerCreateContext {
+  sourceMap?: boolean | null
+  importMapPath?: string | null
+  shouldBootstrapMockFnThrowError?: boolean | null
+  suppressEszipMigrationWarning?: boolean | null
+  useReadSyncFileAPI?: boolean | null
+  supervisor?: {
+    requestAbsentTimeoutMs?: number | null
+  }
+  otel?: {
+    [attribute: string]: string
+  }
+}
+
+interface UserWorkerCreateOptions {
+  servicePath?: string | null
+  envVars?: string[][] | [string, string][] | null
+  noModuleCache?: boolean | null
+
+  forceCreate?: boolean | null
+  allowRemoteModules?: boolean | null
+  customModuleRoot?: string | null
+  permissions?: PermissionsOptions | null
+
+  maybeEszip?: Uint8Array | null
+  maybeEntrypoint?: string | null
+  maybeModuleCode?: string | null
+
+  memoryLimitMb?: number | null
+  lowMemoryMultiplier?: number | null
+  workerTimeoutMs?: number | null
+  cpuTimeSoftLimitMs?: number | null
+  cpuTimeHardLimitMs?: number | null
+  staticPatterns?: string[] | null
+
+  s3FsConfig?: S3FsConfig | null
+  tmpFsConfig?: TmpFsConfig | null
+  otelConfig?: OtelConfig | null
+
+  context?: UserWorkerCreateContext | null
+}
+
+interface HeapStatistics {
+  totalHeapSize: number
+  totalHeapSizeExecutable: number
+  totalPhysicalSize: number
+  totalAvailableSize: number
+  totalGlobalHandlesSize: number
+  usedGlobalHandlesSize: number
+  usedHeapSize: number
+  mallocedMemory: number
+  externalMemory: number
+  peakMallocedMemory: number
+}
+
+interface RuntimeMetrics {
+  mainWorkerHeapStats: HeapStatistics
+  eventWorkerHeapStats?: HeapStatistics
+}
+
+interface MemInfo {
+  total: number
+  free: number
+  available: number
+  buffers: number
+  cached: number
+  swapTotal: number
+  swapFree: number
+}
+
+declare namespace EdgeRuntime {
+  export namespace ai {
+    function tryCleanupUnusedSession(): Promise<number>
+  }
+
+  class UserWorker {
+    constructor(key: string)
+
+    fetch(request: Request, options?: UserWorkerFetchOptions): Promise<Response>
+
+    static create(opts: UserWorkerCreateOptions): Promise<UserWorker>
+    static tryCleanupIdleWorkers(timeoutMs: number): Promise<number>
+  }
+
+  export function scheduleTermination(): void
+  export function waitUntil<T>(promise: Promise<T>): Promise<T>
+  export function getRuntimeMetrics(): Promise<RuntimeMetrics>
+  export function applySupabaseTag(src: Request, dest: Request): void
+  export function systemMemoryInfo(): MemInfo
+  export function raiseSegfault(): void
+
+  export { UserWorker as userWorkers }
+}
+
+declare namespace Supabase {
+  export namespace ai {
+    interface ModelOptions {
+      /**
+       * Pool embeddings by taking their mean. Applies only for `gte-small` model
+       */
+      mean_pool?: boolean
+
+      /**
+       * Normalize the embeddings result. Applies only for `gte-small` model
+       */
+      normalize?: boolean
+
+      /**
+       * Stream response from model. Applies only for LLMs like `mistral` (default: false)
+       */
+      stream?: boolean
+
+      /**
+       * Automatically abort the request to the model after specified time (in seconds). Applies only for LLMs like `mistral` (default: 60)
+       */
+      timeout?: number
+
+      /**
+       * Mode for the inference API host. (default: 'ollama')
+       */
+      mode?: 'ollama' | 'openaicompatible'
+      signal?: AbortSignal
+    }
+
+    export class Session {
+      /**
+       * Create a new model session using given model
+       */
+      constructor(model: string)
+
+      /**
+       * Execute the given prompt in model session
+       */
+      run(
+        prompt:
+          | string
+          | Omit<import('openai').OpenAI.Chat.ChatCompletionCreateParams, 'model' | 'stream'>,
+        modelOptions?: ModelOptions
+      ): unknown
+    }
+  }
+}
+
+declare namespace Deno {
+  export namespace errors {
+    class WorkerRequestCancelled extends Error {}
+    class WorkerAlreadyRetired extends Error {}
+
+    /** Thrown when an outbound HTTP request is blocked by the rate limiter. */
+    class RateLimitError extends Error {
+      /**
+       * Number of milliseconds until the rate-limit window resets.
+       * `null` if the reset time could not be determined.
+       */
+      retryAfterMs: number | null
+      constructor(message: string, retryAfterMs?: number)
+    }
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/functions-js/src/helper.ts

@@ -0,0 +1,8 @@
+import { Fetch } from './types'
+
+export const resolveFetch = (customFetch?: Fetch): Fetch => {
+  if (customFetch) {
+    return (...args) => customFetch(...args)
+  }
+  return (...args) => fetch(...args)
+}

package/templates/realtime-agent/node_modules/@supabase/functions-js/src/index.ts

@@ -0,0 +1,10 @@
+export { FunctionsClient } from './FunctionsClient'
+export {
+  type FunctionInvokeOptions,
+  FunctionsError,
+  FunctionsFetchError,
+  FunctionsHttpError,
+  FunctionsRelayError,
+  FunctionRegion,
+  type FunctionsResponse,
+} from './types'

package/templates/realtime-agent/node_modules/@supabase/functions-js/src/types.ts

@@ -0,0 +1,146 @@
+export type Fetch = typeof fetch
+
+/**
+ * Response format
+ */
+export interface FunctionsResponseSuccess<T> {
+  data: T
+  error: null
+  response?: Response
+}
+export interface FunctionsResponseFailure {
+  data: null
+  error: any
+  response?: Response
+}
+export type FunctionsResponse<T> = FunctionsResponseSuccess<T> | FunctionsResponseFailure
+
+/**
+ * Base error for Supabase Edge Function invocations.
+ *
+ * @example
+ * ```ts
+ * import { FunctionsError } from '@supabase/functions-js'
+ *
+ * throw new FunctionsError('Unexpected error invoking function', 'FunctionsError', {
+ *   requestId: 'abc123',
+ * })
+ * ```
+ */
+export class FunctionsError extends Error {
+  context: any
+  constructor(message: string, name = 'FunctionsError', context?: any) {
+    super(message)
+    this.name = name
+    this.context = context
+  }
+
+  toJSON(): { name: string; message: string; context: any } {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context,
+    }
+  }
+}
+
+/**
+ * Error thrown when the network request to an Edge Function fails.
+ *
+ * @example
+ * ```ts
+ * import { FunctionsFetchError } from '@supabase/functions-js'
+ *
+ * throw new FunctionsFetchError({ requestId: 'abc123' })
+ * ```
+ */
+export class FunctionsFetchError extends FunctionsError {
+  constructor(context: any) {
+    super('Failed to send a request to the Edge Function', 'FunctionsFetchError', context)
+  }
+}
+
+/**
+ * Error thrown when the Supabase relay cannot reach the Edge Function.
+ *
+ * @example
+ * ```ts
+ * import { FunctionsRelayError } from '@supabase/functions-js'
+ *
+ * throw new FunctionsRelayError({ region: 'us-east-1' })
+ * ```
+ */
+export class FunctionsRelayError extends FunctionsError {
+  constructor(context: any) {
+    super('Relay Error invoking the Edge Function', 'FunctionsRelayError', context)
+  }
+}
+
+/**
+ * Error thrown when the Edge Function returns a non-2xx status code.
+ *
+ * @example
+ * ```ts
+ * import { FunctionsHttpError } from '@supabase/functions-js'
+ *
+ * throw new FunctionsHttpError({ status: 500 })
+ * ```
+ */
+export class FunctionsHttpError extends FunctionsError {
+  constructor(context: any) {
+    super('Edge Function returned a non-2xx status code', 'FunctionsHttpError', context)
+  }
+}
+// Define the enum for the 'region' property
+export enum FunctionRegion {
+  Any = 'any',
+  ApNortheast1 = 'ap-northeast-1',
+  ApNortheast2 = 'ap-northeast-2',
+  ApSouth1 = 'ap-south-1',
+  ApSoutheast1 = 'ap-southeast-1',
+  ApSoutheast2 = 'ap-southeast-2',
+  CaCentral1 = 'ca-central-1',
+  EuCentral1 = 'eu-central-1',
+  EuWest1 = 'eu-west-1',
+  EuWest2 = 'eu-west-2',
+  EuWest3 = 'eu-west-3',
+  SaEast1 = 'sa-east-1',
+  UsEast1 = 'us-east-1',
+  UsWest1 = 'us-west-1',
+  UsWest2 = 'us-west-2',
+}
+
+export type FunctionInvokeOptions = {
+  /**
+   * Object representing the headers to send with the request.
+   */
+  headers?: { [key: string]: string }
+  /**
+   * The HTTP verb of the request
+   */
+  method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE'
+  /**
+   * The Region to invoke the function in.
+   */
+  region?: FunctionRegion
+  /**
+   * The body of the request.
+   */
+  body?:
+    | File
+    | Blob
+    | ArrayBuffer
+    | FormData
+    | ReadableStream<Uint8Array>
+    | Record<string, any>
+    | string
+  /**
+   * The AbortSignal to use for the request.
+   * */
+  signal?: AbortSignal
+  /**
+   * The timeout for the request in milliseconds.
+   * If the function takes longer than this, the request will be aborted.
+   * */
+  timeout?: number
+}