sonamu 0.8.27 → 0.9.1

package/dist/ai/providers/rtzr/model.js

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

package/dist/ai/providers/rtzr/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAyB,MAAM,wBAAwB,CAAC;AAGjF,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAiC7E,eAAO,MAAM,gCAAgC;;EAU5C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAiC7E,eAAO,MAAM,gCAAgC;;EAU5C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/ai/providers/rtzr/options.js

@@ -1,47 +1,41 @@
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z } from "zod";
+import { z as z$1 } from "zod";
+
+//#region src/ai/providers/rtzr/options.ts
 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()
+	domain: z$1.enum(["CALL", "GENERAL"]).default("GENERAL"),
+	language: z$1.string(),
+	languageCandidates: z$1.array(z$1.string()).optional(),
+	keywords: z$1.union([z$1.string(), z$1.array(z$1.string())]).optional(),
+	paragraphSplitterMax: z$1.number().optional(),
+	diarization: z$1.boolean().optional(),
+	itn: z$1.boolean().optional(),
+	diarizationSpkCount: z$1.number().optional(),
+	disfluencyFilter: z$1.boolean().optional(),
+	paragraphSplitter: z$1.boolean().optional(),
+	profanityFilter: z$1.boolean().optional(),
+	wordTimestamp: z$1.boolean().optional()
 };
 const rtzrOptionsMap = {
-    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"
+	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],
-                value
-            ];
-        }));
-    })));
+const rtzrTranscriptionProviderOptions = lazySchema(() => zodSchema(z$1.object(rtzrOptionsShape).transform((item) => {
+	return Object.fromEntries(Object.entries(item).map(([key, value]) => {
+		return [rtzrOptionsMap[key], value];
+	}));
+})));
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { rtzrTranscriptionProviderOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/ai/providers/rtzr/provider.d.ts

@@ -1,6 +1,6 @@
 import { type ProviderV3, type TranscriptionModelV3 } from "@ai-sdk/provider";
 import { type FetchFunction } from "@ai-sdk/provider-utils";
-import type { RtzrTranscriptionModelId } from "./options";
+import { type RtzrTranscriptionModelId } from "./options";
 export interface RtzrProvider extends ProviderV3 {
     (modelId: RtzrTranscriptionModelId): TranscriptionModelV3;
     transcription(modelId: RtzrTranscriptionModelId): TranscriptionModelV3;

package/dist/ai/providers/rtzr/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE1D,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;IAC1D,aAAa,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;CACxE;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,wBAAgB,UAAU,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CA+D3E;AAED,eAAO,MAAM,IAAI,cAAe,CAAC"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAO9E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE1D,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;IAC1D,aAAa,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;CACxE;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,wBAAgB,UAAU,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CA+D3E;AAED,eAAO,MAAM,IAAI,cAAe,CAAC"}

package/dist/ai/providers/rtzr/provider.js

@@ -1,54 +1,56 @@
-import { NoSuchModelError } from "@ai-sdk/provider";
-import { loadApiKey, loadOptionalSetting, withoutTrailingSlash, withUserAgentSuffix } from "@ai-sdk/provider-utils";
 import { RtzrTranscriptionModel } from "./model.js";
-export function createRtzr(options = {}) {
-    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)=>{
-        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)=>createTranscriptionModel(modelId);
-    provider.specificationVersion = "v3";
-    provider.transcription = createTranscriptionModel;
-    provider.transcriptionModel = createTranscriptionModel;
-    const handleUnsupportedTypes = (modelType)=>{
-        return (modelId)=>{
-            throw new NoSuchModelError({
-                modelId,
-                modelType
-            });
-        };
-    };
-    provider.languageModel = handleUnsupportedTypes("languageModel");
-    provider.embeddingModel = handleUnsupportedTypes("embeddingModel");
-    provider.imageModel = handleUnsupportedTypes("imageModel");
-    return provider;
+import { loadApiKey, loadOptionalSetting, withUserAgentSuffix, withoutTrailingSlash } from "@ai-sdk/provider-utils";
+import { NoSuchModelError } from "@ai-sdk/provider";
+
+//#region src/ai/providers/rtzr/provider.ts
+function createRtzr(options = {}) {
+	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) => {
+		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) => createTranscriptionModel(modelId);
+	provider.specificationVersion = "v3";
+	provider.transcription = createTranscriptionModel;
+	provider.transcriptionModel = createTranscriptionModel;
+	const handleUnsupportedTypes = (modelType) => {
+		return (modelId) => {
+			throw new NoSuchModelError({
+				modelId,
+				modelType
+			});
+		};
+	};
+	provider.languageModel = handleUnsupportedTypes("languageModel");
+	provider.embeddingModel = handleUnsupportedTypes("embeddingModel");
+	provider.imageModel = handleUnsupportedTypes("imageModel");
+	return provider;
 }
-export const rtzr = createRtzr();
+const rtzr = createRtzr();
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { createRtzr, rtzr };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/ai/providers/rtzr/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,GAAG,EACH,iBAAiB,GAClB,EAAE;IACD,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,OAAO,CAAC;CAC5B,WAuBA;AAKD,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,yFAOjC;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,qBAAqB,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAC9C,yBAAyB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;;;;EAiEA,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAIlF,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,GAAG,EACH,iBAAiB,GAClB,EAAE;IACD,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,OAAO,CAAC;CAC5B,WAuBA;AAKD,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,yFAOjC;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,qBAAqB,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAC9C,yBAAyB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;;;;EAiEA,CAAC"}