@polka-codes/core 0.9.84 → 0.9.86

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

@@ -31,7 +31,7 @@ declare type AgentToolRegistry = {
     invokeTool: {
         input: {
             toolName: string;
-            input: any;
+            input: unknown;
         };
         output: ToolResponse;
     };
@@ -60,7 +60,9 @@ export { AgentWorkflowInput }
 export { AgentWorkflowInput as AgentWorkflowInput_alias_1 }
 export { AgentWorkflowInput as AgentWorkflowInput_alias_2 }
 
-declare type BreakStep = z.infer<typeof BreakStepSchema>;
+declare interface BreakStep {
+    break: true;
+}
 export { BreakStep }
 export { BreakStep as BreakStep_alias_1 }
 export { BreakStep as BreakStep_alias_2 }
@@ -213,7 +215,9 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
 export { configSchema }
 export { configSchema as configSchema_alias_1 }
 
-declare type ContinueStep = z.infer<typeof ContinueStepSchema>;
+declare interface ContinueStep {
+    continue: true;
+}
 export { ContinueStep }
 export { ContinueStep as ContinueStep_alias_1 }
 export { ContinueStep as ContinueStep_alias_2 }
@@ -228,12 +232,24 @@ export { ContinueStepSchema }
 export { ContinueStepSchema as ContinueStepSchema_alias_1 }
 export { ContinueStepSchema as ContinueStepSchema_alias_2 }
 
+/**
+ * Convert a JSON Schema to a Zod schema
+ * Supports a subset of JSON SchemaDraft 7
+ *
+ * This is exported to allow reuse in other parts of the codebase that need to
+ * convert JSON schemas to Zod schemas (e.g., MCP server tool schema conversion).
+ */
+declare function convertJsonSchemaToZod(schema: JsonSchema): z.ZodTypeAny;
+export { convertJsonSchemaToZod }
+export { convertJsonSchemaToZod as convertJsonSchemaToZod_alias_1 }
+export { convertJsonSchemaToZod as convertJsonSchemaToZod_alias_2 }
+
 declare function createContext<TTools extends ToolRegistry>(tools: WorkflowTools<TTools>, stepFn?: StepFn, logger?: Logger): WorkflowContext<TTools>;
 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>;
+declare function createDynamicWorkflow<TTools extends ToolRegistry = DynamicWorkflowRegistry>(definition: WorkflowFile | string, options?: DynamicWorkflowRunnerOptions): (workflowId: string, input: Record<string, unknown>, context: WorkflowContext<TTools>) => Promise<unknown>;
 export { createDynamicWorkflow }
 export { createDynamicWorkflow as createDynamicWorkflow_alias_1 }
 export { createDynamicWorkflow as createDynamicWorkflow_alias_2 }
@@ -511,14 +527,14 @@ 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>;
+    input: Record<string, unknown>;
+    state: Record<string, unknown>;
     tools: WorkflowTools<TTools>;
     logger: Logger;
     step: StepFn;
-    runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>;
+    runWorkflow: (workflowId: string, input?: Record<string, unknown>) => Promise<unknown>;
     toolInfo: Readonly<FullToolInfo[]> | undefined;
-    agentTools: Record<string, (input: any) => Promise<any>>;
+    agentTools: Record<string, (input: unknown) => Promise<unknown>>;
 };
 export { DynamicStepRuntimeContext }
 export { DynamicStepRuntimeContext as DynamicStepRuntimeContext_alias_1 }
@@ -562,8 +578,8 @@ declare type DynamicWorkflowRunnerOptions = {
     stepSystemPrompt?: (args: {
         workflowId: string;
         step: WorkflowStepDefinition;
-        input: any;
-        state: any;
+        input: Record<string, unknown>;
+        state: Record<string, unknown>;
     }) => string;
     /**
      * Whether to wrap plain text agent responses in an object { result: ... }.
@@ -748,7 +764,15 @@ export declare const handler_alias_8: ToolHandler<typeof toolInfo_alias_8, Files
 
 export declare const handler_alias_9: ToolHandler<typeof toolInfo_alias_9, WebProvider>;
 
-declare type IfElseStep = z.infer<typeof IfElseStepSchema>;
+declare interface IfElseStep {
+    id: string;
+    if: {
+        condition: string;
+        thenBranch: WorkflowControlFlowStep[];
+        elseBranch?: WorkflowControlFlowStep[];
+    };
+    output?: string | null;
+}
 export { IfElseStep }
 export { IfElseStep as IfElseStep_alias_1 }
 export { IfElseStep as IfElseStep_alias_2 }
@@ -756,7 +780,7 @@ export { IfElseStep as IfElseStep_alias_2 }
 /**
  * If/else branch - conditionally executes steps
  */
-declare const IfElseStepSchema: any;
+declare const IfElseStepSchema: z.ZodType<IfElseStep>;
 export { IfElseStepSchema }
 export { IfElseStepSchema as IfElseStepSchema_alias_1 }
 export { IfElseStepSchema as IfElseStepSchema_alias_2 }
@@ -872,6 +896,27 @@ export { JsonResponseMessage }
 export { JsonResponseMessage as JsonResponseMessage_alias_1 }
 export { JsonResponseMessage as JsonResponseMessage_alias_2 }
 
+declare interface JsonSchema {
+    type?: JsonSchemaType | JsonSchemaType[];
+    enum?: JsonSchemaEnum;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean | JsonSchema;
+    description?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * JSON Schema enum values - can be string, number, or boolean
+ */
+declare type JsonSchemaEnum = (string | number | boolean)[];
+
+/**
+ * JSON Schema type to Zod type mapping
+ */
+declare type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+
 declare interface JsonToolCallPart {
     type: 'tool-call';
     /**
@@ -1347,12 +1392,15 @@ declare const ruleSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
 export { ruleSchema }
 export { ruleSchema as ruleSchema_alias_1 }
 
+/**
+ * Type for the runWorkflow tool that allows workflows to call other workflows
+ */
 declare type RunWorkflowTool = {
     input: {
         workflowId: string;
-        input?: any;
+        input?: Record<string, unknown>;
     };
-    output: any;
+    output: unknown;
 };
 export { RunWorkflowTool }
 export { RunWorkflowTool as RunWorkflowTool_alias_1 }
@@ -2008,7 +2056,14 @@ declare type Totals = {
     messageCount: number;
 };
 
-declare type TryCatchStep = z.infer<typeof TryCatchStepSchema>;
+declare interface TryCatchStep {
+    id: string;
+    try: {
+        trySteps: WorkflowControlFlowStep[];
+        catchSteps: WorkflowControlFlowStep[];
+    };
+    output?: string | null;
+}
 export { TryCatchStep }
 export { TryCatchStep as TryCatchStep_alias_1 }
 export { TryCatchStep as TryCatchStep_alias_2 }
@@ -2019,8 +2074,8 @@ export { TryCatchStep as TryCatchStep_alias_2 }
 declare const TryCatchStepSchema: z.ZodObject<{
     id: z.ZodString;
     try: z.ZodObject<{
-        trySteps: z.ZodArray<z.ZodLazy<any>>;
-        catchSteps: z.ZodArray<z.ZodLazy<any>>;
+        trySteps: z.ZodArray<z.ZodLazy<z.ZodType<WorkflowControlFlowStep, unknown, z.core.$ZodTypeInternals<WorkflowControlFlowStep, unknown>>>>;
+        catchSteps: z.ZodArray<z.ZodLazy<z.ZodType<WorkflowControlFlowStep, unknown, z.core.$ZodTypeInternals<WorkflowControlFlowStep, unknown>>>>;
     }, z.core.$strip>;
     output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
@@ -2174,7 +2229,14 @@ export { WebProvider }
 export { WebProvider as WebProvider_alias_1 }
 export { WebProvider as WebProvider_alias_2 }
 
-declare type WhileLoopStep = z.infer<typeof WhileLoopStepSchema>;
+declare interface WhileLoopStep {
+    id: string;
+    while: {
+        condition: string;
+        steps: WorkflowControlFlowStep[];
+    };
+    output?: string | null;
+}
 export { WhileLoopStep }
 export { WhileLoopStep as WhileLoopStep_alias_1 }
 export { WhileLoopStep as WhileLoopStep_alias_2 }
@@ -2182,7 +2244,7 @@ export { WhileLoopStep as WhileLoopStep_alias_2 }
 /**
  * While loop - repeats steps while condition is true
  */
-declare const WhileLoopStepSchema: any;
+declare const WhileLoopStepSchema: z.ZodType<WhileLoopStep>;
 export { WhileLoopStepSchema }
 export { WhileLoopStepSchema as WhileLoopStepSchema_alias_1 }
 export { WhileLoopStepSchema as WhileLoopStepSchema_alias_2 }
@@ -2196,7 +2258,7 @@ export { WorkflowContext }
 export { WorkflowContext as WorkflowContext_alias_1 }
 export { WorkflowContext as WorkflowContext_alias_2 }
 
-declare type WorkflowControlFlowStep = z.infer<typeof WorkflowControlFlowStepSchema>;
+declare type WorkflowControlFlowStep = z.infer<typeof WorkflowStepDefinitionSchema> | WhileLoopStep | IfElseStep | BreakStep | ContinueStep | TryCatchStep;
 export { WorkflowControlFlowStep }
 export { WorkflowControlFlowStep as WorkflowControlFlowStep_alias_1 }
 export { WorkflowControlFlowStep as WorkflowControlFlowStep_alias_2 }
@@ -2205,7 +2267,7 @@ export { WorkflowControlFlowStep as WorkflowControlFlowStep_alias_2 }
  * Any step that can appear in a workflow's steps array
  * Can be a basic step, control flow, or jump statement
  */
-declare const WorkflowControlFlowStepSchema: any;
+declare const WorkflowControlFlowStepSchema: z.ZodType<WorkflowControlFlowStep>;
 export { WorkflowControlFlowStepSchema }
 export { WorkflowControlFlowStepSchema as WorkflowControlFlowStepSchema_alias_1 }
 export { WorkflowControlFlowStepSchema as WorkflowControlFlowStepSchema_alias_2 }
@@ -2225,7 +2287,7 @@ declare const WorkflowDefinitionSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
     }, z.core.$strip>>>>;
-    steps: z.ZodArray<any>;
+    steps: z.ZodArray<z.ZodType<WorkflowControlFlowStep, unknown, z.core.$ZodTypeInternals<WorkflowControlFlowStep, unknown>>>;
     output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export { WorkflowDefinitionSchema }
@@ -2245,7 +2307,7 @@ declare const WorkflowFileSchema: z.ZodObject<{
             description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
         }, z.core.$strip>>>>;
-        steps: z.ZodArray<any>;
+        steps: z.ZodArray<z.ZodType<WorkflowControlFlowStep, unknown, z.core.$ZodTypeInternals<WorkflowControlFlowStep, unknown>>>;
         output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/index.d.ts

@@ -97,6 +97,7 @@ 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 { convertJsonSchemaToZod } from './_tsup-dts-rollup.js';
 export { validateWorkflowFile } from './_tsup-dts-rollup.js';
 export { parseDynamicWorkflowDefinition } from './_tsup-dts-rollup.js';
 export { createDynamicWorkflow } from './_tsup-dts-rollup.js';
@@ -107,6 +108,12 @@ export { DynamicWorkflowParseResult } from './_tsup-dts-rollup.js';
 export { DynamicStepRuntimeContext } from './_tsup-dts-rollup.js';
 export { DynamicWorkflowRunnerOptions } from './_tsup-dts-rollup.js';
 export { ValidationResult } from './_tsup-dts-rollup.js';
+export { WhileLoopStep } from './_tsup-dts-rollup.js';
+export { IfElseStep } from './_tsup-dts-rollup.js';
+export { BreakStep } from './_tsup-dts-rollup.js';
+export { ContinueStep } from './_tsup-dts-rollup.js';
+export { TryCatchStep } from './_tsup-dts-rollup.js';
+export { WorkflowControlFlowStep } from './_tsup-dts-rollup.js';
 export { WorkflowInputDefinitionSchema } from './_tsup-dts-rollup.js';
 export { WorkflowStepDefinitionSchema } from './_tsup-dts-rollup.js';
 export { WhileLoopStepSchema } from './_tsup-dts-rollup.js';
@@ -119,12 +126,6 @@ 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 { WhileLoopStep } from './_tsup-dts-rollup.js';
-export { IfElseStep } from './_tsup-dts-rollup.js';
-export { BreakStep } from './_tsup-dts-rollup.js';
-export { ContinueStep } from './_tsup-dts-rollup.js';
-export { TryCatchStep } from './_tsup-dts-rollup.js';
-export { WorkflowControlFlowStep } 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';

package/dist/index.js

@@ -2403,7 +2403,18 @@ var WorkflowFileSchema = z20.object({
 var MAX_WHILE_LOOP_ITERATIONS = 1e3;
 function convertJsonSchemaToZod(schema) {
   if (schema.enum) {
-    return z21.enum(schema.enum.map((v) => String(v)));
+    const enumValues = schema.enum;
+    if (enumValues.length === 0) {
+      return z21.never();
+    }
+    if (enumValues.every((v) => typeof v === "string")) {
+      return z21.enum(enumValues);
+    }
+    const literals = enumValues.map((v) => z21.literal(v));
+    if (literals.length === 1) {
+      return literals[0];
+    }
+    return z21.union([literals[0], literals[1], ...literals.slice(2)]);
   }
   if (Array.isArray(schema.type)) {
     const types = schema.type;
@@ -2450,14 +2461,14 @@ function convertJsonSchemaToZod(schema) {
           shape[propName] = isRequired ? propZod : propZod.optional();
         }
       }
-      let objectSchema = z21.object(shape);
       if (schema.additionalProperties === true) {
-        objectSchema = objectSchema.and(z21.any());
-      } else if (typeof schema.additionalProperties === "object") {
+        return z21.object(shape).passthrough();
+      }
+      if (typeof schema.additionalProperties === "object") {
         const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
-        objectSchema = objectSchema.and(z21.record(z21.string(), additionalSchema));
+        return z21.intersection(z21.object(shape), z21.record(z21.string(), additionalSchema));
       }
-      return objectSchema;
+      return z21.object(shape);
     }
     case "array": {
       if (!schema.items) {
@@ -2572,8 +2583,13 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   }
   return validatedInput;
 }
-function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false) {
+function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false, logger) {
   if (allowUnsafeCodeExecution) {
+    if (logger) {
+      logger.warn(
+        `[SECURITY] Executing unsafe code evaluation for condition: ${condition}. This allows arbitrary JavaScript execution and should only be used for trusted workflows.`
+      );
+    }
     const functionBody = `
       try {
         return ${condition};
@@ -2751,6 +2767,7 @@ function getNestedProperty(obj, path) {
   let current = obj;
   for (const part of parts) {
     if (current == null) return void 0;
+    if (typeof current !== "object") return void 0;
     current = current[part];
   }
   return current;
@@ -2865,8 +2882,9 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
         };
       }
       if (toolName === "runWorkflow") {
-        const subWorkflowId = toolInput?.workflowId;
-        const subInput = toolInput?.input;
+        const runWorkflowInput = toolInput;
+        const subWorkflowId = runWorkflowInput?.workflowId;
+        const subInput = runWorkflowInput?.input;
         if (typeof subWorkflowId !== "string") {
           return {
             success: false,
@@ -3463,6 +3481,7 @@ export {
   askFollowupQuestion_default as askFollowupQuestion,
   computeRateLimitBackoffSeconds,
   configSchema,
+  convertJsonSchemaToZod,
   createContext,
   createDynamicWorkflow,
   executeCommand_default as executeCommand,

package/package.json

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