@polka-codes/core 0.9.77 → 0.9.79

package/dist/_tsup-dts-rollup.d.ts

@@ -158,6 +158,10 @@ export { createContext }
 export { createContext as createContext_alias_1 }
 export { createContext as createContext_alias_2 }
 
+declare function createDynamicWorkflow<TTools extends ToolRegistry = DynamicWorkflowRegistry>(definition: WorkflowFile | string, options?: DynamicWorkflowRunnerOptions): (workflowId: string, input: Record<string, any>, context: WorkflowContext<TTools>) => Promise<any>;
+export { createDynamicWorkflow }
+export { createDynamicWorkflow as createDynamicWorkflow_alias_1 }
+
 declare const _default: {
     handler: ToolHandler<{
         readonly name: "askFollowupQuestion";
@@ -556,6 +560,68 @@ export { _default_9 as readFile_alias_1 }
  */
 export declare function dirname(path: string): string;
 
+declare type DynamicStepRuntimeContext<TTools extends ToolRegistry> = {
+    workflowId: string;
+    stepId: string;
+    input: Record<string, any>;
+    state: Record<string, any>;
+    tools: WorkflowTools<TTools>;
+    logger: Logger;
+    step: StepFn;
+    runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>;
+    toolInfo: Readonly<FullToolInfo[]> | undefined;
+};
+export { DynamicStepRuntimeContext }
+export { DynamicStepRuntimeContext as DynamicStepRuntimeContext_alias_1 }
+
+declare type DynamicWorkflowParseResult = {
+    success: true;
+    definition: WorkflowFile;
+} | {
+    success: false;
+    error: string;
+};
+export { DynamicWorkflowParseResult }
+export { DynamicWorkflowParseResult as DynamicWorkflowParseResult_alias_1 }
+
+declare type DynamicWorkflowRegistry = ToolRegistry & {
+    runWorkflow: RunWorkflowTool;
+};
+export { DynamicWorkflowRegistry }
+export { DynamicWorkflowRegistry as DynamicWorkflowRegistry_alias_1 }
+
+declare type DynamicWorkflowRunnerOptions = {
+    /**
+     * Tool definitions used when a step does not have persisted `code`
+     * and needs to be executed via `agentWorkflow`.
+     */
+    toolInfo?: Readonly<FullToolInfo[]>;
+    /**
+     * Model id forwarded to `agentWorkflow` for agent-executed steps.
+     */
+    model?: string;
+    /**
+     * Maximum round trips for agent-executed steps.
+     */
+    maxToolRoundTrips?: number;
+    /**
+     * Opt-in to execute persisted step `code` strings.
+     * When false, steps without code must be agent-executed.
+     */
+    allowUnsafeCodeExecution?: boolean;
+    /**
+     * Customize per-step system prompt for agent-executed steps.
+     */
+    stepSystemPrompt?: (args: {
+        workflowId: string;
+        step: WorkflowStepDefinition;
+        input: any;
+        state: any;
+    }) => string;
+};
+export { DynamicWorkflowRunnerOptions }
+export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_1 }
+
 declare type ExitReason = {
     type: 'UsageExceeded';
     messages: JsonModelMessage[];
@@ -603,6 +669,57 @@ declare type FullToolInfo = ToolInfo & {
 export { FullToolInfo }
 export { FullToolInfo as FullToolInfo_alias_1 }
 
+declare type GenerateWorkflowCodeInput = z.infer<typeof GenerateWorkflowCodeInputSchema>;
+export { GenerateWorkflowCodeInput }
+export { GenerateWorkflowCodeInput as GenerateWorkflowCodeInput_alias_1 }
+
+declare const GenerateWorkflowCodeInputSchema: z.ZodObject<{
+    workflow: z.ZodObject<{
+        workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+            task: z.ZodString;
+            inputs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+            }, z.core.$strip>>>>;
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                task: z.ZodString;
+                output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expected_outcome: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                outputSchema: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+            }, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export { GenerateWorkflowCodeInputSchema }
+export { GenerateWorkflowCodeInputSchema as GenerateWorkflowCodeInputSchema_alias_1 }
+
+declare const generateWorkflowCodeWorkflow: WorkflowFn<GenerateWorkflowCodeInput, WorkflowFile, AgentToolRegistry>;
+export { generateWorkflowCodeWorkflow }
+export { generateWorkflowCodeWorkflow as generateWorkflowCodeWorkflow_alias_1 }
+
+declare type GenerateWorkflowDefinitionInput = z.infer<typeof GenerateWorkflowDefinitionInputSchema>;
+export { GenerateWorkflowDefinitionInput }
+export { GenerateWorkflowDefinitionInput as GenerateWorkflowDefinitionInput_alias_1 }
+
+declare const GenerateWorkflowDefinitionInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    availableTools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export { GenerateWorkflowDefinitionInputSchema }
+export { GenerateWorkflowDefinitionInputSchema as GenerateWorkflowDefinitionInputSchema_alias_1 }
+
+declare const generateWorkflowDefinitionWorkflow: WorkflowFn<GenerateWorkflowDefinitionInput, WorkflowFile, AgentToolRegistry>;
+export { generateWorkflowDefinitionWorkflow }
+export { generateWorkflowDefinitionWorkflow as generateWorkflowDefinitionWorkflow_alias_1 }
+
 declare type GetTodoItemOutput = TodoItem & {
     subItems: {
         id: string;
@@ -877,6 +994,10 @@ declare type ModelInfo = {
 export { ModelInfo }
 export { ModelInfo as ModelInfo_alias_1 }
 
+declare function parseDynamicWorkflowDefinition(source: string): DynamicWorkflowParseResult;
+export { parseDynamicWorkflowDefinition }
+export { parseDynamicWorkflowDefinition as parseDynamicWorkflowDefinition_alias_1 }
+
 declare const parseJsonFromMarkdown: (markdown: string) => ParseOutputResult<any>;
 export { parseJsonFromMarkdown }
 export { parseJsonFromMarkdown as parseJsonFromMarkdown_alias_1 }
@@ -941,6 +1062,16 @@ declare const ruleSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
 export { ruleSchema }
 export { ruleSchema as ruleSchema_alias_1 }
 
+declare type RunWorkflowTool = {
+    input: {
+        workflowId: string;
+        input?: any;
+    };
+    output: any;
+};
+export { RunWorkflowTool }
+export { RunWorkflowTool as RunWorkflowTool_alias_1 }
+
 declare interface StepFn {
     <T>(name: string, fn: () => Promise<T>): Promise<T>;
     <T>(name: string, options: StepOptions, fn: () => Promise<T>): Promise<T>;
@@ -1540,11 +1671,91 @@ export { WorkflowContext }
 export { WorkflowContext as WorkflowContext_alias_1 }
 export { WorkflowContext as WorkflowContext_alias_2 }
 
+declare type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export { WorkflowDefinition }
+export { WorkflowDefinition as WorkflowDefinition_alias_1 }
+
+declare const WorkflowDefinitionSchema: z.ZodObject<{
+    task: z.ZodString;
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    }, z.core.$strip>>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        task: z.ZodString;
+        output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        expected_outcome: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        outputSchema: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export { WorkflowDefinitionSchema }
+export { WorkflowDefinitionSchema as WorkflowDefinitionSchema_alias_1 }
+
+declare type WorkflowFile = z.infer<typeof WorkflowFileSchema>;
+export { WorkflowFile }
+export { WorkflowFile as WorkflowFile_alias_1 }
+
+declare const WorkflowFileSchema: z.ZodObject<{
+    workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+        task: z.ZodString;
+        inputs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        }, z.core.$strip>>>>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            task: z.ZodString;
+            output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            expected_outcome: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            outputSchema: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        }, z.core.$strip>>;
+        output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export { WorkflowFileSchema }
+export { WorkflowFileSchema as WorkflowFileSchema_alias_1 }
+
 declare type WorkflowFn<TInput, TOutput, TTools extends ToolRegistry> = (input: TInput, context: WorkflowContext<TTools>) => Promise<TOutput>;
 export { WorkflowFn }
 export { WorkflowFn as WorkflowFn_alias_1 }
 export { WorkflowFn as WorkflowFn_alias_2 }
 
+declare type WorkflowInputDefinition = z.infer<typeof WorkflowInputDefinitionSchema>;
+export { WorkflowInputDefinition }
+export { WorkflowInputDefinition as WorkflowInputDefinition_alias_1 }
+
+declare const WorkflowInputDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+}, z.core.$strip>;
+export { WorkflowInputDefinitionSchema }
+export { WorkflowInputDefinitionSchema as WorkflowInputDefinitionSchema_alias_1 }
+
+declare type WorkflowStepDefinition = z.infer<typeof WorkflowStepDefinitionSchema>;
+export { WorkflowStepDefinition }
+export { WorkflowStepDefinition as WorkflowStepDefinition_alias_1 }
+
+declare const WorkflowStepDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    task: z.ZodString;
+    output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expected_outcome: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    outputSchema: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+}, z.core.$strip>;
+export { WorkflowStepDefinitionSchema }
+export { WorkflowStepDefinitionSchema as WorkflowStepDefinitionSchema_alias_1 }
+
 declare type WorkflowTools<TTools extends ToolRegistry> = {
     [K in keyof TTools]: (input: TTools[K]['input']) => Promise<TTools[K]['output']>;
 };

package/dist/index.d.ts

@@ -60,6 +60,27 @@ export { UsageMeter_alias_1 as UsageMeter } from './_tsup-dts-rollup.js';
 export { AgentWorkflowInput } from './_tsup-dts-rollup.js';
 export { AgentToolRegistry } from './_tsup-dts-rollup.js';
 export { agentWorkflow } from './_tsup-dts-rollup.js';
+export { parseDynamicWorkflowDefinition } from './_tsup-dts-rollup.js';
+export { createDynamicWorkflow } from './_tsup-dts-rollup.js';
+export { RunWorkflowTool } from './_tsup-dts-rollup.js';
+export { DynamicWorkflowRegistry } from './_tsup-dts-rollup.js';
+export { DynamicWorkflowParseResult } from './_tsup-dts-rollup.js';
+export { DynamicStepRuntimeContext } from './_tsup-dts-rollup.js';
+export { DynamicWorkflowRunnerOptions } from './_tsup-dts-rollup.js';
+export { GenerateWorkflowDefinitionInputSchema } from './_tsup-dts-rollup.js';
+export { GenerateWorkflowDefinitionInput } from './_tsup-dts-rollup.js';
+export { GenerateWorkflowCodeInputSchema } from './_tsup-dts-rollup.js';
+export { GenerateWorkflowCodeInput } from './_tsup-dts-rollup.js';
+export { generateWorkflowDefinitionWorkflow } from './_tsup-dts-rollup.js';
+export { generateWorkflowCodeWorkflow } from './_tsup-dts-rollup.js';
+export { WorkflowInputDefinitionSchema } from './_tsup-dts-rollup.js';
+export { WorkflowStepDefinitionSchema } from './_tsup-dts-rollup.js';
+export { WorkflowDefinitionSchema } from './_tsup-dts-rollup.js';
+export { WorkflowFileSchema } from './_tsup-dts-rollup.js';
+export { WorkflowInputDefinition } from './_tsup-dts-rollup.js';
+export { WorkflowStepDefinition } from './_tsup-dts-rollup.js';
+export { WorkflowDefinition } from './_tsup-dts-rollup.js';
+export { WorkflowFile } from './_tsup-dts-rollup.js';
 export { JsonImagePart } from './_tsup-dts-rollup.js';
 export { JsonFilePart } from './_tsup-dts-rollup.js';
 export { JsonUserModelMessage } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -1823,6 +1823,14 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
             value: `Tool '${toolCall.toolName}' not found.`
           }
         });
+        toolResults.push({
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          output: {
+            type: "error-text",
+            value: `Error: Tool '${toolCall.toolName}' not found.`
+          }
+        });
         continue;
       }
       await event(`event-tool-use-${toolCall.toolName}-${toolCall.toolCallId}`, {
@@ -1896,6 +1904,478 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
   throw new Error("Maximum number of tool round trips reached.");
 };
 
+// src/workflow/dynamic.ts
+import { parse } from "yaml";
+import { z as z22 } from "zod";
+
+// src/workflow/dynamic-types.ts
+import { z as z21 } from "zod";
+var WorkflowInputDefinitionSchema = z21.object({
+  id: z21.string(),
+  description: z21.string().nullish(),
+  default: z21.any().nullish()
+});
+var WorkflowStepDefinitionSchema = z21.object({
+  id: z21.string(),
+  tools: z21.array(z21.string()).nullish(),
+  task: z21.string(),
+  output: z21.string().nullish(),
+  expected_outcome: z21.string().nullish(),
+  /**
+   * Persisted JavaScript/TypeScript (JS-compatible) async function body.
+   * The code is wrapped as: `async (ctx) => { <code> }`.
+   */
+  code: z21.string().nullish(),
+  /**
+   * Optional JSON schema or other metadata for future structured outputs.
+   * Not interpreted by core today.
+   */
+  outputSchema: z21.any().nullish()
+});
+var WorkflowDefinitionSchema = z21.object({
+  task: z21.string(),
+  inputs: z21.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z21.array(WorkflowStepDefinitionSchema),
+  output: z21.string().nullish()
+});
+var WorkflowFileSchema = z21.object({
+  workflows: z21.record(z21.string(), WorkflowDefinitionSchema)
+});
+
+// src/workflow/dynamic.ts
+function parseDynamicWorkflowDefinition(source) {
+  try {
+    const raw = parse(source);
+    const validated = WorkflowFileSchema.safeParse(raw);
+    if (!validated.success) {
+      return { success: false, error: z22.prettifyError(validated.error) };
+    }
+    return { success: true, definition: validated.data };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+var AsyncFunction = Object.getPrototypeOf(async () => {
+}).constructor;
+function createRunWorkflowFn(args) {
+  return async (subWorkflowId, subInput) => {
+    const mergedInput = { ...args.input, ...args.state, ...subInput ?? {} };
+    return await args.runInternal(subWorkflowId, mergedInput, args.context, args.state);
+  };
+}
+function compileStep(stepDef, workflowId, compiledSteps) {
+  const key = `${workflowId}.${stepDef.id}`;
+  const existing = compiledSteps.get(key);
+  if (existing) {
+    return existing;
+  }
+  if (!stepDef.code) {
+    throw new Error(`Step '${stepDef.id}' in workflow '${workflowId}' has no code`);
+  }
+  try {
+    const fn = new AsyncFunction("ctx", stepDef.code);
+    compiledSteps.set(key, fn);
+    return fn;
+  } catch (error) {
+    throw new Error(
+      `Failed to compile code for step '${stepDef.id}' in workflow '${workflowId}': ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal) {
+  const tools = context.tools;
+  if (typeof tools.generateText !== "function" || typeof tools.invokeTool !== "function" || typeof tools.taskEvent !== "function") {
+    throw new Error(
+      `Step '${stepDef.id}' in workflow '${workflowId}' requires agent execution, but AgentToolRegistry tools are not available.`
+    );
+  }
+  if (!options.toolInfo) {
+    throw new Error(
+      `Step '${stepDef.id}' in workflow '${workflowId}' requires agent execution, but no toolInfo was provided to DynamicWorkflowRunner.`
+    );
+  }
+  const allowedToolNames = stepDef.tools;
+  const toolsForAgent = allowedToolNames ? options.toolInfo.filter((t) => allowedToolNames.includes(t.name)) : [...options.toolInfo];
+  if (!allowedToolNames || allowedToolNames.includes("runWorkflow")) {
+    toolsForAgent.push({
+      name: "runWorkflow",
+      description: "Run a named sub-workflow defined in the current workflow file.",
+      parameters: z22.object({
+        workflowId: z22.string().describe("Sub-workflow id to run"),
+        input: z22.any().nullish().describe("Optional input object for the sub-workflow")
+      }),
+      handler: async () => {
+        return { type: "Error" /* Error */, message: { type: "error-text", value: "runWorkflow is virtual." } };
+      }
+    });
+  }
+  const allowedToolNameSet = new Set(toolsForAgent.map((t) => t.name));
+  const systemPrompt = options.stepSystemPrompt?.({ workflowId, step: stepDef, input, state }) ?? [
+    `You are an AI assistant executing a workflow step.`,
+    "",
+    "# Instructions",
+    "- Execute the task defined in the user message.",
+    "- Use the provided tools to accomplish the task.",
+    "- Return the step output as valid JSON in markdown.",
+    "- Do not ask for user input. If information is missing, make a reasonable assumption or fail."
+  ].filter(Boolean).join("\n");
+  const userContent = [
+    `Workflow: ${workflowId}`,
+    `Step: ${stepDef.id}`,
+    `Task: ${stepDef.task}`,
+    stepDef.expected_outcome ? `Expected outcome: ${stepDef.expected_outcome}` : "",
+    `Workflow Input: ${JSON.stringify(input)}`,
+    `Current State: ${JSON.stringify(state)}`
+  ].filter(Boolean).join("\n");
+  const runWorkflow = createRunWorkflowFn({ input, state, context, runInternal });
+  const agentTools = {
+    generateText: tools.generateText.bind(tools),
+    taskEvent: tools.taskEvent.bind(tools),
+    invokeTool: async ({ toolName, input: toolInput }) => {
+      if (!allowedToolNameSet.has(toolName)) {
+        return {
+          type: "Error" /* Error */,
+          message: { type: "error-text", value: `Tool '${toolName}' is not allowed in this step.` }
+        };
+      }
+      if (toolName === "runWorkflow") {
+        const subWorkflowId = toolInput?.workflowId;
+        const subInput = toolInput?.input;
+        if (typeof subWorkflowId !== "string") {
+          return {
+            type: "Error" /* Error */,
+            message: { type: "error-text", value: "runWorkflow.workflowId must be a string." }
+          };
+        }
+        try {
+          const output = await runWorkflow(subWorkflowId, subInput);
+          const jsonResult = { type: "json", value: output };
+          return { type: "Reply" /* Reply */, message: jsonResult };
+        } catch (error) {
+          return {
+            type: "Error" /* Error */,
+            message: { type: "error-text", value: error instanceof Error ? error.message : String(error) }
+          };
+        }
+      }
+      return await tools.invokeTool({ toolName, input: toolInput });
+    }
+  };
+  const result = await agentWorkflow(
+    {
+      tools: toolsForAgent,
+      systemPrompt,
+      userMessage: [{ role: "user", content: userContent }],
+      maxToolRoundTrips: options.maxToolRoundTrips,
+      model: options.model
+    },
+    { ...context, tools: agentTools }
+  );
+  if (result.type === "Exit") {
+    if (result.object !== void 0) {
+      return result.object;
+    }
+    const parsed = parseJsonFromMarkdown(result.message);
+    if (parsed.success) {
+      return parsed.data;
+    }
+    return result.message;
+  }
+  throw new Error(`Agent execution for step '${stepDef.id}' in workflow '${workflowId}' did not exit cleanly.`);
+}
+async function executeStep(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
+  if (stepDef.code && options.allowUnsafeCodeExecution) {
+    const fn = compileStep(stepDef, workflowId, compiledSteps);
+    const runWorkflow = createRunWorkflowFn({ input, state, context, runInternal });
+    const runtimeCtx = {
+      workflowId,
+      stepId: stepDef.id,
+      input,
+      state,
+      tools: context.tools,
+      logger: context.logger,
+      step: context.step,
+      runWorkflow,
+      toolInfo: options.toolInfo
+    };
+    return await fn(runtimeCtx);
+  }
+  return await executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal);
+}
+function createDynamicWorkflow(definition, options = {}) {
+  if (typeof definition === "string") {
+    const res = parseDynamicWorkflowDefinition(definition);
+    if (!res.success) {
+      throw new Error(res.error);
+    }
+    definition = res.definition;
+  }
+  const compiledSteps = /* @__PURE__ */ new Map();
+  const runInternal = async (workflowId, input, context, inheritedState) => {
+    const workflow = definition.workflows[workflowId];
+    if (!workflow) {
+      throw new Error(`Workflow '${workflowId}' not found`);
+    }
+    const state = { ...inheritedState };
+    let lastOutput;
+    for (const stepDef of workflow.steps) {
+      const stepName = `${workflowId}.${stepDef.id}`;
+      lastOutput = await context.step(stepName, async () => {
+        return await executeStep(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal);
+      });
+      const outputKey = stepDef.output ?? stepDef.id;
+      state[outputKey] = lastOutput;
+    }
+    if (workflow.output) {
+      return state[workflow.output];
+    }
+    return state;
+  };
+  return async (workflowId, input, context) => {
+    return await runInternal(workflowId, input, context, {});
+  };
+}
+
+// src/workflow/dynamic-generator.workflow.ts
+import { z as z23 } from "zod";
+var GenerateWorkflowDefinitionInputSchema = z23.object({
+  prompt: z23.string(),
+  availableTools: z23.array(
+    z23.object({
+      name: z23.string(),
+      description: z23.string()
+    })
+  ).optional()
+});
+var GenerateWorkflowCodeInputSchema = z23.object({
+  workflow: WorkflowFileSchema
+});
+var WORKFLOW_DEFINITION_SYSTEM_PROMPT = `You are an expert workflow architect.
+Your task is to create a JSON workflow definition based on the user's request.
+
+The workflow definition must follow this structure:
+{
+  "workflows": {
+    "workflowName": {
+      "task": "Description of the workflow",
+      "inputs": [
+        { "id": "inputName", "description": "Description", "default": "optionalDefault" }
+      ],
+      "steps": [
+        {
+          "id": "stepId",
+          "task": "Description of the step",
+          "tools": ["toolName1", "toolName2"], // Optional list of tools needed
+          "output": "outputVariableName", // Optional
+        }
+      ],
+      "output": "outputVariableName" // Optional
+    }
+  }
+}
+
+Constraints:
+- You MUST always include a workflow named 'main'. This is the entry point.
+- The 'main' workflow input must be either empty (no input) or a single string input.
+- Break down complex tasks into logical steps.
+- Define clear inputs and outputs.
+
+Example 1:
+User: "Research a topic and summarize it."
+Output:
+\`\`\`json
+{
+  "workflows": {
+    "main": {
+      "task": "Research a topic and provide a summary",
+      "inputs": [
+        { "id": "topic", "description": "The topic to research" }
+      ],
+      "steps": [
+        {
+          "id": "search",
+          "task": "Search for information about the topic",
+          "tools": ["search"],
+          "output": "searchResults"
+        },
+        {
+          "id": "summarize",
+          "task": "Summarize the search results",
+          "tools": ["generateText"],
+          "output": "summary"
+        }
+      ],
+      "output": "summary"
+    }
+  }
+}
+\`\`\`
+
+Example 2:
+User: "Review urgent PRs. For each PR, run the review workflow."
+Output:
+\`\`\`json
+{
+  "workflows": {
+    "main": {
+      "task": "Fetch urgent PRs and review them",
+      "inputs": [],
+      "steps": [
+        {
+          "id": "fetchPRs",
+          "task": "Fetch list of urgent PRs",
+          "tools": ["github_list_prs"],
+          "output": "prs"
+        },
+        {
+          "id": "reviewEachPR",
+          "task": "Run review workflow for each PR",
+          "tools": [],
+          "output": "reviews"
+        }
+      ],
+      "output": "reviews"
+    },
+    "reviewPR": {
+      "task": "Review a single PR",
+      "inputs": [
+        { "id": "prId", "description": "ID of the PR to review" }
+      ],
+      "steps": [
+        {
+          "id": "getDiff",
+          "task": "Get PR diff",
+          "tools": ["github_get_diff"],
+          "output": "diff"
+        },
+        {
+          "id": "analyze",
+          "task": "Analyze the diff",
+          "tools": ["generateText"],
+          "output": "analysis"
+        }
+      ],
+      "output": "analysis"
+    }
+  }
+}
+\`\`\`
+`;
+var WORKFLOW_CODE_SYSTEM_PROMPT = `You are an expert TypeScript developer.
+Your task is to implement the TypeScript code for the steps in the provided workflow definition.
+
+You will receive a JSON workflow definition where the "code" field is null.
+You must fill in the "code" field for each step with valid TypeScript code.
+
+The code will be executed in an async function with the following signature:
+async (ctx) => {
+  // Your code here
+}
+
+The \`ctx\` object provides access to:
+- \`ctx.input\`: The workflow inputs.
+- \`ctx.state\`: A shared state object for passing data between steps.
+- \`ctx.tools\`: An object containing available tools.
+- \`ctx.runWorkflow\`: (workflowId: string, input?: any) => Promise<any>. Use this to run other workflows.
+
+Guidelines:
+- Use \`await\` for asynchronous operations.
+- Return the output value of the step.
+- Access inputs via \`ctx.input.inputName\`.
+- Access previous step outputs via \`ctx.state.stepOutputName\`.
+- Use \`ctx.tools.invokeTool({ toolName: 'name', input: { ... } })\` to call tools.
+- Use \`ctx.tools.generateText({ messages: [...] })\` for LLM calls.
+- Use \`ctx.tools.invokeTool({ toolName: 'runAgent', input: { prompt: '...' } })\` for complex sub-tasks that require multiple steps or tools. Prefer this over \`generateText\` for advanced tasks.
+
+Example Code for a step:
+\`\`\`typescript
+const searchResults = await ctx.tools.invokeTool({
+  toolName: 'search',
+  input: { query: ctx.input.topic }
+});
+return searchResults;
+\`\`\`
+
+Example Code for LLM step:
+\`\`\`typescript
+const summary = await ctx.tools.generateText({
+  messages: [
+    { role: 'system', content: 'Summarize the following text.' },
+    { role: 'user', content: ctx.state.searchResults }
+  ]
+});
+return summary;
+\`\`\`
+
+Example Code for runAgent:
+\`\`\`typescript
+const result = await ctx.tools.invokeTool({
+  toolName: 'runAgent',
+  input: {
+    prompt: 'Research the history of the internet and write a summary.',
+    tools: ['search', 'generateText']
+  }
+});
+return result;
+\`\`\`
+
+Example Code for invoking a sub-workflow:
+\`\`\`typescript
+const results = [];
+for (const pr of ctx.state.prs) {
+  const review = await ctx.runWorkflow('reviewPR', { prId: pr.id });
+  results.push(review);
+}
+return results;
+\`\`\`
+
+Return the complete workflow JSON with the "code" fields populated.
+`;
+var generateWorkflowDefinitionWorkflow = async (input, ctx) => {
+  let systemPrompt = WORKFLOW_DEFINITION_SYSTEM_PROMPT;
+  if (input.availableTools && input.availableTools.length > 0) {
+    const toolsList = input.availableTools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+    systemPrompt += `
+
+Available Tools:
+${toolsList}
+
+Use these tools when appropriate.`;
+  }
+  const result = await ctx.step("generate-workflow-definition", async () => {
+    return agentWorkflow(
+      {
+        systemPrompt,
+        userMessage: [{ role: "user", content: input.prompt }],
+        tools: [],
+        outputSchema: WorkflowFileSchema
+      },
+      ctx
+    );
+  });
+  if (result.type === "Exit" && result.object) {
+    return result.object;
+  }
+  throw new Error("Failed to generate workflow definition");
+};
+var generateWorkflowCodeWorkflow = async (input, ctx) => {
+  const result = await ctx.step("generate-workflow-code", async () => {
+    return agentWorkflow(
+      {
+        systemPrompt: WORKFLOW_CODE_SYSTEM_PROMPT,
+        userMessage: [{ role: "user", content: JSON.stringify(input.workflow, null, 2) }],
+        tools: [],
+        outputSchema: WorkflowFileSchema
+      },
+      ctx
+    );
+  });
+  if (result.type === "Exit" && result.object) {
+    return result.object;
+  }
+  throw new Error("Failed to generate workflow code");
+};
+
 // src/workflow/json-ai-types.ts
 var toJsonDataContent = (data) => {
   if (data instanceof URL) {
@@ -2094,6 +2574,8 @@ var makeStepFn = () => {
   };
 };
 export {
+  GenerateWorkflowCodeInputSchema,
+  GenerateWorkflowDefinitionInputSchema,
   MockProvider,
   TaskEventKind,
   TodoItemSchema,
@@ -2102,19 +2584,27 @@ export {
   UpdateTodoItemInputSchema,
   UpdateTodoItemOutputSchema,
   UsageMeter,
+  WorkflowDefinitionSchema,
+  WorkflowFileSchema,
+  WorkflowInputDefinitionSchema,
+  WorkflowStepDefinitionSchema,
   agentWorkflow,
   askFollowupQuestion_default as askFollowupQuestion,
   computeRateLimitBackoffSeconds,
   configSchema,
   createContext,
+  createDynamicWorkflow,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,
+  generateWorkflowCodeWorkflow,
+  generateWorkflowDefinitionWorkflow,
   getTodoItem_default as getTodoItem,
   listFiles_default as listFiles,
   listMemoryTopics_default as listMemoryTopics,
   listTodoItems_default as listTodoItems,
   makeStepFn,
+  parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
   providerModelSchema,
   readBinaryFile_default as readBinaryFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/core",
-  "version": "0.9.77",
+  "version": "0.9.79",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",