@vertesia/workflow 0.79.0 → 0.80.0-dev-20251118

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

@@ -2,30 +2,49 @@ import { ApplicationFailure } from "@temporalio/workflow";
 import { WorkflowExecutionPayload } from "@vertesia/common";
 import { MemoryPack } from "@vertesia/memory";
 import { getVertesiaClient } from "../../utils/client.js";
-import { buildAndPublishMemoryPack, loadMemoryPack } from "../../utils/memory.js";
-import { IterativeGenerationPayload, OutputMemoryMeta, Section, TocPart, TocSection } from "../types.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[]) {
+export async function it_gen_generatePart(
+    payload: WorkflowExecutionPayload,
+    path: number[],
+) {
     const vars = payload.vars as IterativeGenerationPayload;
-    const client = getVertesiaClient(payload);
+    const client = await getVertesiaClient(payload);
     const memory = vars.memory;
 
     const [sectionIndex, partIndex] = path;
     const outMemory = await loadMemoryPack(client, `${memory}/output`);
-    const meta = await outMemory.getMetadata() as OutputMemoryMeta;
+    const meta = (await outMemory.getMetadata()) as OutputMemoryMeta;
 
     // the section we build is the section at the given index
     const section: TocSection = meta.toc.sections[sectionIndex];
     if (!section) {
-        throw ApplicationFailure.nonRetryable('Section not found in the TOC', 'SectionNotFound', { memory, path });
+        throw ApplicationFailure.nonRetryable(
+            "Section not found in the TOC",
+            "SectionNotFound",
+            { memory, path },
+        );
     }
     let part: TocPart | undefined;
     if (partIndex !== undefined) {
         part = section.parts?.[partIndex];
         if (!part) {
-            throw ApplicationFailure.nonRetryable('Part not found in the TOC section', 'PartNotFound', { memory, path });
+            throw ApplicationFailure.nonRetryable(
+                "Part not found in the TOC section",
+                "PartNotFound",
+                { memory, path },
+            );
         }
     }
 
@@ -33,17 +52,26 @@ export async function it_gen_generatePart(payload: WorkflowExecutionPayload, pat
 
     const content = await loadGeneratedContent(outMemory);
 
-    let previously_generated = getPreviouslyGeneratedContent(content, !part, vars.remembrance_strategy);
+    let previously_generated = getPreviouslyGeneratedContent(
+        content,
+        !part,
+        vars.remembrance_strategy,
+    );
 
-    if (!part) { // a new section
+    if (!part) {
+        // a new section
         content.push({
             id: section.id,
             name: section.name,
             description: section.description,
-            content: ''
-        })
+            content: "",
+        });
     } else if (!content.length) {
-        throw ApplicationFailure.nonRetryable('content.json is empty while generating a part', 'InvalidIterationState', { memory, path });
+        throw ApplicationFailure.nonRetryable(
+            "content.json is empty while generating a part",
+            "InvalidIterationState",
+            { memory, path },
+        );
     }
 
     const interaction = vars.iterative_interaction || vars.interaction;
@@ -54,30 +82,42 @@ export async function it_gen_generatePart(payload: WorkflowExecutionPayload, pat
             section: section.name,
             part: part?.name,
             path: path,
-        }
+        },
     });
 
-    const result = r.result.map(completionResultToString).join('\n');
+    const result = r.result.text();
     content[content.length - 1].content += result;
     meta.lastProcessedPart = path;
-    await buildAndPublishMemoryPack(client, `${memory}/output`, async ({ copyText }) => {
-        copyText(JSON.stringify(content, null, 2), "content.json");
-        return meta;
-    });
+    await buildAndPublishMemoryPack(
+        client,
+        `${memory}/output`,
+        async ({ copyText }) => {
+            copyText(JSON.stringify(content, null, 2), "content.json");
+            return meta;
+        },
+    );
 }
 
 async function loadGeneratedContent(memory: MemoryPack): Promise<Section[]> {
-    const content = await memory.getEntryText('content.json');
+    const content = await memory.getEntryText("content.json");
     return content ? JSON.parse(content) : [];
 }
 
-function getPreviouslyGeneratedContent(sections: Section[], isNewSection: boolean, strategy?: "document" | "section" | "none"): string {
+function getPreviouslyGeneratedContent(
+    sections: Section[],
+    isNewSection: boolean,
+    strategy?: "document" | "section" | "none",
+): string {
     switch (strategy) {
         case "document":
-            return sections.map((section: Section) => section.content || '').join('\n\n');
+            return sections
+                .map((section: Section) => section.content || "")
+                .join("\n\n");
         case "none":
-            return '';
+            return "";
         default:
-            return isNewSection ? '' : sections[sections.length - 1]?.content || '';
+            return isNewSection
+                ? ""
+                : sections[sections.length - 1]?.content || "";
     }
-}
+}

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

@@ -1,104 +1,116 @@
 import { WorkflowExecutionPayload } from "@vertesia/common";
 import { getVertesiaClient } from "../../utils/client.js";
 import { buildAndPublishMemoryPack } from "../../utils/memory.js";
-import { IterativeGenerationPayload, OutputMemoryMeta, Toc, TocIndex } from "../types.js";
+import {
+    IterativeGenerationPayload,
+    OutputMemoryMeta,
+    Toc,
+    TocIndex,
+} from "../types.js";
 import { executeWithVars, tocIndex } from "../utils.js";
-import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 const defaultTocSchema = {
-    "type": "object",
-    "properties": {
-        "sections": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "properties": {
-                    "id": {
-                        "type": "string",
-                        "description": "the id of the section, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model."
+    type: "object",
+    properties: {
+        sections: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "string",
+                        description:
+                            "the id of the section, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model.",
                     },
-                    "operation": {
-                        "type": "string",
-                        "enum": ["create", "update", "delete"],
-                        "description": "The operation to perform on the section, create, update or delete. If update, you will be requested later to provide the list of change operation to perform."
+                    operation: {
+                        type: "string",
+                        enum: ["create", "update", "delete"],
+                        description:
+                            "The operation to perform on the section, create, update or delete. If update, you will be requested later to provide the list of change operation to perform.",
                     },
-                    "name": {
-                        "type": "string",
-                        "description": "The name or title of the section, should be the path in the OpenAPI spec, of the title of the section/part."
+                    name: {
+                        type: "string",
+                        description:
+                            "The name or title of the section, should be the path in the OpenAPI spec, of the title of the section/part.",
                     },
-                    "description": {
-                        "type": "string"
+                    description: {
+                        type: "string",
                     },
-                    "instructions": {
-                        "type": "string"
+                    instructions: {
+                        type: "string",
                     },
-                    "parts":
-                    {
-                        "type": "array",
-                        "description": "when the section is too large, you can split it into parts, each part should have a title and description. Use it to split the section into subsection. When doing an API documentation, you can do one part for each path. When generating code, you can do one part for each method. When generating an OpenAPI spec, you can do one part for each operation.",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "id": {
-                                    "type": "string",
-                                    "description": "the id of the part, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model."
+                    parts: {
+                        type: "array",
+                        description:
+                            "when the section is too large, you can split it into parts, each part should have a title and description. Use it to split the section into subsection. When doing an API documentation, you can do one part for each path. When generating code, you can do one part for each method. When generating an OpenAPI spec, you can do one part for each operation.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description:
+                                        "the id of the part, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model.",
                                 },
-                                "name": {
-                                    "type": "string",
-                                    "description": "The name or title of the part, should be the path in the OpenAPI spec, of the title of the section/part."
+                                name: {
+                                    type: "string",
+                                    description:
+                                        "The name or title of the part, should be the path in the OpenAPI spec, of the title of the section/part.",
                                 },
                                 /*
                                 "description": {
                                     "type": "string"
                                 },
                                 */
-                                "instructions": {
-                                    "type": "string"
-                                }
+                                instructions: {
+                                    type: "string",
+                                },
                             },
-                            "required": [
-                                "id",
-                                "name",
-                            ]
-                        }
-                    }
+                            required: ["id", "name"],
+                        },
+                    },
                 },
-                "required": [
-                    "id",
-                    "name",
-                    "operation"
-                ]
-            }
-        }
+                required: ["id", "name", "operation"],
+            },
+        },
     },
-    "required": [
-        "sections"
-    ]
-}
+    required: ["sections"],
+};
 
-export async function it_gen_generateToc(payload: WorkflowExecutionPayload): Promise<TocIndex> {
+export async function it_gen_generateToc(
+    payload: WorkflowExecutionPayload,
+): Promise<TocIndex> {
     const vars = payload.vars as IterativeGenerationPayload;
 
     const schema = vars.toc_schema || defaultTocSchema;
 
-    const client = getVertesiaClient(payload);
+    const client = await getVertesiaClient(payload);
 
-    const run = await executeWithVars(client, vars.interaction, vars, undefined, schema);
+    const run = await executeWithVars(
+        client,
+        vars.interaction,
+        vars,
+        undefined,
+        schema,
+    );
 
     //Parse the CompletionResult[] to get a Toc object
-    const jsonResults = parseCompletionResultsToJson(run.result);
+    const jsonResults = run.result.object();
 
     const toc: Toc = {
         sections: jsonResults.sections
     };
 
-    await buildAndPublishMemoryPack(client, `${vars.memory}/output`, async () => {
-        return {
-            toc,
-            lastProcessedPart: undefined, // the part index (a number array)
-            previouslyGenerated: ""
-        } satisfies OutputMemoryMeta
-    });
+    await buildAndPublishMemoryPack(
+        client,
+        `${vars.memory}/output`,
+        async () => {
+            return {
+                toc,
+                lastProcessedPart: undefined, // the part index (a number array)
+                previouslyGenerated: "",
+            } satisfies OutputMemoryMeta;
+        },
+    );
 
     return tocIndex(toc);
 }

package/src/iterative-generation/utils.ts

@@ -1,8 +1,7 @@
-import { VertesiaClient } from "@vertesia/client";
-import { ExecutionRun } from "@vertesia/common";
+import { ModelOptions, TextFallbackOptions } from "@llumiverse/common";
 import { ApplicationFailure } from "@temporalio/workflow";
+import { VertesiaClient } from "@vertesia/client";
 import { OutputMemoryMeta, PartIndex, Toc, TocIndex, TocSection } from "./types.js";
-import { ModelOptions, TextFallbackOptions } from "@llumiverse/common";
 
 //TODO: For whole file, support for options beyond max_tokens and temperature and multiple modalities.
 export interface ExecuteOptions {
@@ -15,7 +14,7 @@ export interface ExecuteOptions {
     result_schema?: Record<string, any>;
 }
 
-export async function execute(client: VertesiaClient, options: ExecuteOptions): Promise<ExecutionRun> {
+export async function execute(client: VertesiaClient, options: ExecuteOptions) {
     return client.interactions.executeByName(options.interaction, {
         data: {
             ...options.memory_mapping,
@@ -30,7 +29,7 @@ export async function execute(client: VertesiaClient, options: ExecuteOptions):
     });
 }
 
-export function executeWithVars(client: VertesiaClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>): Promise<ExecutionRun> {
+export function executeWithVars(client: VertesiaClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>) {
     if (mapping) {
         mapping = { ...vars.input_mapping, ...mapping };
     } else {

package/src/utils/blobs.ts

@@ -14,7 +14,9 @@ export async function fetchBlobAsStream(client: VertesiaClient, blobUri: string)
     } catch (err: any) {
         if (err.message.includes("not found")) {
             //TODO improve error handling with a fetch fail error class in the client
-            throw new DocumentNotFoundError(`Failed to download blob ${blobUri}: ${err.message}`, []);
+            throw new DocumentNotFoundError(`Not found at ${blobUri}: ${err.message}`, []);
+        } else if (err.message.includes("forbidden")) {
+            throw new DocumentNotFoundError(`Forbidden at ${blobUri}: ${err.message}`);
         } else {
             throw new Error(`Failed to download blob ${blobUri}: ${err.message}`);
         }

package/src/utils/client.ts

@@ -2,31 +2,45 @@
  * get a zeno client for a given token
  */
 
-import { VertesiaClient } from "@vertesia/client";
+import {
+    decodeJWT,
+    VertesiaClient,
+    VertesiaClientProps,
+} from "@vertesia/client";
 import { WorkflowExecutionBaseParams } from "@vertesia/common";
 import { WorkflowParamNotFoundError } from "../errors.js";
 
-
 export function getVertesiaClient(payload: WorkflowExecutionBaseParams) {
     return new VertesiaClient(getVertesiaClientOptions(payload));
 }
 
-export function getVertesiaClientOptions(payload: WorkflowExecutionBaseParams) {
+export function getVertesiaClientOptions(
+    payload: WorkflowExecutionBaseParams,
+): VertesiaClientProps {
     if (!payload.auth_token) {
-        throw new WorkflowParamNotFoundError("Authentication Token is missing from WorkflowExecutionPayload.authToken");
+        throw new WorkflowParamNotFoundError(
+            "Authentication Token is missing from WorkflowExecutionPayload.authToken",
+        );
     }
 
     if (!payload.config?.studio_url) {
-        throw new WorkflowParamNotFoundError("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
+        throw new WorkflowParamNotFoundError(
+            "Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl",
+        );
     }
 
     if (!payload.config?.store_url) {
-        throw new WorkflowParamNotFoundError("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
+        throw new WorkflowParamNotFoundError(
+            "Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl",
+        );
     }
 
+    const token = decodeJWT(payload.auth_token);
+
     return {
         serverUrl: payload.config.studio_url,
         storeUrl: payload.config.store_url,
-        apikey: payload.auth_token
+        tokenServerUrl: token.iss,
+        apikey: payload.auth_token,
     };
-}
+}