@vertesia/workflow 1.2.0 → 1.3.0-dev.20260620.091720Z

package/src/activities/media/transcribeMediaWithGladia.ts

@@ -1,10 +1,17 @@
-import { activityInfo, CompleteAsyncError, log } from "@temporalio/activity";
-import { FetchClient, RequestError } from "@vertesia/api-fetch-client";
-import { AUDIO_RENDITION_NAME, ContentNature, DSLActivityExecutionPayload, DSLActivitySpec, GladiaConfiguration, SupportedIntegrations, VideoMetadata } from "@vertesia/common";
-import { setupActivity } from "../../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError } from "../../errors.js";
-import { TextExtractionResult, TextExtractionStatus } from "../../index.js";
-
+import { activityInfo, CompleteAsyncError, log } from '@temporalio/activity';
+import { FetchClient, RequestError } from '@vertesia/api-fetch-client';
+import {
+    AUDIO_RENDITION_NAME,
+    ContentNature,
+    type DSLActivityExecutionPayload,
+    type DSLActivitySpec,
+    type GladiaConfigurationWithSecrets,
+    SupportedIntegrations,
+    type VideoMetadata,
+} from '@vertesia/common';
+import { setupActivity } from '../../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError } from '../../errors.js';
+import { type TextExtractionResult, TextExtractionStatus } from '../../index.js';
 
 export interface TranscriptMediaParams {
     environmentId?: string;
@@ -25,33 +32,37 @@ export interface TranscriptMediaResult extends TextExtractionResult {
     gladiaTranscriptionId?: string;
 }
 
-const GLADIA_URL = "https://api.gladia.io/v2";
-
-export async function transcribeMedia(payload: DSLActivityExecutionPayload<TranscriptMediaParams>): Promise<TranscriptMediaResult> {
+const GLADIA_URL = 'https://api.gladia.io/v2';
 
+export async function transcribeMedia(
+    payload: DSLActivityExecutionPayload<TranscriptMediaParams>,
+): Promise<TranscriptMediaResult> {
     const context = await setupActivity<TranscriptMediaParams>(payload);
     const { params, client, inputType } = context;
 
-    const gladiaConfig = await client.projects.integrations.retrieve(payload.project_id, SupportedIntegrations.gladia) as GladiaConfiguration | undefined;
-    if (!gladiaConfig || !gladiaConfig.enabled) {
+    const gladiaConfig = (await client.projects.integrations.retrieve(
+        payload.project_id,
+        SupportedIntegrations.gladia,
+    )) as GladiaConfigurationWithSecrets | undefined;
+    if (!gladiaConfig?.enabled) {
         return {
             hasText: false,
             objectId: inputType === 'objectIds' ? context.objectId : undefined,
             status: TextExtractionStatus.error,
-            error: "Gladia integration not enabled",
-        }
+            error: 'Gladia integration not enabled',
+        };
     }
     if (!gladiaConfig.api_key) {
         return {
             hasText: false,
             objectId: inputType === 'objectIds' ? context.objectId : undefined,
             status: TextExtractionStatus.error,
-            error: "Gladia API key not configured",
-        }
+            error: 'Gladia API key not configured',
+        };
     }
 
     const gladiaClient = new FetchClient(gladiaConfig.url ?? GLADIA_URL);
-    gladiaClient.withHeaders({ "x-gladia-key": gladiaConfig.api_key });
+    gladiaClient.withHeaders({ 'x-gladia-key': gladiaConfig.api_key });
 
     let mediaSource: string;
     let storageId: string;
@@ -59,10 +70,15 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
     if (inputType === 'objectIds') {
         // Object mode: fetch from object store
         const objectId = context.objectId;
-        const object = await client.objects.retrieve(objectId, "+text");
+        const object = await client.objects.retrieve(objectId, '+text');
 
         if (object.text && !params.force) {
-            return { hasText: true, objectId, status: TextExtractionStatus.skipped, message: "text already present and force not enabled" }
+            return {
+                hasText: true,
+                objectId,
+                status: TextExtractionStatus.skipped,
+                message: 'text already present and force not enabled',
+            };
         }
 
         if (!object.content?.source) {
@@ -73,7 +89,7 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
         mediaSource = object.content.source;
         if (object.metadata?.type === ContentNature.Video) {
             const videoMetadata = object.metadata as VideoMetadata;
-            const audioRendition = videoMetadata.renditions?.find(r => r.name === AUDIO_RENDITION_NAME);
+            const audioRendition = videoMetadata.renditions?.find((r) => r.name === AUDIO_RENDITION_NAME);
             if (audioRendition?.content?.source) {
                 mediaSource = audioRendition.content.source;
                 log.info(`Found audio rendition for video object ${objectId}`, { mediaSource });
@@ -85,7 +101,7 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
         // File mode: use file input
         const file = context.file;
         if (!params.output_storage_path) {
-            throw new DocumentNotFoundError("output_storage_path is required when using file input");
+            throw new DocumentNotFoundError('output_storage_path is required when using file input');
         }
 
         mediaSource = file.url;
@@ -107,7 +123,7 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
     log.info(`Transcribing media ${mediaUrl} with Gladia`, { storageId, callbackUrl });
 
     try {
-        const res = await gladiaClient.post("/transcription", {
+        const res = (await gladiaClient.post('/transcription', {
             payload: {
                 audio_url: mediaUrl,
                 callback_url: callbackUrl,
@@ -115,19 +131,19 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
                 enable_code_switching: true,
                 subtitles: true,
                 subtitles_config: {
-                    formats: ["vtt"],
-                }
-            }
-        }) as GladiaTranscriptRequestResponse;
+                    formats: ['vtt'],
+                },
+            },
+        })) as GladiaTranscriptRequestResponse;
         log.info(`Transcription request sent to Gladia`, { storageId, res });
-    } catch (error: any) {
+    } catch (error: unknown) {
         if (error instanceof RequestError && error.status === 422) {
             return {
                 hasText: false,
                 objectId: storageId,
                 status: TextExtractionStatus.error,
                 error: `Gladia transcription error: ${error.message}`,
-            }
+            };
         }
         log.error(`Error sending transcription request to Gladia for storage ${storageId}`, { error });
         throw error;

package/src/activities/mergeChildArtifacts.ts

@@ -1,8 +1,9 @@
-import { log } from "@temporalio/activity";
-import { NodeStreamSource } from "@vertesia/client/node";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import { Readable } from "stream";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { Readable } from 'node:stream';
+import { log } from '@temporalio/activity';
+import type { VertesiaClient } from '@vertesia/client';
+import { NodeStreamSource } from '@vertesia/client/node';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
 
 /**
  * Directories to merge from child to parent.
@@ -18,7 +19,7 @@ const EXCLUDED_FILES = ['conversation.json', 'tools.json'];
 export interface MergeChildArtifactsParams {
     child_run_id: string;
     parent_run_id: string;
-    directories?: string[];  // defaults to MERGE_DIRECTORIES
+    directories?: string[]; // defaults to MERGE_DIRECTORIES
 }
 
 export interface MergeChildArtifacts extends DSLActivitySpec<MergeChildArtifactsParams> {
@@ -36,7 +37,7 @@ export interface MergeChildArtifacts extends DSLActivitySpec<MergeChildArtifacts
  * Returns the list of merged paths in the parent's space for the model to access.
  */
 export async function mergeChildArtifacts(
-    payload: DSLActivityExecutionPayload<MergeChildArtifactsParams>
+    payload: DSLActivityExecutionPayload<MergeChildArtifactsParams>,
 ): Promise<{ merged: number; files: string[] }> {
     const { client, params } = await setupActivity<MergeChildArtifactsParams>(payload);
     const childRunId = params.child_run_id;
@@ -49,7 +50,7 @@ export async function mergeChildArtifacts(
     const childFiles = await client.files.listArtifacts(childRunId);
 
     if (childFiles.length === 0) {
-        log.info("No artifacts in child agent space");
+        log.info('No artifacts in child agent space');
         return { merged: 0, files: [] };
     }
 
@@ -72,8 +73,9 @@ export async function mergeChildArtifacts(
             const namespacedPath = createNamespacedPath(relativePath, childRunId);
             await copyArtifact(client, childRunId, parentRunId, relativePath, namespacedPath);
             mergedFiles.push(namespacedPath);
-        } catch (err: any) {
-            log.warn(`Failed to merge ${relativePath}: ${err.message}`);
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            log.warn(`Failed to merge ${relativePath}: ${message}`);
         }
     }
 
@@ -132,28 +134,24 @@ function extractRelativePath(fullPath: string, runId: string): string | null {
  * Copy a single artifact from child to parent agent space with a new path
  */
 async function copyArtifact(
-    client: any,
+    client: VertesiaClient,
     childRunId: string,
     parentRunId: string,
     sourcePath: string,
-    destPath: string
+    destPath: string,
 ): Promise<void> {
     // Download from child's agent space
     const stream = await client.files.downloadArtifact(childRunId, sourcePath);
 
     // Convert web stream to node stream for upload
-    const nodeStream = Readable.fromWeb(stream as any);
+    const nodeStream = Readable.fromWeb(stream as ReadableStream<Uint8Array>);
 
     // Determine mime type from extension
     const mimeType = getMimeType(sourcePath);
     const fileName = sourcePath.split('/').pop() || sourcePath;
 
     // Upload to parent's agent space at the namespaced path
-    const source = new NodeStreamSource(
-        nodeStream,
-        fileName,
-        mimeType
-    );
+    const source = new NodeStreamSource(nodeStream, fileName, mimeType);
 
     await client.files.uploadArtifact(parentRunId, destPath, source);
 }
@@ -164,26 +162,26 @@ async function copyArtifact(
 function getMimeType(filePath: string): string {
     const ext = filePath.split('.').pop()?.toLowerCase();
     const mimeTypes: Record<string, string> = {
-        'json': 'application/json',
-        'txt': 'text/plain',
-        'md': 'text/markdown',
-        'html': 'text/html',
-        'csv': 'text/csv',
-        'png': 'image/png',
-        'jpg': 'image/jpeg',
-        'jpeg': 'image/jpeg',
-        'gif': 'image/gif',
-        'svg': 'image/svg+xml',
-        'pdf': 'application/pdf',
-        'xml': 'application/xml',
-        'zip': 'application/zip',
-        'js': 'application/javascript',
-        'ts': 'application/typescript',
-        'py': 'text/x-python',
-        'sh': 'text/x-shellscript',
-        'bash': 'text/x-shellscript',
-        'yaml': 'text/yaml',
-        'yml': 'text/yaml',
+        json: 'application/json',
+        txt: 'text/plain',
+        md: 'text/markdown',
+        html: 'text/html',
+        csv: 'text/csv',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        pdf: 'application/pdf',
+        xml: 'application/xml',
+        zip: 'application/zip',
+        js: 'application/javascript',
+        ts: 'application/typescript',
+        py: 'text/x-python',
+        sh: 'text/x-shellscript',
+        bash: 'text/x-shellscript',
+        yaml: 'text/yaml',
+        yml: 'text/yaml',
     };
     return mimeTypes[ext || ''] || 'application/octet-stream';
 }