@vertesia/workflow 0.78.0 → 0.79.0

package/src/activities/notifyWebhook.ts

@@ -1,15 +1,29 @@
 import { log } from "@temporalio/activity";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { VertesiaClient } from "@vertesia/client";
+import { ApiVersions, DSLActivityExecutionPayload, DSLActivitySpec, WebHookSpec, WorkflowExecutionBaseParams } from "@vertesia/common";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
 import { WorkflowParamNotFoundError } from "../errors.js";
+import { getVertesiaClientOptions } from "../utils/client.js";
 
 export interface NotifyWebhookParams {
-    target_url: string; //URL to send the notification to
+    webhook: string | WebHookSpec; //URL to send the notification to
+    workflow_id: string; //The ID of the workflow sending the notification
+    workflow_type: string; //The type of workflow sending the notification (the wf function name)
+    workflow_run_id: string; //The ID of the specific workflow run sending the notification
+    event_name: string; //The event that triggered the notification (e.g. "completed", "failed", etc.)
+    detail?: Record<string, any>; // additional data about the event if any. It will be send to the webhook when using POST 
+    //target_url: string; //URL to send the notification to
     method: 'GET' | 'POST'; //HTTP method to use
-    payload: Record<string, any>; //payload to send (if POST then as JSON body, if GET then as query string)
-    headers?: Record<string, string>; //additional headers to send
+    headers?: Record<string, string>; // additional headers to send
 }
 
+export interface WebhookNotificationPayload {
+    workflow_id: string,
+    workflow_name: string,
+    workflow_run_id: string,
+    event_name: string,
+    detail?: Record<string, any>,
+}
 
 export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
     name: 'notifyWebhook';
@@ -19,32 +33,166 @@ export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
 export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyWebhookParams>) {
 
     const { params } = await setupActivity<NotifyWebhookParams>(payload);
-    const { target_url, method, payload: requestPayload, headers } = params
+    const { webhook, method, headers: defaultHeaders } = params
+    // resolve the url and the api version of the webhook
+    let target_url: string, version: number | undefined;
+    if (typeof webhook === 'string') {
+        target_url = webhook;
+    } else {
+        target_url = webhook.url;
+        version = webhook.version;
+    }
 
     if (!target_url) throw new WorkflowParamNotFoundError('target_url');
 
-    const body = method === 'POST' ? JSON.stringify({
-        ...requestPayload,
-    }) : undefined
+    const hasBody = params.detail && method === 'POST'; //body is sent only for POST
+
+    const headers = {
+        ...defaultHeaders,
+    };
+    if (hasBody) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const body = hasBody ? await createRequestBody(payload, params, version) : undefined
 
     log.info(`Notifying webhook at ${target_url}`);
     const res = await fetch(target_url, {
         method,
         body,
-        headers: {
-            'Content-Type': 'application/json',
-            ...headers
-        },
+        headers,
     }).catch(err => {
-        log.warn(`Failed to notify webhook ${target_url}: ${err}`);
-        throw new Error(`Failed to notify webhook ${target_url}: ${err}`);
+        log.error(`An error occurred while notifying webhook at ${target_url}`, { err });
+        throw err;
     });
 
     if (!res.ok) {
-        log.warn(`Failed to notify webhook ${target_url} - ${res.status}: ${res.statusText}`, { res });
-        throw new Error(`Failed to notify webhook ${target_url}: ${res.statusText}`);
+        log.warn(`Webhook endpoint ${target_url} returned an error - ${res.status} ${res.statusText}`, { fetchResponse: res });
+
+        // Try to get response payload for error message
+        let errorMessage = `Webhook Notification to ${target_url} failed with status: ${res.status} ${res.statusText}`;
+        try {
+            const responseText = await res.text();
+            if (responseText) {
+                errorMessage += ` - Response: ${responseText}`;
+            }
+        } catch (readError) {
+            // If we can't read the response, just use the basic error message
+            log.debug('Could not read response body for error', { readError });
+        }
+
+        throw new Error(errorMessage);
     }
 
     return { status: res.status, message: res.statusText, url: res.url }
 
 }
+
+
+
+// --------------------------------------
+// Data provider for webhooks
+// this allows to customize the payload sent to the webhook depending on the 
+// type of workflow and the api version of the webhook
+// --------------------------------------
+
+
+function getWorkflowName(workflowType: string): string {
+    // remove trailing Workflow or _Workflow case insensitive from the workflow type
+    return workflowType.replace(/_?workflow$/i, '');
+}
+
+async function createRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<string> {
+    if (api_version === undefined || Number(api_version) < ApiVersions.COMPLETION_RESULT_V1) {
+        return createOldRequestBody(payload, params);
+    } else {
+        return createLatestRequestBody(payload, params, api_version);
+    }
+}
+
+async function createLatestRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<string> {
+    const data = await createEventData(payload, params, api_version);
+    return JSON.stringify({
+        workflow_id: params.workflow_id,
+        workflow_name: getWorkflowName(params.workflow_type),
+        workflow_run_id: params.workflow_run_id,
+        event_name: params.event_name,
+        detail: data,
+    } satisfies WebhookNotificationPayload);
+}
+
+async function createEventData(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<any> {
+    const data = params.detail;
+    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+        const client = getVersionedVertesiaClient(payload, api_version); //ensure client is initialized
+        // we replace the result property with the full execution run object
+        return await client.runs.retrieve(data.run_id);
+    }
+    return data;
+}
+
+
+function getVersionedVertesiaClient(payload: WorkflowExecutionBaseParams, version: string | number | undefined | null) {
+    // set the api version header
+    return new VertesiaClient(getVertesiaClientOptions(payload)).withApiVersion(version ? String(version) : null);
+}
+
+
+// ----------------- Compatibility code -----------------
+/* Before 2025-10-08 the notifyWebhook POST body was in the format:
+
+{
+    "workflowId": "generation:ExecuteInteractionWorkflow:WhatColor:ox8wu6t4",
+    "runId": "0199c2c6-818f-77eb-b931-c1ba8b9e5184",
+    "status": "completed",
+    "result": {
+        "run_id": "68e616274b0e9bb510462378",
+        "status": "completed",
+        "result": {"Color": "white"}
+    }
+}
+
+After Versions.COMPLETION_RESULT_V1  (20250925) when the completion result interface changed we improved the
+payload to the current format:
+
+{
+    "workflow_id": "generation:ExecuteInteractionWorkflow:WhatColor:bdedqjqj6",
+    "workflow_name": "ExecuteInteraction",
+    "workflow_run_id": "0199c2d4-6b1d-7cf2-a1e5-4cac6778091e",
+    "event_name": "workflow_completed",
+    "detail": ExecutionRun
+}
+
+where ExecutionRun contains a result property with the new completion result format.
+
+"result": [
+    {
+        "type": "json",
+        "value": {
+            "Color": "white"
+        }
+    }
+],
+
+*/
+
+//@ts-ignore
+async function createOldRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams): Promise<string> {
+    let data = params.detail;
+    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+        const client = getVersionedVertesiaClient(payload, null); //ensure client is using no specific version
+        const run = await client.runs.retrieve(data.run_id);
+        // since we use an unversioned client the run will be in old format so we don't need to tranform the result
+        const result = run.result;
+        data = {
+            workflowId: params.workflow_id,
+            runId: params.workflow_run_id,
+            status: params.event_name === 'workflow_completed' ? 'completed' : params.event_name,
+            result: {
+                run_id: run.id,
+                status: run.status,
+                result: result || null
+            }
+        };
+    }
+    return JSON.stringify(data || {});
+}

package/src/activities/rateLimiter.ts

@@ -0,0 +1,41 @@
+import { DSLActivityExecutionPayload, RateLimitRequestPayload } from "@vertesia/common";
+import { activityInfo, log } from "@temporalio/activity";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+
+export interface RateLimitParams {
+  interactionIdOrEndpoint: string;
+  environmentId?: string;
+  modelId?: string;
+}
+
+export interface RateLimitResult {
+  delayMs: number;
+}
+
+export async function checkRateLimit(payload: DSLActivityExecutionPayload<RateLimitParams>): Promise<RateLimitResult> {
+  const { client, params } = await setupActivity<RateLimitParams>(payload);
+  const { environmentId, modelId } = params;
+  
+  const result: RateLimitResult = {
+    delayMs: 0,
+  }
+
+  try {
+    // Call the studio-server endpoint to get rate limit delay using the Vertesia client
+    const info = activityInfo();
+    const requestPayload: RateLimitRequestPayload = {
+      interaction: params.interactionIdOrEndpoint,
+      workflow_run_id: info.workflowExecution.runId,
+      environment_id: environmentId,
+      model_id: modelId,
+    };
+    
+    const response = await client.interactions.requestSlot(requestPayload);
+    result.delayMs = response.delay_ms;
+  } catch (error) {
+    log.warn('Failed to call rate limit API:', {error});
+    throw error;
+  }
+
+  return result;
+}

package/src/conversion/image.ts

@@ -78,6 +78,12 @@ export async function imageResizer(
         const command = `convert`
         let args = [inputPath];
 
+        // Add JPEG shrink-on-load optimization
+        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
+
+        // Remove metadata
+        args.push("-strip");
+
         // https://usage.imagemagick.org/filter/nicolas/#downsample
         // Add colorspace correction if enabled
         if (colorspaceCorrection) {
@@ -110,9 +116,6 @@ export async function imageResizer(
             }
         }
 
-        // Add JPEG shrink-on-load optimization
-        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
-
         // Resize operation
         args.push("-resize", `${max_hw}x${max_hw}>`);
 

package/src/dsl/dsl-workflow.ts

@@ -7,6 +7,7 @@ import {
     log,
     patched,
     proxyActivities,
+    sleep,
     startChild,
     UntypedActivities,
 } from "@temporalio/workflow";
@@ -18,6 +19,7 @@ import {
     DSLWorkflowExecutionPayload,
     DSLWorkflowSpec,
     getDocumentIds,
+    getTenantId,
     WorkflowExecutionPayload
 } from "@vertesia/common";
 import ms, { StringValue } from 'ms';
@@ -25,6 +27,8 @@ import { HandleDslErrorParams } from "../activities/handleError.js";
 import * as activities from "../activities/index.js";
 import { WF_NON_RETRYABLE_ERRORS, WorkflowParamNotFoundError } from "../errors.js";
 import { Vars } from "./vars.js";
+import { RateLimitParams } from "../activities/rateLimiter.js";
+
 
 interface BaseActivityPayload extends WorkflowExecutionPayload {
     workflow_name: string;
@@ -172,6 +176,7 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
             AccountId: [payload.account_id],
             DocumentId: getDocumentIds(payload),
             ProjectId: [payload.project_id],
+            TenantId: [getTenantId(payload.account_id, payload.project_id)],
             InitiatedBy: payload.initiated_by ? [payload.initiated_by] : [],
         },
     });
@@ -204,6 +209,7 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
             AccountId: [payload.account_id],
             DocumentId: getDocumentIds(payload),
             ProjectId: [payload.project_id],
+            TenantId: [getTenantId(payload.account_id, payload.project_id)],
             InitiatedBy: payload.initiated_by ? [payload.initiated_by] : [],
         },
     });
@@ -218,6 +224,48 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
     }
 }
 
+function buildRateLimitParams(activity: DSLActivitySpec, executionPayload: DSLActivityExecutionPayload<any>): RateLimitParams {
+    const params = executionPayload.params;
+    let interactionId: string;
+
+    switch (activity.name) {
+        case "executeInteraction":
+            interactionId = params.interactionName;
+            break;
+
+        case "generateDocumentProperties":
+            interactionId = params.interactionName || "sys:ExtractInformation";
+            break;
+
+        case "identifyTextSections":
+            interactionId = params.interactionName || "sys:IdentifyTextSections";
+            break;
+
+        case "generateOrAssignContentType":
+            interactionId = params.interactionNames?.selectDocumentType || "sys:SelectDocumentType";
+            break;
+
+        case "chunkDocument":
+            interactionId = params.interactionName || "sys:ChunkDocument";
+            break;
+
+        default:
+            // For any other rate-limited activities, try to extract what we can
+            interactionId = params.interactionName;
+            break;
+    }
+
+    if (!interactionId) {
+        throw new Error(`No interaction ID could be determined for activity ${activity.name}`);
+    }
+
+    return {
+        interactionIdOrEndpoint: interactionId,
+        environmentId: params.environment,
+        modelId: params.model,
+    };
+}
+
 async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityPayload, vars: Vars, defaultProxy: ActivityInterfaceFor<UntypedActivities>, defaultOptions: ActivityOptions) {
     if (basePayload.debug_mode) {
         log.debug(`Workflow vars before executing activity ${activity.name}`, { vars: vars.resolve() });
@@ -245,6 +293,38 @@ async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityP
         });
     }
 
+    if (patched('system-activity-taskqueue')) {
+        // hack: do nothing, remove later
+        // https://github.com/vertesia/composableai/pull/544/files
+    }
+
+    // call rate limiter depending on the activity type
+    const rateLimitedActivities = [
+        "chunkDocument",
+        "executeInteraction",
+        "generateDocumentProperties",
+        "generateOrAssignContentType",
+        "identifyTextSections",
+    ];
+
+    if (activity.name && rateLimitedActivities.includes(activity.name)) {
+        log.info(`Applying rate limit for activity ${activity.name}`);
+        // Apply rate limiting logic here
+         // Check rate limit first - loop until no delay
+        const rateLimitParams = buildRateLimitParams(activity, executionPayload);
+
+        const rateLimitPayload = dslActivityPayload(basePayload, activity, rateLimitParams);
+        let rateLimitResult = await proxy.checkRateLimit(rateLimitPayload);
+    
+        while (rateLimitResult.delayMs > 0) {
+            log.info(`Rate limit delay applied: ${rateLimitResult.delayMs}ms`);
+            await sleep(rateLimitResult.delayMs);
+
+            // Check again after sleeping
+            rateLimitResult = await proxy.checkRateLimit(rateLimitPayload);
+        }
+    }
+
     const fn = proxy[activity.name];
     if (activity.parallel) {
         //TODO execute in parallel

package/src/dsl/workflow-exec-child.test.ts

@@ -129,6 +129,7 @@ describe('DSL Workflow with child workflows', () => {
                 AccountId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 DocumentId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 ProjectId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                TenantId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 InitiatedBy: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
             },
         });

package/src/dsl/workflow.test.ts

@@ -60,6 +60,7 @@ describe('DSL Workflow', () => {
                 AccountId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 DocumentId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 ProjectId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                TenantId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 InitiatedBy: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
             },
         });

package/src/errors.ts

@@ -51,6 +51,19 @@ export class WorkflowParamNotFoundError extends ApplicationFailure {
     }
 }
 
+export class ResourceExhaustedError extends ApplicationFailure {
+    constructor(
+        public statusCode: number = 429,
+        message?: string,
+    ) {
+        super(
+            message || "Resource exhausted - rate limit exceeded",
+            "ResourceExhaustedError",
+            true, // non-retryable
+        );
+    }
+}
+
 export const WF_NON_RETRYABLE_ERRORS = [
     "DocumentNotFoundError",
     "ActivityParamInvalidError",

package/src/index.ts

@@ -18,11 +18,11 @@ export * from "./activities/executeInteraction.js";
 export * from "./activities/extractDocumentText.js";
 export * from "./activities/generateDocumentProperties.js";
 export * from "./activities/generateEmbeddings.js";
-export * from "./activities/identifyTextSections.js";
 export * from "./activities/renditions/generateImageRendition.js";
 export * from "./activities/renditions/generateVideoRendition.js";
 export * from "./activities/generateOrAssignContentType.js";
 export * from "./activities/notifyWebhook.js";
+export * from "./activities/rateLimiter.js";
 export * from "./activities/setDocumentStatus.js";
 export * from "./iterative-generation/activities/index.js";
 

package/src/iterative-generation/activities/generatePart.ts

@@ -5,6 +5,7 @@ import { getVertesiaClient } from "../../utils/client.js";
 import { buildAndPublishMemoryPack, loadMemoryPack } from "../../utils/memory.js";
 import { IterativeGenerationPayload, OutputMemoryMeta, Section, TocPart, TocSection } from "../types.js";
 import { executeWithVars, expectMemoryIsConsistent } from "../utils.js";
+import { completionResultToString } from "@llumiverse/common";
 
 export async function it_gen_generatePart(payload: WorkflowExecutionPayload, path: number[]) {
     const vars = payload.vars as IterativeGenerationPayload;
@@ -56,7 +57,7 @@ export async function it_gen_generatePart(payload: WorkflowExecutionPayload, pat
         }
     });
 
-    const result = r.result as string;
+    const result = r.result.map(completionResultToString).join('\n');
     content[content.length - 1].content += result;
     meta.lastProcessedPart = path;
     await buildAndPublishMemoryPack(client, `${memory}/output`, async ({ copyText }) => {

package/src/iterative-generation/activities/generateToc.ts

@@ -3,6 +3,7 @@ import { getVertesiaClient } from "../../utils/client.js";
 import { buildAndPublishMemoryPack } from "../../utils/memory.js";
 import { IterativeGenerationPayload, OutputMemoryMeta, Toc, TocIndex } from "../types.js";
 import { executeWithVars, tocIndex } from "../utils.js";
+import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 const defaultTocSchema = {
     "type": "object",
@@ -84,14 +85,19 @@ export async function it_gen_generateToc(payload: WorkflowExecutionPayload): Pro
 
     const run = await executeWithVars(client, vars.interaction, vars, undefined, schema);
 
-    const toc = run.result as Toc;
+    //Parse the CompletionResult[] to get a Toc object
+    const jsonResults = parseCompletionResultsToJson(run.result);
+
+    const toc: Toc = {
+        sections: jsonResults.sections
+    };
 
     await buildAndPublishMemoryPack(client, `${vars.memory}/output`, async () => {
         return {
             toc,
             lastProcessedPart: undefined, // the part index (a number array)
             previouslyGenerated: ""
-        } as OutputMemoryMeta
+        } satisfies OutputMemoryMeta
     });
 
     return tocIndex(toc);

package/src/iterative-generation/utils.ts

@@ -15,7 +15,7 @@ export interface ExecuteOptions {
     result_schema?: Record<string, any>;
 }
 
-export async function execute<T = any>(client: VertesiaClient, options: ExecuteOptions): Promise<ExecutionRun<any, T>> {
+export async function execute(client: VertesiaClient, options: ExecuteOptions): Promise<ExecutionRun> {
     return client.interactions.executeByName(options.interaction, {
         data: {
             ...options.memory_mapping,
@@ -30,7 +30,7 @@ export async function execute<T = any>(client: VertesiaClient, options: ExecuteO
     });
 }
 
-export function executeWithVars<T = any>(client: VertesiaClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>): Promise<ExecutionRun<any, T>> {
+export function executeWithVars(client: VertesiaClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>): Promise<ExecutionRun> {
     if (mapping) {
         mapping = { ...vars.input_mapping, ...mapping };
     } else {

package/src/system/notifyWebhookWorkflow.ts

@@ -1,6 +1,6 @@
 
-import { log } from "@temporalio/workflow";
-import { WorkflowExecutionPayload } from "@vertesia/common";
+import { log, workflowInfo } from "@temporalio/workflow";
+import { WebHookSpec, WorkflowExecutionPayload } from "@vertesia/common";
 import * as activities from "../activities/notifyWebhook.js";
 import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
 import { WF_NON_RETRYABLE_ERRORS } from "../errors.js";
@@ -19,19 +19,25 @@ const {
 });
 
 export interface NotifyWebhookWorfklowParams {
-    endpoints: string[],
+    workflow_type: string;
+    endpoints: (string | WebHookSpec)[],
     data: Record<string, any>
 }
 
 
 export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload<NotifyWebhookWorfklowParams>): Promise<any> {
 
+    const info = workflowInfo();
     const { objectIds, vars } = payload;
     const notifications = [];
     const endpoints = vars.endpoints ?? (vars as any).webhooks ?? [];
     const data = vars.data ?? (vars as any).webhook_data ?? undefined;
+    const workflow_type = vars.workflow_type ?? info.workflowType;
     const eventName = payload.event;
 
+    const workflowId = info.parent?.workflowId || info.workflowId;
+    const workflowRunId = info.parent?.runId || info.runId;
+
     if (!endpoints.length) {
         log.info(`No webhooks to notify`);
         return { notifications: [], message: "No webhooks to notify" };
@@ -39,11 +45,14 @@ export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload<No
 
     for (const ep of endpoints) {
         const n = notifyWebhook(payload, {
-            target_url: ep,
+            webhook: ep,
             method: 'POST',
-            payload: {
+            workflow_type,
+            workflow_id: workflowId,
+            workflow_run_id: workflowRunId,
+            event_name: eventName,
+            detail: {
                 object_ids: objectIds,
-                event: eventName,
                 data
             }
         }).then(res => {

package/lib/cjs/activities/identifyTextSections.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.identifyTextSections = identifyTextSections;
-const activity_1 = require("@temporalio/activity");
-const ActivityContext_js_1 = require("../dsl/setup/ActivityContext.js");
-const executeInteraction_js_1 = require("./executeInteraction.js");
-const INT_GENERATE_TEXT_PARTS = "sys:IdentifyTextSections";
-async function identifyTextSections(payload) {
-    const context = await (0, ActivityContext_js_1.setupActivity)(payload);
-    const { params, client, objectId } = context;
-    const interactionName = params.interactionName ?? INT_GENERATE_TEXT_PARTS;
-    const project = await context.fetchProject();
-    const doc = await client.objects.retrieve(objectId, "+text");
-    const text = doc.text;
-    if (!text || text.length === 0) {
-        activity_1.log.warn(`No text found for object ${objectId}`);
-        return;
-    }
-    //instrument the text with line numbers
-    const lines = text.split('\n');
-    const instrumented = lines.map((l, i) => `{%${i}%}${l}`).join('\n');
-    const promptData = {
-        content: instrumented ?? undefined,
-        human_context: project?.configuration?.human_context ?? undefined,
-    };
-    const infoRes = await (0, executeInteraction_js_1.executeInteractionFromActivity)(client, interactionName, {
-        ...params,
-        include_previous_error: true,
-        validate_result: true,
-    }, promptData, payload.debug_mode ?? false);
-    const parts = infoRes.result.parts;
-    if (!parts || !Array.isArray(parts) || parts.length === 0) {
-        activity_1.log.warn(`No text parts generated for object ${objectId}`);
-        return;
-    }
-    const existingMetadata = doc.metadata;
-    const updatedMetadata = {
-        type: "document",
-        ...existingMetadata,
-        generation_runs: existingMetadata?.generation_runs ?? [],
-        sections: parts
-    };
-    await client.objects.update(doc.id, {
-        metadata: updatedMetadata,
-    });
-    return { status: "completed" };
-}
-//# sourceMappingURL=identifyTextSections.js.map

package/lib/cjs/activities/identifyTextSections.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identifyTextSections.js","sourceRoot":"","sources":["../../../src/activities/identifyTextSections.ts"],"names":[],"mappings":";;AAaA,oDAyDC;AAtED,mDAA2C;AAE3C,wEAAgE;AAChE,mEAAqG;AAErG,MAAM,uBAAuB,GAAG,0BAA0B,CAAC;AAQpD,KAAK,UAAU,oBAAoB,CACtC,OAAgE;IAEhE,MAAM,OAAO,GAAG,MAAM,IAAA,kCAAa,EAA6B,OAAO,CAAC,CAAC;IACzE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAC7C,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,IAAI,uBAAuB,CAAC;IAE1E,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,YAAY,EAAE,CAAC;IAE7C,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAE7D,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACtB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,cAAG,CAAC,IAAI,CAAC,4BAA4B,QAAQ,EAAE,CAAC,CAAC;QACjD,OAAO;IACX,CAAC;IAED,uCAAuC;IACvC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAC9B,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAEnE,MAAM,UAAU,GAAG;QACf,OAAO,EAAE,YAAY,IAAI,SAAS;QAClC,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,aAAa,IAAI,SAAS;KACpE,CAAC;IAEF,MAAM,OAAO,GAAG,MAAM,IAAA,sDAA8B,EAChD,MAAM,EACN,eAAe,EACf;QACI,GAAG,MAAM;QACT,sBAAsB,EAAE,IAAI;QAC5B,eAAe,EAAE,IAAI;KACxB,EACD,UAAU,EACV,OAAO,CAAC,UAAU,IAAI,KAAK,CAC9B,CAAC;IAEF,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;IACnC,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxD,cAAG,CAAC,IAAI,CAAC,sCAAsC,QAAQ,EAAE,CAAC,CAAC;QAC3D,OAAO;IACX,CAAC;IAED,MAAM,gBAAgB,GAAG,GAAG,CAAC,QAAwC,CAAC;IACtE,MAAM,eAAe,GAAqB;QACtC,IAAI,EAAE,UAAU;QAChB,GAAG,gBAAgB;QACnB,eAAe,EAAE,gBAAgB,EAAE,eAAe,IAAI,EAAE;QACxD,QAAQ,EAAE,KAAK;KAClB,CAAC;IAEF,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;QAChC,QAAQ,EAAE,eAAe;KAC5B,CAAC,CAAC;IAEH,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACnC,CAAC"}