sonamu 0.6.0 → 0.7.0

package/src/ai/agents/types.ts

@@ -0,0 +1,47 @@
+import type { ProviderOptions, Schema, Tool } from "@ai-sdk/provider-utils";
+import type { LanguageModel, StopCondition, ToolSet } from "ai";
+
+export type ToolChoiceLimited = "auto" | "none" | "required";
+
+export interface ToolDecoratorSchema<INPUT, OUTPUT = unknown> {
+  input: Schema<INPUT>;
+  output?: Schema<OUTPUT>;
+}
+
+export interface ToolDecoratorOptions<INPUT, OUTPUT = unknown> {
+  name?: string;
+  description?: string;
+  schema: ToolDecoratorSchema<INPUT, OUTPUT>;
+  needsApproval?: Tool<INPUT, OUTPUT>["needsApproval"];
+  toModelOutput?: Tool<INPUT, OUTPUT>["toModelOutput"];
+  providerOptions?: ProviderOptions;
+}
+
+export type RegisteredToolDefinition = {
+  name: string;
+  description?: string;
+  schema: ToolDecoratorSchema<unknown, unknown>;
+  needsApproval?: Tool["needsApproval"];
+  toModelOutput?: Tool["toModelOutput"];
+  providerOptions?: ProviderOptions;
+  method: (...args: unknown[]) => unknown;
+  from: string;
+};
+
+export interface AgentConfig {
+  model: LanguageModel;
+  instructions?: string;
+  toolChoice?: ToolChoiceLimited;
+  providerOptions?: ProviderOptions;
+  stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>;
+  activeTools?: Array<string>;
+  maxOutputTokens?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  stopSequences?: string[];
+  seed?: number;
+  headers?: Record<string, string | undefined>;
+}

package/src/ai/index.ts

@@ -0,0 +1 @@
+export * from "./agents";

package/src/ai/providers/rtzr/api.ts

@@ -0,0 +1,37 @@
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+
+export const rtzrAuthResponseSchema = z.object({
+  access_token: z.string(),
+  expire_at: z.number(),
+});
+
+export const rtzrTranscriptionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+    }),
+  ),
+);
+
+export const rtzrTranscriptionResultResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      status: z.enum(["transcribing", "completed", "failed"]),
+      results: z
+        .object({
+          utterances: z.array(
+            z.object({
+              start_at: z.number(),
+              duration: z.number(),
+              msg: z.string(),
+              spk: z.number(),
+              lang: z.string().optional(),
+            }),
+          ),
+        })
+        .nullish(),
+    }),
+  ),
+);

package/src/ai/providers/rtzr/error.ts

@@ -0,0 +1,34 @@
+import { AISDKError } from "@ai-sdk/provider";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+
+export const rtzrErrorDataSchema = z.object({
+  error: z.object({
+    msg: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish(),
+  }),
+});
+
+export type RtzrErrorData = z.infer<typeof rtzrErrorDataSchema>;
+
+export const rtzrFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: rtzrErrorDataSchema,
+  errorToMessage: (data) => data.error.msg,
+});
+
+export class RtzrClientError extends AISDKError {
+  constructor(
+    message: string,
+    options?: {
+      cause?: Error;
+    },
+  ) {
+    super({
+      name: "RtzrClientError",
+      message,
+      cause: options?.cause,
+    });
+  }
+}

package/src/ai/providers/rtzr/index.ts

@@ -0,0 +1,4 @@
+export * from "./error";
+export * from "./model";
+export * from "./options";
+export * from "./provider";

package/src/ai/providers/rtzr/model.ts

@@ -0,0 +1,201 @@
+import type {
+  SharedV3Warning,
+  TranscriptionModelV3,
+  TranscriptionModelV3CallOptions,
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  type FetchFunction,
+  getFromApi,
+  mediaTypeToExtension,
+  parseProviderOptions,
+  postFormDataToApi,
+} from "@ai-sdk/provider-utils";
+import { isEmpty } from "radashi";
+import {
+  rtzrAuthResponseSchema,
+  rtzrTranscriptionResponseSchema,
+  rtzrTranscriptionResultResponseSchema,
+} from "./api";
+import { RtzrClientError, rtzrFailedResponseHandler } from "./error";
+import {
+  type RtzrTranscriptionModelId,
+  type RtzrTranscriptionProviderOptions,
+  rtzrTranscriptionProviderOptions,
+} from "./options";
+
+export type RtzrTranscriptionCallOptions = Omit<
+  TranscriptionModelV3CallOptions,
+  "providerOptions"
+> & {
+  providerOptions?: {
+    rtzr?: RtzrTranscriptionProviderOptions;
+  };
+};
+
+interface RtzrTranscriptionModelConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+  provider: string;
+  auth: {
+    clientId: string;
+    clientSecret: string;
+  };
+  url: (options: { path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+}
+
+export class RtzrTranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion = "v3";
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: RtzrTranscriptionModelId,
+    private readonly config: RtzrTranscriptionModelConfig,
+  ) {}
+
+  private async authorize() {
+    const fetchApi = this.config.fetch ?? fetch;
+    const response = await fetchApi(
+      this.config.url({
+        path: "/authenticate",
+      }),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: new URLSearchParams({
+          client_id: this.config.auth.clientId,
+          client_secret: this.config.auth.clientSecret,
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      throw new RtzrClientError(`Failed to authorize: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const parsedData = rtzrAuthResponseSchema.safeParse(data);
+    if (!parsedData.success) {
+      throw new RtzrClientError(`Validation failed: ${parsedData.error.message}`);
+    }
+
+    return parsedData.data.access_token;
+  }
+
+  private async getArgs({ audio, mediaType, providerOptions }: RtzrTranscriptionCallOptions) {
+    const warnings: SharedV3Warning[] = [];
+    const rtzrOptions = await parseProviderOptions({
+      provider: "rtzr",
+      providerOptions,
+      schema: rtzrTranscriptionProviderOptions,
+    });
+
+    const blob =
+      audio instanceof Uint8Array
+        ? new Blob([new Uint8Array(audio)])
+        : new Blob([convertBase64ToUint8Array(audio)]);
+
+    const formData = new FormData();
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append(
+      "file",
+      new File([blob], "audio", { type: mediaType }),
+      `audio.${fileExtension}`,
+    );
+
+    const config = { model_name: this.modelId, ...rtzrOptions };
+    formData.append("config", JSON.stringify(config));
+
+    return { formData, warnings };
+  }
+
+  async doGenerate(options: RtzrTranscriptionCallOptions) {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    const accessToken = await this.authorize();
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      ...options.headers,
+    };
+
+    const { formData, warnings } = await this.getArgs(options);
+    const {
+      value: { id: transcriptionId },
+      responseHeaders,
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/transcribe",
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      formData,
+      failedResponseHandler: rtzrFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(rtzrTranscriptionResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const { value: response, rawValue } = await (async () => {
+      // transcription이 끝날 떄까지 0.5초마다 체크.
+      // timeout을 따로 지정하지 않는 이유는 애초에 AbortSignal을 사용하고 있음.
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const data = await getFromApi({
+          url: this.config.url({
+            path: `/transcribe/${transcriptionId}`,
+          }),
+          headers: combineHeaders(this.config.headers(), headers),
+          failedResponseHandler: rtzrFailedResponseHandler,
+          successfulResponseHandler: createJsonResponseHandler(
+            rtzrTranscriptionResultResponseSchema,
+          ),
+          abortSignal: options.abortSignal,
+          fetch: this.config.fetch,
+        });
+
+        if (data.value.status !== "transcribing") {
+          return data;
+        }
+      }
+    })();
+
+    const segments = response.results?.utterances ?? [];
+
+    const languages = new Set(segments.map((item) => item.lang).filter((item) => !isEmpty(item)));
+    const language = (() => {
+      if (languages.size > 1) {
+        return undefined;
+      }
+
+      return languages.values().next().value;
+    })();
+
+    return {
+      text: segments.map((item) => item.msg).join("\n"),
+      segments: segments.map((segment) => ({
+        text: segment.msg,
+        startSecond: Math.trunc(segment.start_at / 1000),
+        endSecond: Math.trunc((segment.start_at + segment.duration) / 1000),
+      })),
+      language,
+      warnings,
+      durationInSeconds: segments.reduce((acc, segment) => acc + segment.duration, 0) ?? undefined,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawValue,
+      },
+    };
+  }
+}

package/src/ai/providers/rtzr/options.ts

@@ -0,0 +1,49 @@
+import { type InferSchema, lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+
+export type RtzrTranscriptionModelId = "whisper" | "sommers" | (string & {});
+
+const rtzrOptionsShape = {
+  domain: z.enum(["CALL", "GENERAL"]).default("GENERAL"),
+  language: z.string(),
+  languageCandidates: z.array(z.string()).optional(),
+  keywords: z.union([z.string(), z.array(z.string())]).optional(),
+  paragraphSplitterMax: z.number().optional(),
+  diarization: z.boolean().optional(),
+  itn: z.boolean().optional(),
+  diarizationSpkCount: z.number().optional(),
+  disfluencyFilter: z.boolean().optional(),
+  paragraphSplitter: z.boolean().optional(),
+  profanityFilter: z.boolean().optional(),
+  wordTimestamp: z.boolean().optional(),
+};
+
+const rtzrOptionsMap: Record<keyof typeof rtzrOptionsShape, string> = {
+  domain: "domain",
+  language: "language",
+  languageCandidates: "language_candidates",
+  keywords: "keywords",
+  paragraphSplitterMax: "paragraph_splitter.max",
+  diarization: "use_diarization",
+  itn: "use_itn",
+  diarizationSpkCount: "diarization.spk_count",
+  disfluencyFilter: "use_disfluency_filter",
+  paragraphSplitter: "use_paragraph_splitter",
+  profanityFilter: "use_profanity_filter",
+  wordTimestamp: "use_word_timestamp",
+};
+
+// https://developers.rtzr.ai/docs/stt-file/
+export const rtzrTranscriptionProviderOptions = lazySchema(() =>
+  zodSchema(
+    z.object(rtzrOptionsShape).transform((item) => {
+      return Object.fromEntries(
+        Object.entries(item).map(([key, value]) => {
+          return [rtzrOptionsMap[key as keyof typeof rtzrOptionsShape], value];
+        }),
+      );
+    }),
+  ),
+);
+
+export type RtzrTranscriptionProviderOptions = InferSchema<typeof rtzrTranscriptionProviderOptions>;

package/src/ai/providers/rtzr/provider.ts

@@ -0,0 +1,91 @@
+import { NoSuchModelError, type ProviderV3, type TranscriptionModelV3 } from "@ai-sdk/provider";
+import {
+  type FetchFunction,
+  loadApiKey,
+  loadOptionalSetting,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from "@ai-sdk/provider-utils";
+import { RtzrTranscriptionModel } from "./model";
+import type { RtzrTranscriptionModelId } from "./options";
+
+export interface RtzrProvider extends ProviderV3 {
+  (modelId: RtzrTranscriptionModelId): TranscriptionModelV3;
+  transcription(modelId: RtzrTranscriptionModelId): TranscriptionModelV3;
+}
+
+export interface RtzrProviderSettings {
+  baseURL?: string;
+  clientId?: string;
+  clientSecret?: string;
+  headers?: Record<string, string>;
+  name?: string;
+  fetch?: FetchFunction;
+}
+
+export function createRtzr(options: RtzrProviderSettings = {}): RtzrProvider {
+  const baseURL =
+    withoutTrailingSlash(
+      loadOptionalSetting({
+        settingValue: options.baseURL,
+        environmentVariableName: "RTZR_BASE_URL",
+      }),
+    ) ?? "https://openapi.vito.ai/v1";
+
+  const providerName = options.name ?? "rtzr";
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        ...options.headers,
+      },
+      `cartanova-ai/rtzr-api-provider`,
+    );
+
+  const createTranscriptionModel = (modelId: RtzrTranscriptionModelId) => {
+    const clientId = loadApiKey({
+      apiKey: options.clientId,
+      environmentVariableName: "RTZR_CLIENT_ID",
+      description: "RTZR",
+    });
+
+    const clientSecret = loadApiKey({
+      apiKey: options.clientSecret,
+      environmentVariableName: "RTZR_CLIENT_SECRET",
+      description: "RTZR",
+    });
+
+    return new RtzrTranscriptionModel(modelId, {
+      provider: `${providerName}.transcription`,
+      auth: {
+        clientId,
+        clientSecret,
+      },
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+  };
+
+  const provider = (modelId: RtzrTranscriptionModelId) => createTranscriptionModel(modelId);
+
+  provider.specificationVersion = "v3" as const;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+
+  const handleUnsupportedTypes = (modelType: "languageModel" | "embeddingModel" | "imageModel") => {
+    return (modelId: string) => {
+      throw new NoSuchModelError({
+        modelId,
+        modelType,
+      });
+    };
+  };
+
+  provider.languageModel = handleUnsupportedTypes("languageModel");
+  provider.embeddingModel = handleUnsupportedTypes("embeddingModel");
+  provider.imageModel = handleUnsupportedTypes("imageModel");
+  return provider as RtzrProvider;
+}
+
+export const rtzr = createRtzr();

package/src/ai/providers/rtzr/utils.ts

@@ -0,0 +1,127 @@
+import { APICallError } from "@ai-sdk/provider";
+import {
+  extractResponseHeaders,
+  type FetchFunction,
+  isAbortError,
+  type ResponseHandler,
+  withUserAgentSuffix,
+} from "@ai-sdk/provider-utils";
+
+const FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+
+export function handleFetchError({
+  error,
+  url,
+  requestBodyValues,
+}: {
+  error: unknown;
+  url: string;
+  requestBodyValues: unknown;
+}) {
+  if (isAbortError(error)) {
+    return error;
+  }
+
+  if (
+    error instanceof TypeError &&
+    FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())
+  ) {
+    const cause = (error as { cause?: Error }).cause;
+
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url,
+        requestBodyValues,
+        isRetryable: true, // retry when network error
+      });
+    }
+  }
+
+  return error;
+}
+
+// use function to allow for mocking in tests:
+const getOriginalFetch = () => globalThis.fetch;
+
+export const getFromApi = async <T>({
+  url,
+  headers = {},
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch(),
+}: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+}) => {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: withUserAgentSuffix(headers, `cartanova-ai/rtzr-api-provider`),
+      signal: abortSignal,
+    });
+
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (!response.ok) {
+      let errorInformation: {
+        value: Error;
+        responseHeaders?: Record<string, string> | undefined;
+      };
+
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues: {},
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues: {},
+        });
+      }
+
+      throw errorInformation.value;
+    }
+
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues: {},
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+      }
+
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues: {},
+      });
+    }
+  } catch (error) {
+    throw handleFetchError({ error, url, requestBodyValues: {} });
+  }
+};

package/src/api/base-frame.ts

@@ -1,5 +1,7 @@
-import { Knex } from "knex";
-import { DB, DBPreset } from "../database/db";
+import type { Knex } from "knex";
+import type { DBPreset } from "../database/db";
+// Static imports kept for non-async functions (getDB, getUpsertBuilder)
+import { DB } from "../database/db";
 import { UpsertBuilder } from "../database/upsert-builder";
 
 export abstract class BaseFrameClass {

package/src/api/caster.ts

@@ -25,6 +25,7 @@ function isZodNumberAnyway(zodType: $ZodType) {
 }
 
 // ZodType을 이용해 raw를 Type Coercing
+// biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
 export function caster(zodType: $ZodType, raw: any): any {
   if (isZodNumberAnyway(zodType) && typeof raw === "string") {
     // number
@@ -35,45 +36,36 @@ export function caster(zodType: $ZodType, raw: any): any {
   ) {
     // zArrayable Number 케이스 처리
     if (Array.isArray(raw)) {
-      const numType = zodType.options.find(opt => isNumberType(opt));
+      const numType = zodType.options.find((opt) => isNumberType(opt));
       assert(numType !== undefined);
+      // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
       return raw.map((elem: any) => caster(numType, elem));
     } else {
       return Number(raw);
     }
-  } else if (
-    zodType instanceof z.ZodBoolean &&
-    (raw === "true" || raw === "false")
-  ) {
+  } else if (zodType instanceof z.ZodBoolean && (raw === "true" || raw === "false")) {
     // boolean
     return raw === "true";
-  } else if (
-    raw !== null &&
-    Array.isArray(raw) &&
-    zodType instanceof z.ZodArray
-  ) {
+  } else if (raw !== null && Array.isArray(raw) && zodType instanceof z.ZodArray) {
     // array
+    // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
     return raw.map((elem: any) => caster(zodType.element, elem));
-  } else if (
-    zodType instanceof z.ZodObject &&
-    typeof raw === "object" &&
-    raw !== null
-  ) {
+  } else if (zodType instanceof z.ZodObject && typeof raw === "object" && raw !== null) {
     // object
-    return Object.keys(raw).reduce((r, rawKey) => {
-      r[rawKey] = caster(zodType.shape[rawKey], raw[rawKey]);
-      return r;
-    }, {} as any);
+    return Object.keys(raw).reduce(
+      (r, rawKey) => {
+        r[rawKey] = caster(zodType.shape[rawKey], raw[rawKey]);
+        return r;
+      },
+      {} as Record<string, unknown>,
+    );
   } else if (zodType instanceof z.ZodOptional) {
     // optional
     return caster(zodType.def.innerType, raw);
   } else if (zodType instanceof z.ZodNullable) {
     // nullable
     return caster(zodType.def.innerType, raw);
-  } else if (
-    zodType instanceof z.ZodDate &&
-    new Date(raw).toString() !== "Invalid Date"
-  ) {
+  } else if (zodType instanceof z.ZodDate && new Date(raw).toString() !== "Invalid Date") {
     // date
     return new Date(raw);
   } else {
@@ -82,7 +74,9 @@ export function caster(zodType: $ZodType, raw: any): any {
   }
 }
 
+// biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
 export function fastifyCaster(schema: z.ZodObject<any>) {
+  // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
   return z.preprocess((raw: any) => {
     return caster(schema, raw);
   }, schema);