@twick/cloud-transcript 0.15.1

package/README.md

@@ -0,0 +1,131 @@
+# @twick/cloud-transcript
+
+**Transcribe audio/video to JSON captions using Google GenAI (Vertex AI) with Gemini models.**
+
+Extract text from audio content with precise millisecond timestamps. Perfect for generating subtitle data from audio files or video URLs.
+
+## What Problem Does This Solve?
+
+- **AI-powered transcription** — Use Google's Gemini models for accurate audio-to-text conversion
+- **Precise timestamps** — Get millisecond-level timing for each caption segment
+- **Serverless processing** — Deploy as AWS Lambda for automatic scaling
+- **Multiple languages** — Support various languages and fonts
+
+## Input → Output
+
+**Input:** Audio URL + optional configuration
+```json
+{
+  "audioUrl": "https://example.com/audio.mp3",
+  "language": "english",
+  "languageFont": "english"
+}
+```
+
+**Output:** JSON captions with timestamps
+```json
+{
+  "captions": [
+    {
+      "t": "Example phrase 1",
+      "s": 0,
+      "e": 1500
+    },
+    {
+      "t": "Another short example",
+      "s": 1500,
+      "e": 2800
+    }
+  ],
+  "rawText": "Full raw response text from the model..."
+}
+```
+
+**Where it runs:** AWS Lambda container image (Linux/AMD64)
+
+## Installation
+
+```bash
+npm install -D @twick/cloud-transcript
+```
+
+## Quick Start
+
+### 1. Scaffold AWS Lambda Template
+
+```bash
+npx twick-transcript init
+```
+
+### 2. Build Docker Image
+
+```bash
+npx twick-transcript build twick-transcript:latest
+```
+
+### 3. Configure Google Cloud
+
+**Required:**
+- Google Cloud project with Vertex AI API enabled
+- Service account with Vertex AI permissions
+
+**Environment variables:**
+- `GOOGLE_CLOUD_PROJECT` (required) — Your GCP project ID
+- `GOOGLE_CLOUD_LOCATION` (optional) — Vertex AI location (default: `"global"`)
+- `GOOGLE_VERTEX_MODEL` (optional) — Model name (default: `"gemini-2.5-flash"`)
+
+**Credentials (choose one):**
+- **File path** (recommended):
+  - Mount service account JSON and set `GOOGLE_APPLICATION_CREDENTIALS` to the file path
+- **Environment JSON** (alternative):
+  - Set `GOOGLE_KEY` to the service account JSON string
+
+### 4. Deploy to AWS Lambda
+
+```bash
+# Login to ECR
+npx twick-transcript ecr-login us-east-1 YOUR_ACCOUNT_ID
+
+# Push to ECR
+npx twick-transcript push twick-transcript:latest us-east-1 YOUR_ACCOUNT_ID
+```
+
+## Deployment (High Level)
+
+1. **Scaffold** the Lambda container template
+2. **Configure** Google Cloud credentials (file mount or environment variable)
+3. **Set environment variables** (GCP project, location, model)
+4. **Build and push** Docker image to ECR
+5. **Create Lambda function** using the ECR image
+
+The Lambda handler expects:
+- **Event format:** `{ audioUrl, language?, languageFont? }`
+- **Response:** JSON with `captions` array and `rawText` string
+
+**Note:** The audio URL must be publicly accessible via HTTP(S). Google Cloud Storage URIs (`gs://`) are not directly supported—use signed URLs instead.
+
+## Programmatic Usage
+
+Use the core transcriber directly:
+
+```js
+import { transcribeAudioUrl } from '@twick/cloud-transcript/core/transcriber.js';
+
+const result = await transcribeAudioUrl({
+  audioUrl: 'https://example.com/audio.mp3',
+  language: 'english',
+  languageFont: 'english',
+});
+
+console.log(result.captions); // Array of {t, s, e} objects
+console.log(result.rawText);  // Raw model response
+```
+
+## Technical Details
+
+- **Model:** Google Gemini (default: `gemini-2.5-flash`, configurable via `GOOGLE_VERTEX_MODEL`)
+- **Format:** Captions segmented into max 4 words per segment
+- **Timestamps:** Millisecond precision, non-overlapping segments
+- **API:** Google Vertex AI (GenAI)
+
+For detailed setup instructions, see the complete deployment guide in the repository.

package/bin/twick-transcript.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import fs from 'fs';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkgRoot = join(__dirname, '..');
+
+function copyTemplate(destDir) {
+  const templateDir = join(pkgRoot, 'platform', 'aws');
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+
+  // Create platform/aws directory structure to maintain consistency with CMD ["platform/aws/handler.handler"]
+  const platformAwsDir = join(destDir, 'platform', 'aws');
+  if (!fs.existsSync(platformAwsDir)) {
+    fs.mkdirSync(platformAwsDir, { recursive: true });
+  }
+
+  // Copy Dockerfile to root (it references platform/aws/handler.handler)
+  const dockerfileSrc = join(templateDir, 'Dockerfile');
+  const dockerfileDest = join(destDir, 'Dockerfile');
+  fs.copyFileSync(dockerfileSrc, dockerfileDest);
+
+  // Copy handler.js to platform/aws/ to match the CMD path
+  const handlerSrc = join(templateDir, 'handler.js');
+  const handlerDest = join(platformAwsDir, 'handler.js');
+  fs.copyFileSync(handlerSrc, handlerDest);
+
+  // Minimal package.json to enable docker layer caching (npm ci)
+  const pkgJsonPath = join(destDir, 'package.json');
+  if (!fs.existsSync(pkgJsonPath)) {
+    const pkg = {
+      name: 'twick-transcript-runtime',
+      private: true,
+      type: 'module',
+      dependencies: {
+        '@twick/cloud-transcript': 'latest',
+        '@ffmpeg-installer/ffmpeg': '^1.1.0',
+        '@ffprobe-installer/ffprobe': '^1.1.0'
+      }
+    };
+    fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+  }
+}
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const ps = typeof cmd === 'string' && Array.isArray(args) && args.length === 0
+      ? spawn(cmd, { stdio: 'inherit', shell: true, ...opts })
+      : spawn(cmd, args, { stdio: 'inherit', shell: true, ...opts });
+    ps.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`))));
+  });
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+
+  if (!command || ['-h', '--help', 'help'].includes(command)) {
+    console.log(`
+Usage: twick-transcript <command> [options]
+
+Commands:
+  init [dir]             Scaffold AWS container template into [dir] (default: ./twick-transcript-aws)
+  build <image> [dir]    Docker build image from [dir] (default: ./twick-transcript-aws)
+  ecr-login <region> <accountId>  Login docker to ECR
+  push <image> <region> <accountId>  Push image to ECR (repo must exist)
+
+Examples:
+  twick-transcript init
+  twick-transcript build my-repo:latest
+  twick-transcript ecr-login us-east-1 123456789012
+  twick-transcript push my-repo:latest us-east-1 123456789012
+`);
+    return;
+  }
+
+  if (command === 'init') {
+    const dir = rest[0] || 'twick-transcript-aws';
+    copyTemplate(dir);
+    console.log(`✔ Scaffolded AWS runtime into ./${dir}`);
+    return;
+  }
+
+  if (command === 'build') {
+    const image = rest[0];
+    const dir = rest[1] || 'twick-transcript-aws';
+    if (!image) throw new Error('Image name required. e.g., my-repo:latest');
+    // Build for linux/amd64 platform to avoid creating multi-arch manifest index
+    // This reduces the number of artifacts pushed to the registry
+    await run('docker', ['build', '--platform', 'linux/amd64', '-t', image, dir]);
+    return;
+  }
+
+  if (command === 'ecr-login') {
+    const region = rest[0];
+    const accountId = rest[1];
+    if (!region || !accountId) throw new Error('Usage: ecr-login <region> <accountId>');
+    const registry = `${accountId}.dkr.ecr.${region}.amazonaws.com`;
+    await run(`aws ecr get-login-password --region ${region} | docker login --username AWS --password-stdin ${registry}`, []);
+    return;
+  }
+
+  if (command === 'push') {
+    const image = rest[0];
+    const region = rest[1];
+    const accountId = rest[2];
+    if (!image || !region || !accountId) throw new Error('Usage: push <image> <region> <accountId>');
+    const [repo, tag = 'latest'] = image.split(':');
+    const registry = `${accountId}.dkr.ecr.${region}.amazonaws.com`;
+    const remote = `${registry}/${repo}:${tag}`;
+    await run('docker', ['tag', `${repo}:${tag}`, remote]);
+    await run('docker', ['push', remote]);
+    console.log(`✔ Pushed ${remote}`);
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/core/transcriber.js

@@ -0,0 +1,347 @@
+import { GoogleGenAI } from "@google/genai";
+import {
+  SecretsManagerClient,
+  GetSecretValueCommand,
+} from "@aws-sdk/client-secrets-manager";
+import fs from "fs";
+import path, { join } from "path";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { Readable, pipeline } from "stream";
+
+// These packages provide prebuilt ffmpeg/ffprobe binaries. Types are not bundled,
+// so we import them as `any` to keep TypeScript satisfied.
+import ffmpeg from "@ffmpeg-installer/ffmpeg";
+import ffprobe from "@ffprobe-installer/ffprobe";
+
+
+const execFileAsync = promisify(execFile);
+const pipelineAsync = promisify(pipeline);
+const ffmpegPath = ffmpeg.path;
+const ffprobePath = ffprobe.path;
+
+/**
+ * Read a required environment variable, optionally falling back to a default.
+ * Throws if neither value is available, making configuration errors obvious.
+ *
+ * @param {string} name - Environment variable to read.
+ * @param {string | undefined} defaultValue - Optional fallback value.
+ * @returns {string} The resolved value.
+ * @throws {Error} If no value is found.
+ */
+const ensureEnv = (name, defaultValue) => {
+  const value = process.env[name] ?? defaultValue;
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+};
+
+/**
+ * Ensure GOOGLE_APPLICATION_CREDENTIALS points to a JSON key file.
+ *
+ * In AWS Lambda, the raw service-account JSON is expected to live in
+ * AWS Secrets Manager. When GCP_SERVICE_ACCOUNT_SECRET_NAME is present, the
+ * secret is fetched, written to `/tmp/gcp-sa-key.json`, and the environment
+ * variable is updated to point at that file to avoid stale Lambda values.
+ *
+ * @returns {Promise<void>} Resolves once credentials are ready.
+ * @throws {Error} When the secret cannot be read or written.
+ */
+const ensureGoogleCredentialsFromSecret = async () => {
+  const secretName = process.env.GCP_SERVICE_ACCOUNT_SECRET_NAME;
+  if (!secretName) {
+    console.log(
+      "No secret name configured, skipping Google credentials initialization"
+    );
+    return;
+  }
+
+  try {
+    const client = new SecretsManagerClient({
+      region: process.env.AWS_REGION || "ap-south-1",
+    });
+
+    const response = await client.send(
+      new GetSecretValueCommand({
+        SecretId: secretName,
+        VersionStage: "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified
+      })
+    );
+    const secret = response.SecretString;
+    const credPath = path.join("/tmp", "gcp-sa-key.json");
+    fs.writeFileSync(credPath, secret, { encoding: "utf8" });
+    process.env.GOOGLE_APPLICATION_CREDENTIALS = credPath;
+    console.log(
+      `Wrote Google service account credentials to ${credPath} from Secrets Manager`
+    );
+  } catch (error) {
+    console.error(
+      `Failed to initialize Google credentials from secret ::`,
+      error
+    );
+    throw error;
+  }
+};
+
+/**
+ * Initialize a Google GenAI client configured for Vertex AI.
+ * Ensures credentials, project, and location are available before instantiating.
+ *
+ * @returns {Promise<GoogleGenAI>} Configured GenAI client instance.
+ * @throws {Error} When required environment variables are missing.
+ */
+const createGenAIClient = async () => {
+  await ensureGoogleCredentialsFromSecret();
+  const project = ensureEnv("GOOGLE_CLOUD_PROJECT");
+  const location = ensureEnv("GOOGLE_CLOUD_LOCATION", "global");
+  const client = new GoogleGenAI({
+    vertexai: true,
+    project: project,
+    location: location,
+  });
+
+  return client;
+};
+
+const extractAudioBufferFromVideo = async (videoUrl) => {
+  const videoResponse = await fetch(videoUrl);
+  if (!videoResponse.ok) {
+    throw new Error(`Failed to download video: ${videoResponse.status} ${videoResponse.statusText}`);
+  }
+  const tmpBase = await mkdtemp(join(tmpdir(), 'mcp-'));
+  const inputPath = join(tmpBase, 'input_video');
+  const outputPath = join(tmpBase, 'output_audio.mp3');
+
+  // Stream the video response directly to disk to avoid holding the full video in memory
+  if (!videoResponse.body) {
+    await rm(tmpBase, { recursive: true, force: true });
+    throw new Error("Video response has no body");
+  }
+  const videoStream = Readable.fromWeb(videoResponse.body);
+  const fileWriteStream = fs.createWriteStream(inputPath);
+  await pipelineAsync(videoStream, fileWriteStream);
+
+  // Get duration using bundled ffprobe
+  let duration = 0;
+  try {
+    const { stdout } = await execFileAsync(ffprobePath, [
+      '-v', 'error',
+      '-show_entries', 'format=duration',
+      '-of', 'default=noprint_wrappers=1:nokey=1',
+      inputPath
+    ]);
+    duration = parseFloat(stdout.toString().trim()) || 0;
+  } catch (err) {
+    console.warn('Failed to get duration using ffprobe, duration will be 0');
+  }
+
+  try {
+    await execFileAsync(ffmpegPath, [
+      '-y',
+      '-i', inputPath,
+      '-vn',
+      '-acodec', 'libmp3lame',
+      '-q:a', '2',
+      outputPath
+    ]);
+  } catch (err) {
+    await rm(tmpBase, { recursive: true, force: true });
+    const stderr = err?.stderr?.toString?.().trim?.() || "";
+    const msg = stderr || (err instanceof Error ? err.message : String(err));
+    throw new Error(`ffmpeg execution failed: ${msg}`);
+  }
+
+  const audioBuffer = await readFile(outputPath);
+  await rm(tmpBase, { recursive: true, force: true });
+  return { audioBuffer, duration };
+};
+
+
+/**
+ * Build the captioning prompt passed to the Gemini model.
+ *
+ * @param {number} duration - Audio duration in seconds.
+ * @param {string} language - Human-readable target language.
+ * @param {string} languageFont - Desired script/font name.
+ * @returns {string} Instruction prompt for the model.
+ */
+const buildPrompt = (duration, language, languageFont) => {
+  // Convert duration from seconds to milliseconds for the prompt
+  const durationMs = Math.round(duration * 1000);
+
+  return `You are a professional subtitle and transcription engine.
+
+## INPUT
+- Audio duration: ${durationMs} milliseconds
+- Target language: ${language}
+- Subtitle font script: ${languageFont}
+
+## OBJECTIVE
+Transcribe the audio into clear, readable subtitles.
+
+If the spoken audio is NOT in ${language}, translate it into ${language} before generating subtitles.
+
+## SUBTITLE SEGMENTATION RULES
+- Split speech into short, natural phrases.
+- Each subtitle phrase MUST contain a maximum of 4 words.
+- Do NOT split words across phrases.
+- Avoid breaking phrases mid-sentence unless required by timing constraints.
+
+## TIMING RULES (STRICT — MUST FOLLOW)
+- All timestamps are in **milliseconds**.
+- Each subtitle object MUST include:
+  - 's': start timestamp
+  - 'e': end timestamp
+- Duration of each phrase = 'e - s'
+- Minimum phrase duration: **100 ms**
+- 'e' MUST be greater than 's'
+- 'e' MUST be **less than or equal to ${durationMs}**
+- Subtitles MUST be sequential:
+  - 's' of the next phrase MUST be **greater than or equal to** the previous 'e'
+  - NO overlapping timestamps
+- Prefer aligning timestamps with natural speech pauses.
+
+## TEXT RULES
+- 't' MUST be written using ${languageFont} characters.
+- No emojis.
+- No punctuation-only subtitles.
+- Normalize casing according to the target language's writing system.
+- Remove filler sounds (e.g., “um”, “uh”) unless semantically important.
+
+## OUTPUT FORMAT (CRITICAL)
+Return ONLY a valid JSON array.
+- No markdown
+- No code blocks
+- No explanations
+- No additional text
+- Output MUST start with '[' and end with ']'
+
+## OUTPUT SCHEMA
+[
+  {
+    "t": "Subtitle text",
+    "s": 0,
+    "e": 1200
+  }
+]
+`.trim();
+};
+
+/**
+ * Transcribe an audio URL to JSON subtitles using Google GenAI (Vertex AI),
+ * mirroring the Python implementation in `playground/vertex/transcript.py`.
+ *
+ * @param {Object} params
+ * @param {string} params.videoUrl - Publicly reachable video URL.
+ * @param {string} [params.language="english"] - Target transcription language (human-readable).
+ * @param {string} [params.languageFont="english"] - Target font/script for subtitles.
+ * @returns {Promise<{ subtitles: Array<{t: string, s: number, e: number}> }>} Subtitles array with text, start time, and end time.
+ * @throws {Error} When audioUrl is missing or downstream calls fail.
+ */
+export const transcribeVideoUrl = async (params) => {
+  const {
+    videoUrl,
+    language = "english",
+    languageFont = "english",
+  } = params || {};
+
+  if (!videoUrl) {
+    throw new Error("Missing required parameter: videoUrl");
+  }
+
+  const { audioBuffer, duration } = await extractAudioBufferFromVideo(videoUrl);
+  if (!duration) {
+    throw new Error("Failed to get duration of video");
+  }
+
+  const prompt = buildPrompt(duration, language, languageFont);
+
+  const client = await createGenAIClient();
+  const modelName = process.env.GOOGLE_VERTEX_MODEL || "gemini-2.5-flash-lite";
+
+  const generationConfig = {
+    maxOutputTokens: 65535,
+    temperature: 1,
+    topP: 0.95,
+    thinkingConfig: {
+      thinkingBudget: 0,
+    },
+    safetySettings: [
+      {
+        category: "HARM_CATEGORY_HATE_SPEECH",
+        threshold: "OFF",
+      },
+      {
+        category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+        threshold: "OFF",
+      },
+      {
+        category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        threshold: "OFF",
+      },
+      {
+        category: "HARM_CATEGORY_HARASSMENT",
+        threshold: "OFF",
+      },
+    ],
+  };
+
+  const req = {
+    model: modelName,
+    contents: [
+      {
+        role: "user",
+        parts: [
+          {
+            inlineData: {
+              data: audioBuffer.toString("base64"),
+              mimeType: "audio/mpeg",
+            },
+          },
+          { text: prompt },
+        ],
+      },
+    ],
+    config: generationConfig,
+  };
+
+  const response = await client.models.generateContent(req);
+
+  let textPart = response.text || "";
+
+  // Strip markdown code fences if present (```json ... ``` or ``` ... ```)
+  textPart = textPart
+    .replace(/^```json\s*/i, "") // Remove opening ```json
+    .replace(/^```\s*/i, "") // Remove opening ```
+    .replace(/\s*```$/i, "") // Remove closing ```
+    .trim();
+
+
+  let subtitles = [];
+  try {
+    // Try to find JSON array in the text (in case there's extra text)
+    const jsonMatch = textPart.match(/\[[\s\S]*\]/);
+    const jsonText = jsonMatch ? jsonMatch[0] : textPart;
+
+    subtitles = JSON.parse(jsonText);
+    if (!Array.isArray(subtitles)) {
+      throw new Error("Parsed subtitles are not an array");
+    }
+  } catch (err) {
+    console.warn(
+      "Failed to parse model output as JSON subtitles, returning raw text",
+      err
+    );
+    console.warn("Raw response text:", textPart.substring(0, 500));
+    subtitles = [];
+  }
+
+  return {
+    subtitles,
+    duration,
+    videoUrl
+  };
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@twick/cloud-transcript",
+  "version": "0.15.1",
+  "description": "Twick cloud function for generating JSON captions from audio using Google Cloud Speech-to-Text",
+  "type": "module",
+  "main": "core/transcriber.js",
+  "exports": {
+    ".": "./core/transcriber.js",
+    "./aws": "./platform/aws/handler.js",
+    "./platform/aws/*": "./platform/aws/*"
+  },
+  "bin": {
+    "twick-transcript": "bin/twick-transcript.js"
+  },
+  "files": [
+    "core",
+    "platform",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test test/transcriber.test.js",
+    "verify:aws": "node -e \"require('fs').accessSync('platform/aws/Dockerfile'); require('fs').accessSync('platform/aws/handler.js'); console.log('AWS transcript function assets present')\"",
+    "pack:aws": "npm run verify:aws && npm pack",
+    "release:aws": "npm run verify:aws && npm publish --access public --tag aws",
+    "deploy:aws": "node scripts/deploy-aws.js",
+    "prepublishOnly": "npm run verify:aws"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "aws"
+  },
+  "keywords": [
+    "twick",
+    "audio",
+    "transcript",
+    "caption",
+    "lambda",
+    "aws",
+    "docker",
+    "google-cloud-speech"
+  ],
+  "author": "",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@google/genai": "^1.0.0",
+    "@aws-sdk/client-secrets-manager": "^3.679.0",
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@ffprobe-installer/ffprobe": "^1.1.0"
+  },
+  "devDependencies": {
+    "typescript": "~5.4.5",
+    "dotenv": "^16.4.5"
+  }
+}

package/platform/aws/Dockerfile

@@ -0,0 +1,14 @@
+FROM --platform=linux/amd64 public.ecr.aws/lambda/nodejs:20
+
+# Copy package files for better caching
+COPY package.json package-lock.json* ./
+
+RUN npm install
+
+# Copy source code
+COPY . ./
+
+# Default Lambda handler
+CMD ["platform/aws/handler.handler"]
+
+

package/platform/aws/handler.js

@@ -0,0 +1,90 @@
+import { transcribeVideoUrl } from '@twick/cloud-transcript';
+
+const jsonResponse = (statusCode, body) => ({
+  statusCode,
+  headers: {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Access-Control-Allow-Methods': 'POST, OPTIONS',
+  },
+  body: JSON.stringify(body),
+});
+
+/**
+ * AWS Lambda handler for generating captions using Google Cloud Speech-to-Text.
+ *
+ * Expected JSON payload (e.g. via AppSync / Lambda resolver):
+ * {
+ *   "videoUrl": "https://example.com/audio.mp3", // or "gs://bucket/object"
+ *   "languageCode": "en-US", // optional, defaults to "en-US"
+ *   "encoding": "MP3",        // optional
+ *   "sampleRateHertz": 16000  // optional
+ * }
+ *
+ * Environment variables:
+ * - GOOGLE_CLOUD_PROJECT: Explicit Google Cloud project id.
+ * - GOOGLE_CLOUD_LOCATION (optional): Location of the Google Cloud project.  
+ * - GOOGLE_VERTEX_MODEL (optional): Model to use for transcription.
+ *
+ * Returns: JSON payload containing transcript text, caption segments, and word-level timings.
+ */
+export const handler = async (event) => {
+  console.log('Transcript function invoked');
+  console.log('Event:', JSON.stringify(event));
+
+  if (event.httpMethod === 'OPTIONS') {
+    return {
+      statusCode: 204,
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': 'Content-Type',
+        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+      },
+      body: '',
+    };
+  }
+
+  try {
+    const argumentsPayload =
+      event?.arguments ||
+      (event?.body ? JSON.parse(event.body) : {}) ||
+      {};
+
+    const { videoUrl, language,languageFont } =
+      argumentsPayload;
+
+    if (!videoUrl) {
+      return jsonResponse(400, {
+        error: 'Missing required field: videoUrl',
+        expectedFormat: {
+          videoUrl:
+            'Publicly reachable audio URL or "gs://bucket/object" for GCS',
+          language: 'Optional language (e.g., "english", "hindi")',
+          languageFont: 'Optional font/script for captions (e.g., "english")',
+        },
+      });
+    }
+
+    const result = await transcribeVideoUrl({
+      videoUrl,
+      language,
+      languageFont,
+    });
+
+    console.log('Transcription completed successfully');
+
+    return jsonResponse(200, {
+      ...result,
+    });
+  } catch (error) {
+    console.error('Error generating transcript:', error);
+
+    return jsonResponse(500, {
+      error: 'Internal server error',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+};
+
+