@polka-codes/core 0.9.78 → 0.9.80

package/README.md

@@ -29,7 +29,7 @@ import {
   agentWorkflow,
   createContext,
   makeStepFn,
-  type ToolResponse,
+  type AgentToolResponse,
   ToolResponseType,
 } from '@polka-codes/core';
 import { z } from 'zod';
@@ -52,10 +52,10 @@ async function main() {
         const { location } = input as z.infer<typeof getCurrentWeather.parameters>;
         // In a real app, you would call a weather API here
         const weather = `The weather in ${location} is 70°F and sunny.`;
-        const response: ToolResponse = { type: ToolResponseType.Reply, message: weather };
+        const response: AgentToolResponse = { type: ToolResponseType.Reply, message: weather };
         return response;
       }
-      const response: ToolResponse = { type: ToolResponseType.Error, message: 'Tool not found' };
+      const response: AgentToolResponse = { type: ToolResponseType.Error, message: 'Tool not found' };
       return response;
     },
     // A simple text generation function

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

@@ -21,6 +21,14 @@ import { ZodObject } from 'zod';
 import { ZodOptional } from 'zod';
 import { ZodString } from 'zod';
 
+declare type AgentToolInfo = {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+};
+export { AgentToolInfo }
+export { AgentToolInfo as AgentToolInfo_alias_1 }
+
 declare type AgentToolRegistry = {
     generateText: {
         input: {
@@ -39,20 +47,24 @@ declare type AgentToolRegistry = {
             toolName: string;
             input: any;
         };
-        output: ToolResponse;
+        output: AgentToolResponse;
     };
 };
 export { AgentToolRegistry }
 export { AgentToolRegistry as AgentToolRegistry_alias_1 }
 export { AgentToolRegistry as AgentToolRegistry_alias_2 }
 
+declare type AgentToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseError;
+export { AgentToolResponse }
+export { AgentToolResponse as AgentToolResponse_alias_1 }
+
 declare const agentWorkflow: WorkflowFn<AgentWorkflowInput, ExitReason, AgentToolRegistry>;
 export { agentWorkflow }
 export { agentWorkflow as agentWorkflow_alias_1 }
 export { agentWorkflow as agentWorkflow_alias_2 }
 
 declare type AgentWorkflowInput = {
-    tools: Readonly<FullToolInfo[]>;
+    tools: Readonly<FullAgentToolInfo[]>;
     maxToolRoundTrips?: number;
     userMessage: readonly JsonUserModelMessage[];
     outputSchema?: z.ZodSchema;
@@ -158,6 +170,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 +572,73 @@ 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<FullAgentToolInfo[]> | 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<FullAgentToolInfo[]>;
+    /**
+     * 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;
+    /**
+     * Whether to wrap plain text agent responses in an object { result: ... }.
+     * Defaults to false.
+     */
+    wrapAgentResultInObject?: boolean;
+};
+export { DynamicWorkflowRunnerOptions }
+export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_1 }
+
 declare type ExitReason = {
     type: 'UsageExceeded';
     messages: JsonModelMessage[];
@@ -597,11 +680,63 @@ export { fromJsonModelMessage }
 export { fromJsonModelMessage as fromJsonModelMessage_alias_1 }
 export { fromJsonModelMessage as fromJsonModelMessage_alias_2 }
 
-declare type FullToolInfo = ToolInfo & {
-    handler: ToolHandler<ToolInfo, any>;
-};
-export { FullToolInfo }
-export { FullToolInfo as FullToolInfo_alias_1 }
+declare type FullAgentToolInfo = AgentToolInfo & {
+    handler: ToolHandler<AgentToolInfo, any>;
+};
+export { FullAgentToolInfo }
+export { FullAgentToolInfo as FullAgentToolInfo_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>>;
+                timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, 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: {
@@ -877,6 +1012,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 +1080,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>;
@@ -1135,18 +1284,10 @@ export { toJsonModelMessage }
 export { toJsonModelMessage as toJsonModelMessage_alias_1 }
 export { toJsonModelMessage as toJsonModelMessage_alias_2 }
 
-declare type ToolHandler<_T, P> = (provider: P, args: Partial<Record<string, ToolParameterValue>>) => Promise<ToolResponse>;
+declare type ToolHandler<_T, P> = (provider: P, args: Partial<Record<string, ToolParameterValue>>) => Promise<AgentToolResponse>;
 export { ToolHandler }
 export { ToolHandler as ToolHandler_alias_1 }
 
-declare type ToolInfo = {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<any>;
-};
-export { ToolInfo }
-export { ToolInfo as ToolInfo_alias_1 }
-
 export declare const toolInfo: {
     readonly name: "askFollowupQuestion";
     readonly description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.";
@@ -1352,10 +1493,6 @@ export { ToolRegistry }
 export { ToolRegistry as ToolRegistry_alias_1 }
 export { ToolRegistry as ToolRegistry_alias_2 }
 
-declare type ToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseError;
-export { ToolResponse }
-export { ToolResponse as ToolResponse_alias_1 }
-
 declare type ToolResponseError = {
     type: ToolResponseType.Error;
     message: ToolResponseResult;
@@ -1540,11 +1677,94 @@ 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>>;
+        timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, 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>>;
+            timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, 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>>;
+    timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, 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

@@ -10,15 +10,15 @@ export { configSchema_alias_1 as configSchema } from './_tsup-dts-rollup.js';
 export { Config_alias_1 as Config } from './_tsup-dts-rollup.js';
 export { ToolParameterValue } from './_tsup-dts-rollup.js';
 export { ToolParameter } from './_tsup-dts-rollup.js';
-export { ToolInfo } from './_tsup-dts-rollup.js';
-export { FullToolInfo } from './_tsup-dts-rollup.js';
+export { AgentToolInfo } from './_tsup-dts-rollup.js';
+export { FullAgentToolInfo } from './_tsup-dts-rollup.js';
 export { ToolResponseType } from './_tsup-dts-rollup.js';
 export { ToolResponseResultMedia } from './_tsup-dts-rollup.js';
 export { ToolResponseResult } from './_tsup-dts-rollup.js';
 export { ToolResponseReply } from './_tsup-dts-rollup.js';
 export { ToolResponseExit } from './_tsup-dts-rollup.js';
 export { ToolResponseError } from './_tsup-dts-rollup.js';
-export { ToolResponse } from './_tsup-dts-rollup.js';
+export { AgentToolResponse } from './_tsup-dts-rollup.js';
 export { ToolHandler } from './_tsup-dts-rollup.js';
 export { askFollowupQuestion } from './_tsup-dts-rollup.js';
 export { executeCommand } from './_tsup-dts-rollup.js';
@@ -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';