yandex-ai 0.0.1

package/dist/chat.d.ts

@@ -0,0 +1,28 @@
+import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult } from "@ai-sdk/provider";
+type YandexModelId = "aliceai-llm" | "yandexgpt/rc" | "yandexgpt-lite" | "yandexgpt/latest" | "qwen3-235b-a22b-fp8/latest" | "gpt-oss-120b/latest" | "gpt-oss-20b/latest" | "gemma-3-27b-it/latest" | (string & {});
+type YandexReasoningMode = "REASONING_MODE_UNSPECIFIED" | "DISABLED" | "ENABLED_HIDDEN";
+type YandexChatProviderOptions = {
+	reasoningOptions?: YandexReasoningMode;
+	parallelToolCalls?: boolean;
+};
+declare class YandexChatModel implements LanguageModelV3 {
+	private folderId;
+	private secretKey;
+	readonly specificationVersion = "v3";
+	readonly provider = "yandex-cloud";
+	readonly modelId;
+	readonly supportedUrls: {};
+	constructor(modelId: YandexModelId, { folderId, secretKey }: {
+		folderId: string;
+		secretKey: string;
+	});
+	private convertTools;
+	private convertRole;
+	private convertFromAiSdkToYandex;
+	private convertFromYandexToAiSdk;
+	private convertToolChoice;
+	private convertFinishReason;
+	doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+	doStream(): Promise<never>;
+}
+export { YandexChatProviderOptions, YandexChatModel };

package/dist/chat.js

@@ -0,0 +1,280 @@
+// src/chat.ts
+class YandexChatModel {
+  folderId;
+  secretKey;
+  specificationVersion = "v3";
+  provider = "yandex-cloud";
+  modelId;
+  supportedUrls = {};
+  constructor(modelId, { folderId, secretKey }) {
+    this.modelId = modelId;
+    this.folderId = folderId;
+    this.secretKey = secretKey;
+  }
+  convertTools(tools) {
+    const warnings = [];
+    const convertedTools = [];
+    if (!tools) {
+      return { tools: [], warnings: [] };
+    }
+    for (const tool of tools) {
+      if (tool.type !== "function") {
+        warnings.push(`Tool ${tool.name} is not a function tool`);
+        continue;
+      }
+      convertedTools.push({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema,
+        strict: true
+      });
+    }
+    return {
+      tools: convertedTools.map((tool) => ({
+        function: tool
+      })),
+      warnings
+    };
+  }
+  convertRole(role) {
+    switch (role) {
+      case "assistant":
+        return "assistant";
+      case "user":
+        return "user";
+      default:
+        return "system";
+    }
+  }
+  convertFromAiSdkToYandex(messages) {
+    const warnings = [];
+    const convertedMessages = [];
+    for (const message of messages) {
+      const role = this.convertRole(message.role);
+      if (typeof message.content === "string") {
+        convertedMessages.push({
+          role,
+          text: message.content
+        });
+        continue;
+      }
+      for (const part of message.content) {
+        console.log({ part });
+        if (typeof part === "string") {
+          convertedMessages.push({
+            role,
+            text: part
+          });
+          continue;
+        }
+        switch (part.type) {
+          case "text":
+            convertedMessages.push({
+              role,
+              text: part.text
+            });
+            continue;
+          case "tool-call":
+            convertedMessages.push({
+              role,
+              toolCallList: {
+                toolCalls: [
+                  {
+                    functionCall: {
+                      name: part.toolName,
+                      arguments: part.input
+                    }
+                  }
+                ]
+              }
+            });
+            continue;
+          case "tool-result":
+            convertedMessages.push({
+              role: "user",
+              toolResultList: {
+                toolResults: [
+                  {
+                    functionResult: {
+                      name: part.toolName,
+                      content: JSON.stringify(part.output)
+                    }
+                  }
+                ]
+              }
+            });
+            continue;
+          case "file":
+            throw new Error("Files are not implemented yet");
+          case "reasoning":
+            throw new Error("Reasoning is not implemented yet");
+          case "tool-approval-response":
+            throw new Error("Tool approval is not implemented yet");
+        }
+      }
+    }
+    return {
+      messages: convertedMessages,
+      warnings
+    };
+  }
+  convertFromYandexToAiSdk(alternatives) {
+    const content = [];
+    let status = {
+      raw: undefined,
+      unified: "stop"
+    };
+    for (const part of alternatives) {
+      status = this.convertFinishReason(part.status);
+      if (part.message.text) {
+        content.push({
+          type: "text",
+          text: part.message.text
+        });
+      } else if (part.message.toolCallList) {
+        for (const toolCall of part.message.toolCallList.toolCalls) {
+          content.push({
+            toolCallId: crypto.randomUUID(),
+            type: "tool-call",
+            toolName: toolCall.functionCall.name,
+            input: JSON.stringify(toolCall.functionCall.arguments)
+          });
+        }
+      } else if (part.message.toolResultList) {
+        for (const toolResult of part.message.toolResultList.toolResults) {
+          content.push({
+            toolCallId: crypto.randomUUID(),
+            type: "tool-result",
+            toolName: toolResult.functionResult.name,
+            result: JSON.parse(toolResult.functionResult.content)
+          });
+        }
+      }
+    }
+    return {
+      content,
+      finishReason: status
+    };
+  }
+  convertToolChoice(toolChoice) {
+    if (!toolChoice) {
+      return {
+        mode: "TOOL_CHOICE_MODE_UNSPECIFIED"
+      };
+    }
+    if (toolChoice.type === "tool") {
+      return {
+        functionName: toolChoice.toolName
+      };
+    }
+    switch (toolChoice.type) {
+      case "auto":
+        return {
+          mode: "AUTO"
+        };
+      case "none":
+        return {
+          mode: "NONE"
+        };
+      case "required":
+        return {
+          mode: "REQUIRED"
+        };
+    }
+  }
+  convertFinishReason(reason) {
+    switch (reason) {
+      case "ALTERNATIVE_STATUS_UNSPECIFIED":
+        return {
+          raw: reason,
+          unified: "stop"
+        };
+      case "ALTERNATIVE_STATUS_PARTIAL":
+        return {
+          raw: reason,
+          unified: "other"
+        };
+      case "ALTERNATIVE_STATUS_TRUNCATED_FINAL":
+        return {
+          raw: reason,
+          unified: "length"
+        };
+      case "ALTERNATIVE_STATUS_FINAL":
+        return {
+          raw: reason,
+          unified: "stop"
+        };
+      case "ALTERNATIVE_STATUS_CONTENT_FILTER": {
+        return {
+          raw: reason,
+          unified: "other"
+        };
+      }
+      case "ALTERNATIVE_STATUS_TOOL_CALLS": {
+        return {
+          raw: reason,
+          unified: "tool-calls"
+        };
+      }
+    }
+  }
+  async doGenerate(options) {
+    const { messages, warnings: messageWarnings } = this.convertFromAiSdkToYandex(options.prompt);
+    const { tools, warnings: toolWarnings } = this.convertTools(options.tools);
+    const po = options.providerOptions;
+    const body = {
+      modelUri: `gpt://${this.folderId}/${this.modelId}`,
+      completionOptions: {
+        stream: false,
+        temperature: options.temperature,
+        maxTokens: options.maxOutputTokens,
+        reasoningOptions: po?.reasoningOptions
+      },
+      messages,
+      tools,
+      jsonSchema: options.responseFormat?.type === "json" ? options.responseFormat.schema : undefined,
+      toolChoice: this.convertToolChoice(options.toolChoice),
+      parallelToolCalls: po?.parallelToolCalls
+    };
+    const response = await fetch("https://llm.api.cloud.yandex.net/foundationModels/v1/completion", {
+      method: "POST",
+      headers: {
+        Authorization: `Api-Key ${this.secretKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Yandex API error: ${response.status} ${response.statusText}: ${await response.text()}`);
+    }
+    const data = await response.json();
+    const { finishReason, content } = this.convertFromYandexToAiSdk(data.result.alternatives);
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: {
+          total: Number.parseInt(data.result.usage.inputTextTokens, 10),
+          noCache: Number.parseInt(data.result.usage.inputTextTokens, 10),
+          cacheRead: 0,
+          cacheWrite: 0
+        },
+        outputTokens: {
+          total: Number.parseInt(data.result.usage.completionTokens, 10),
+          text: Number.parseInt(data.result.usage.completionTokens, 10),
+          reasoning: 0
+        }
+      },
+      warnings: [...messageWarnings, ...toolWarnings].map((s) => ({
+        type: "compatibility",
+        feature: s
+      }))
+    };
+  }
+  async doStream() {
+    throw new Error("Стриминг (doStream) пока не реализован.");
+  }
+}
+export {
+  YandexChatModel
+};

package/dist/speech.d.ts

@@ -0,0 +1,62 @@
+import { JSONObject, SharedV2Headers, SharedV3Warning, SpeechModelV3, SpeechModelV3CallOptions } from "@ai-sdk/provider";
+declare const yandexSpeechVoices: readonly ["alena", "filipp", "ermil", "jane", "omazh", "zahar", "dasha", "julia", "lera", "masha", "marina", "alexander", "kirill", "anton", "madi_ru", "saule_ru", "zamira_ru", "zhanar_ru", "yulduz_ru"];
+type YandexSpeechVoice = (typeof yandexSpeechVoices)[number];
+declare const voiceEmotions: {
+	readonly alena: readonly ["neutral", "good"];
+	readonly filipp: readonly ["neutral"];
+	readonly ermil: readonly ["neutral", "good"];
+	readonly jane: readonly ["neutral", "good", "evil"];
+	readonly omazh: readonly ["neutral", "evil"];
+	readonly zahar: readonly ["neutral", "good"];
+	readonly dasha: readonly ["neutral", "good", "friendly"];
+	readonly julia: readonly ["neutral", "strict"];
+	readonly lera: readonly ["neutral", "friendly"];
+	readonly masha: readonly ["good", "strict", "friendly"];
+	readonly marina: readonly ["neutral", "whisper", "friendly"];
+	readonly alexander: readonly ["neutral", "good"];
+	readonly kirill: readonly ["neutral", "strict", "good"];
+	readonly anton: readonly ["neutral", "good"];
+	readonly madi_ru: readonly ["neutral"];
+	readonly saule_ru: readonly ["neutral", "strict", "whisper"];
+	readonly zamira_ru: readonly ["neutral", "strict", "friendly"];
+	readonly zhanar_ru: readonly ["neutral", "strict", "friendly"];
+	readonly yulduz_ru: readonly ["neutral", "strict", "friendly", "whisper"];
+};
+type YandexSpeechEmotionFor<T extends YandexSpeechVoice> = (typeof voiceEmotions)[T][number];
+type YandexSpeechProviderOptions<T extends YandexSpeechVoice> = {
+	emotion?: YandexSpeechEmotionFor<T>;
+	sampleRateHertz?: 48000 | 16000 | 8000;
+};
+type YandexSpeechOptions<T extends YandexSpeechVoice> = {
+	voice: T;
+	speed?: number;
+	providerOptions?: YandexSpeechProviderOptions<T>;
+	outputFormat?: "mp3" | "oggopus" | "lpcm";
+};
+declare class YandexSpeechModel implements SpeechModelV3 {
+	private folderId;
+	private secretKey;
+	readonly specificationVersion = "v3";
+	readonly provider = "yandex-cloud";
+	readonly modelId = "tts:synthesize";
+	constructor({ folderId, secretKey }: {
+		folderId: string;
+		secretKey: string;
+	});
+	private sanitizeInput;
+	doGenerate(options: SpeechModelV3CallOptions): Promise<{
+		audio: string | Uint8Array;
+		warnings: Array<SharedV3Warning>;
+		request?: {
+			body?: unknown;
+		};
+		response: {
+			timestamp: Date;
+			modelId: string;
+			headers?: SharedV2Headers;
+			body?: unknown;
+		};
+		providerMetadata?: Record<string, JSONObject>;
+	}>;
+}
+export { YandexSpeechVoice, YandexSpeechProviderOptions, YandexSpeechOptions, YandexSpeechModel, YandexSpeechEmotionFor };

package/dist/speech.js

@@ -0,0 +1,65 @@
+// src/speech.ts
+class YandexSpeechModel {
+  folderId;
+  secretKey;
+  specificationVersion = "v3";
+  provider = "yandex-cloud";
+  modelId = "tts:synthesize";
+  constructor({
+    folderId,
+    secretKey
+  }) {
+    this.folderId = folderId;
+    this.secretKey = secretKey;
+  }
+  sanitizeInput(input) {
+    return input.replace(/[^a-zA-Z0-9а-яА-ЯёЁ]/g, " ");
+  }
+  async doGenerate(options) {
+    const po = options.providerOptions;
+    const requestBody = {
+      text: this.sanitizeInput(options.text),
+      voice: options.voice,
+      lang: options.language,
+      emotion: po.emotion,
+      speed: options.speed,
+      format: options.outputFormat,
+      sampleRateHertz: po.sampleRateHertz,
+      folderId: this.folderId
+    };
+    console.log(requestBody.text);
+    const formData = new URLSearchParams;
+    for (const [key, value] of Object.entries(requestBody)) {
+      if (value !== undefined && value !== null) {
+        formData.append(key, String(value));
+      }
+    }
+    const response = await fetch("https://tts.api.cloud.yandex.net/speech/v1/tts:synthesize", {
+      method: "POST",
+      headers: {
+        Authorization: `Api-Key ${this.secretKey}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: formData.toString()
+    });
+    if (!response.ok) {
+      throw new Error(`Yandex TTS API error: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const audio = new Uint8Array(arrayBuffer);
+    return {
+      audio,
+      warnings: [],
+      request: { body: requestBody },
+      response: {
+        timestamp: new Date,
+        modelId: this.modelId,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: audio
+      }
+    };
+  }
+}
+export {
+  YandexSpeechModel
+};

package/dist/transcript.d.ts

@@ -0,0 +1,40 @@
+import { JSONObject, SharedV3Headers, SharedV3Warning, TranscriptionModelV3, TranscriptionModelV3CallOptions } from "@ai-sdk/provider";
+type YandexTranscriptProviderOptions = {
+	profanityFilter?: boolean;
+	rawResults?: boolean;
+	format?: "lpcm" | "oggopus";
+	sampleRateHertz?: 48000 | 16000 | 8000;
+};
+declare class YandexTranscriptModel implements TranscriptionModelV3 {
+	private folderId;
+	private secretKey;
+	readonly specificationVersion = "v3";
+	readonly provider = "yandex-cloud";
+	readonly modelId = "sst:recognize";
+	constructor({ folderId, secretKey }: {
+		folderId: string;
+		secretKey: string;
+	});
+	doGenerate(options: TranscriptionModelV3CallOptions): Promise<{
+		text: string;
+		segments: Array<{
+			text: string;
+			startSecond: number;
+			endSecond: number;
+		}>;
+		language: string | undefined;
+		durationInSeconds: number | undefined;
+		warnings: Array<SharedV3Warning>;
+		request?: {
+			body?: string;
+		};
+		response: {
+			timestamp: Date;
+			modelId: string;
+			headers?: SharedV3Headers;
+			body?: unknown;
+		};
+		providerMetadata?: Record<string, JSONObject>;
+	}>;
+}
+export { YandexTranscriptProviderOptions, YandexTranscriptModel };

package/dist/transcript.js

@@ -0,0 +1,52 @@
+// src/transcript.ts
+class YandexTranscriptModel {
+  folderId;
+  secretKey;
+  specificationVersion = "v3";
+  provider = "yandex-cloud";
+  modelId = "sst:recognize";
+  constructor({
+    folderId,
+    secretKey
+  }) {
+    this.folderId = folderId;
+    this.secretKey = secretKey;
+  }
+  async doGenerate(options) {
+    const queryParams = new URLSearchParams({
+      folderId: this.folderId,
+      ...options.providerOptions
+    });
+    const response = await fetch(`https://stt.api.cloud.yandex.net/speech/v1/stt:recognize?${queryParams.toString()}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Api-Key ${this.secretKey}`,
+        "Content-Type": "application/octet-stream"
+      },
+      body: options.audio
+    });
+    if (!response.ok) {
+      throw new Error(`Yandex STT API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      text: data.result.length > 0 ? data.result : "нет звуков",
+      segments: [],
+      language: undefined,
+      durationInSeconds: undefined,
+      warnings: [],
+      request: {
+        body: queryParams.toString()
+      },
+      response: {
+        timestamp: new Date,
+        modelId: this.modelId,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: data
+      }
+    };
+  }
+}
+export {
+  YandexTranscriptModel
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "yandex-ai",
+  "version": "0.0.1",
+  "description": "Yandex GPT integrations for Vercel's AI SDK. Includes LLM, TTS and STT.",
+  "author": "Denis Smirnov <wonepng@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./chat": {
+      "types": "./dist/chat/index.d.ts",
+      "default": "./dist/chat/index.js"
+    },
+    "./speech": {
+      "types": "./dist/speech/index.d.ts",
+      "default": "./dist/speech/index.js"
+    },
+    "./transcript": {
+      "types": "./dist/transcript/index.d.ts",
+      "default": "./dist/transcript/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENCE"
+  ],
+  "scripts": {
+    "build": "bunup src/chat.ts src/speech.ts src/transcript.ts",
+    "publish": "bun publish"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "ai": "^6.0.62"
+  },
+  "devDependencies": {
+    "bunup": "^0.16.21",
+    "typescript": "^5.6.2"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}