n8n-nodes-speechsense 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 x0cfwm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# n8n-nodes-speechsense
+
+An [n8n](https://n8n.io) community node that uploads talks (call recordings) to
+**Yandex SpeechSense** (Talk Analytics).
+
+SpeechSense exposes talk **upload only over gRPC** (`api.speechsense.yandexcloud.net:443`)
+— the REST host serves read methods (search/get) only. This node speaks that gRPC
+API directly using a bundled, self-contained subset of the official protobuf, so no
+code generation or external proto files are required at runtime.
+
+## Operations
+
+- **Talk → Upload Audio** — `TalkService.Upload`. Sends one audio recording (MP3 / WAV /
+  OGG-Opus) plus talk metadata and per-user metadata to a SpeechSense connection.
+
+## Credentials
+
+**SpeechSense API**
+- **API Key** — a Yandex Cloud service-account API key with the SpeechSense upload role.
+  Paste the raw key; the node adds the `Api-Key ` prefix.
+- **gRPC Endpoint** — defaults to `api.speechsense.yandexcloud.net:443`.
+
+## Node parameters
+
+| Field | Notes |
+| --- | --- |
+| Connection ID | Target SpeechSense connection. |
+| Input Binary Field | Item binary property holding the audio file (default `data`). |
+| Audio Type | `MP3` / `WAV` / `OGG/Opus`. |
+| Talk ID | Optional; leave blank to create a new talk. |
+| Metadata Fields (JSON) | `{ "key": "value" }` map of connection-defined fields. |
+| Users (JSON) | `[{ "id", "role": "USER_ROLE_OPERATOR"\|"USER_ROLE_CLIENT", "fields": {} }]`. |
+
+The node returns `{ talk_id }` for each uploaded item.
+
+## License
+
+[MIT](./LICENSE)

package/dist/credentials/SpeechSenseApi.credentials.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechSenseApi = void 0;
+class SpeechSenseApi {
+    constructor() {
+        this.name = 'speechSenseApi';
+        this.displayName = 'SpeechSense API';
+        this.documentationUrl = 'https://yandex.cloud/docs/speechsense/';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Yandex Cloud service-account API key with the SpeechSense upload role. Paste the raw key only — the node adds the "Api-Key " prefix itself.',
+            },
+            {
+                displayName: 'gRPC Endpoint',
+                name: 'endpoint',
+                type: 'string',
+                default: 'api.speechsense.yandexcloud.net:443',
+                description: 'SpeechSense gRPC data-plane endpoint as host:port.',
+            },
+        ];
+    }
+}
+exports.SpeechSenseApi = SpeechSenseApi;

package/dist/nodes/SpeechSense/GenericFunctions.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadTalk = uploadTalk;
+const path = __importStar(require("path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+// The generated gRPC client constructor, cached across executions.
+let cachedServiceCtor;
+function getTalkServiceCtor() {
+    if (cachedServiceCtor)
+        return cachedServiceCtor;
+    const protoPath = path.join(__dirname, 'talk_service.proto');
+    const definition = protoLoader.loadSync(protoPath, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+    });
+    const pkg = grpc.loadPackageDefinition(definition);
+    cachedServiceCtor = pkg.yandex.cloud.speechsense.v1.TalkService;
+    return cachedServiceCtor;
+}
+/** Call TalkService.Upload (unary, TLS, Api-Key auth) and resolve the response. */
+async function uploadTalk(creds, request, timeoutMs = 120000) {
+    const Ctor = getTalkServiceCtor();
+    const endpoint = (creds.endpoint || 'api.speechsense.yandexcloud.net:443').trim();
+    const channelCreds = grpc.credentials.createSsl();
+    const client = new Ctor(endpoint, channelCreds, {
+        'grpc.max_send_message_length': 128 * 1024 * 1024,
+        'grpc.max_receive_message_length': 16 * 1024 * 1024,
+    });
+    const metadata = new grpc.Metadata();
+    metadata.add('authorization', `Api-Key ${creds.apiKey}`);
+    return new Promise((resolve, reject) => {
+        const deadline = new Date(Date.now() + timeoutMs);
+        client.Upload(request, metadata, { deadline }, (err, response) => {
+            try {
+                client.close();
+            }
+            catch {
+                /* noop */
+            }
+            if (err) {
+                const code = err.code !== undefined ? err.code : '?';
+                reject(new Error(`SpeechSense Upload failed [gRPC ${code}]: ${err.details || err.message}`));
+                return;
+            }
+            resolve(response);
+        });
+    });
+}

package/dist/nodes/SpeechSense/SpeechSense.node.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechSense = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+/** Coerce an arbitrary value into a flat { string: string } map. */
+function asStringMap(value) {
+    const out = {};
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        for (const [k, v] of Object.entries(value)) {
+            if (v === undefined || v === null)
+                continue;
+            out[k] = typeof v === 'string' ? v : String(v);
+        }
+    }
+    return out;
+}
+function parseMaybeJson(value, fallback) {
+    if (typeof value !== 'string')
+        return value ?? fallback;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return fallback;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return fallback;
+    }
+}
+class SpeechSense {
+    constructor() {
+        this.description = {
+            displayName: 'SpeechSense',
+            name: 'speechSense',
+            icon: 'fa:cloud-upload-alt',
+            group: ['output'],
+            version: 1,
+            subtitle: '={{ $parameter["operation"] + ": " + $parameter["resource"] }}',
+            description: 'Загрузка диалогов в Yandex SpeechSense (Talk Analytics) по gRPC',
+            defaults: { name: 'SpeechSense' },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [{ name: 'speechSenseApi', required: true }],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    default: 'talk',
+                    options: [{ name: 'Talk', value: 'talk' }],
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    default: 'uploadAudio',
+                    displayOptions: { show: { resource: ['talk'] } },
+                    options: [
+                        {
+                            name: 'Upload Audio',
+                            value: 'uploadAudio',
+                            action: 'Upload an audio talk',
+                            description: 'Залить аудиозапись разговора (TalkService.Upload, gRPC)',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Connection ID',
+                    name: 'connectionId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    description: 'ID коннекции SpeechSense, в которую заливается разговор',
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    required: true,
+                    default: 'data',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    description: 'Имя входного бинарного поля с аудиофайлом',
+                },
+                {
+                    displayName: 'Audio Type',
+                    name: 'audioType',
+                    type: 'options',
+                    default: 'CONTAINER_AUDIO_TYPE_MP3',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    options: [
+                        { name: 'MP3', value: 'CONTAINER_AUDIO_TYPE_MP3' },
+                        { name: 'WAV', value: 'CONTAINER_AUDIO_TYPE_WAV' },
+                        { name: 'OGG / Opus', value: 'CONTAINER_AUDIO_TYPE_OGG_OPUS' },
+                    ],
+                },
+                {
+                    displayName: 'Talk ID',
+                    name: 'talkId',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    description: 'Необязательно. Пусто — создаётся новый talk; заданный — обновление метаданных.',
+                },
+                {
+                    displayName: 'Metadata Fields (JSON)',
+                    name: 'fields',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    description: 'Объект строковых полей метаданных диалога (ключи, заданные в коннекции)',
+                },
+                {
+                    displayName: 'Users (JSON)',
+                    name: 'users',
+                    type: 'json',
+                    default: '[]',
+                    displayOptions: { show: { resource: ['talk'], operation: ['uploadAudio'] } },
+                    description: 'Массив участников: [{ "id": "...", "role": "USER_ROLE_OPERATOR" | "USER_ROLE_CLIENT", "fields": { } }]',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const c = (await this.getCredentials('speechSenseApi'));
+        const creds = {
+            apiKey: c.apiKey,
+            endpoint: c.endpoint || 'api.speechsense.yandexcloud.net:443',
+        };
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const connectionId = this.getNodeParameter('connectionId', i);
+                const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                const audioType = this.getNodeParameter('audioType', i);
+                const talkId = this.getNodeParameter('talkId', i, '');
+                const fieldsRaw = parseMaybeJson(this.getNodeParameter('fields', i, {}), {});
+                const usersRaw = parseMaybeJson(this.getNodeParameter('users', i, []), []);
+                const fields = asStringMap(fieldsRaw);
+                const users = Array.isArray(usersRaw)
+                    ? usersRaw.map((u) => ({
+                        id: String(u.id ?? ''),
+                        role: String(u.role ?? 'USER_ROLE_UNSPECIFIED'),
+                        fields: asStringMap(u.fields),
+                    }))
+                    : [];
+                const buffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                const request = {
+                    metadata: { connection_id: connectionId, fields, users },
+                    audio: {
+                        audio_metadata: { container_audio: { container_audio_type: audioType } },
+                        audio_data: { data: buffer },
+                    },
+                };
+                if (talkId)
+                    request.talk_id = talkId;
+                const response = await (0, GenericFunctions_1.uploadTalk)(creds, request);
+                returnData.push({
+                    json: { talk_id: response?.talk_id ?? null, connection_id: connectionId },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.SpeechSense = SpeechSense;

package/dist/nodes/SpeechSense/talk_service.proto

@@ -0,0 +1,84 @@
+syntax = "proto3";
+
+package yandex.cloud.speechsense.v1;
+
+// Minimal, self-contained subset of the Yandex SpeechSense Talk API, sufficient
+// for TalkService.Upload (single-message audio upload). Message/field/enum
+// numbers match the official protos (yandex-cloud/cloudapi:
+// yandex/cloud/speechsense/v1/{talk_service,audio}.proto) so the binary wire
+// format is compatible. Streaming/text/search RPCs are intentionally omitted.
+
+service TalkService {
+  // Upload a talk document as a single message.
+  rpc Upload(UploadTalkRequest) returns (UploadTalkResponse);
+}
+
+message UploadTalkRequest {
+  TalkMetadata metadata = 1;
+  AudioRequest audio = 2;
+  // Blank for initial upload; set to update an existing talk's metadata.
+  string talk_id = 3;
+}
+
+message UploadTalkResponse {
+  // id of the created talk document
+  string talk_id = 1;
+}
+
+message TalkMetadata {
+  // id of the connection this talk belongs to
+  string connection_id = 1;
+  // connection-defined metadata fields
+  map<string, string> fields = 2;
+  // per-user metadata
+  repeated UserMetadata users = 3;
+}
+
+message UserMetadata {
+  string id = 1;
+  UserRole role = 2;
+  map<string, string> fields = 3;
+}
+
+enum UserRole {
+  USER_ROLE_UNSPECIFIED = 0;
+  USER_ROLE_OPERATOR = 1;
+  USER_ROLE_CLIENT = 2;
+  USER_ROLE_BOT = 3;
+}
+
+message RawAudio {
+  enum AudioEncoding {
+    AUDIO_ENCODING_UNSPECIFIED = 0;
+    AUDIO_ENCODING_LINEAR16_PCM = 1;
+  }
+  AudioEncoding audio_encoding = 1;
+  int64 sample_rate_hertz = 2;
+  int64 audio_channel_count = 3;
+}
+
+message ContainerAudio {
+  enum ContainerAudioType {
+    CONTAINER_AUDIO_TYPE_UNSPECIFIED = 0;
+    CONTAINER_AUDIO_TYPE_WAV = 1;
+    CONTAINER_AUDIO_TYPE_OGG_OPUS = 2;
+    CONTAINER_AUDIO_TYPE_MP3 = 3;
+  }
+  ContainerAudioType container_audio_type = 1;
+}
+
+message AudioMetadata {
+  oneof AudioFormat {
+    RawAudio raw_audio = 1;
+    ContainerAudio container_audio = 2;
+  }
+}
+
+message AudioChunk {
+  bytes data = 1;
+}
+
+message AudioRequest {
+  AudioMetadata audio_metadata = 1;
+  AudioChunk audio_data = 2;
+}

package/index.js

@@ -0,0 +1,3 @@
+// n8n discovers nodes and credentials through the "n8n" field in package.json.
+// This file exists only to satisfy the package "main" entry.
+module.exports = {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "n8n-nodes-speechsense",
+  "version": "0.1.0",
+  "description": "n8n community node to upload call/chat talks to Yandex SpeechSense (Talk Analytics) over gRPC",
+  "keywords": [
+    "n8n-community-node-package",
+    "speechsense",
+    "yandex",
+    "talk-analytics",
+    "grpc",
+    "speech"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "x0cfwm",
+    "url": "https://github.com/x0cfwm"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/x0cfwm/n8n-nodes-speechsense.git"
+  },
+  "homepage": "https://github.com/x0cfwm/n8n-nodes-speechsense#readme",
+  "bugs": {
+    "url": "https://github.com/x0cfwm/n8n-nodes-speechsense/issues"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc && npm run copy:assets",
+    "prepare": "npm run build",
+    "copy:assets": "mkdir -p dist/nodes/SpeechSense && cp nodes/SpeechSense/*.proto dist/nodes/SpeechSense/ 2>/dev/null || true",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "files": [
+    "dist",
+    "index.js"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/SpeechSenseApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/SpeechSense/SpeechSense.node.js"
+    ]
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.10.0",
+    "@grpc/proto-loader": "^0.7.10"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "n8n-workflow": "*",
+    "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}