@kirha/planner 0.1.3 → 0.1.4

package/dist/index.js

@@ -20667,39 +20667,22 @@ function resolveValue(value, outputsByStepId) {
 
 // src/validator/index.ts
 var import_json52 = __toESM(require_lib(), 1);
-function createErrorContext(step, argumentPath, reference) {
-  return {
-    stepId: step.stepId,
-    toolName: step.toolName,
-    argumentPath: formatPath(argumentPath),
-    ...reference && {
-      fromStepId: reference.$fromStep,
-      outputPath: reference.$outputKey
-    }
-  };
-}
-function createValidationError(code, message, context, extra) {
-  return {
-    code,
-    message,
-    ...context,
-    ...extra
-  };
-}
 function isValidPlan(steps, tools) {
   const errors3 = [];
   const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
   const schemasByTool = new Map;
   const stepsById = new Map(steps.map((step) => [step.stepId, step]));
   for (const tool of tools) {
-    const { schemas: schemas3, errorDetail } = parseToolSchemas(tool);
-    if (schemas3) {
-      schemasByTool.set(tool.name, schemas3);
-    } else {
-      const detail = errorDetail ? `: ${errorDetail}` : "";
+    try {
+      schemasByTool.set(tool.name, {
+        input: parseSchema(tool.inputSchema),
+        output: parseSchema(tool.outputSchema)
+      });
+    } catch (error47) {
+      const detail = error47 instanceof Error ? error47.message : String(error47);
       errors3.push({
         code: "schema_parse_error",
-        message: `Failed to parse input/output schema for tool "${tool.name}"${detail}`,
+        message: `Failed to parse input/output schema for tool "${tool.name}": ${detail}`,
         toolName: tool.name
       });
     }
@@ -20726,42 +20709,30 @@ function isValidPlan(steps, tools) {
       continue;
     }
     traverseReferences(step.arguments, {
-      onDependency: (ref, path2) => {
-        validateDependencyReference({
-          reference: ref,
-          argumentPath: path2,
-          step,
-          inputSchema: schemas3.input,
-          stepsById,
-          schemasByTool,
-          errors: errors3
-        });
+      onDependency: (ref, inputPath) => {
+        const formattedInputPath = formatPath(inputPath);
+        const expectedSchema = getSchemaAtPath(schemas3.input, inputPath);
+        if (!expectedSchema) {
+          errors3.push({
+            code: "input_key_missing",
+            message: `Input path "${formattedInputPath}" not found on tool "${step.toolName}"`,
+            stepId: step.stepId,
+            toolName: step.toolName,
+            argumentPath: formattedInputPath,
+            fromStepId: ref.$fromStep,
+            outputPath: ref.$outputKey
+          });
+          return;
+        }
+        validateOutputReference(ref, formattedInputPath, expectedSchema, step, stepsById, schemasByTool, errors3);
       },
-      onTemplate: (ref, path2) => {
-        validateStringTemplateReference({
-          reference: ref,
-          argumentPath: path2,
-          step,
-          inputSchema: schemas3.input,
-          stepsById,
-          schemasByTool,
-          errors: errors3
-        });
+      onTemplate: (ref, inputPath) => {
+        validateStringTemplateReference(ref, inputPath, step, schemas3.input, stepsById, schemasByTool, errors3);
       }
     });
   }
   return { valid: errors3.length === 0, errors: errors3 };
 }
-function parseToolSchemas(tool) {
-  try {
-    const input = parseSchema(tool.inputSchema);
-    const output = parseSchema(tool.outputSchema);
-    return { schemas: { input, output } };
-  } catch (error47) {
-    const errorDetail = error47 instanceof Error ? error47.message : String(error47);
-    return { schemas: null, errorDetail };
-  }
-}
 function parseSchema(rawSchema) {
   try {
     return exports_external.fromJSONSchema(import_json52.default.parse(rawSchema));
@@ -20770,106 +20741,74 @@ function parseSchema(rawSchema) {
     throw new Error(`Invalid JSON schema: ${message}`);
   }
 }
-function getExpectedSchemaOrError(inputSchema, argumentPath, step, reference, errors3) {
-  const expectedSchema = getSchemaAtPath(inputSchema, argumentPath);
-  if (!expectedSchema) {
-    const context = createErrorContext(step, argumentPath, reference);
-    errors3.push(createValidationError("input_key_missing", `Input path "${context.argumentPath}" not found on tool "${step.toolName}"`, context));
-    return null;
-  }
-  return expectedSchema;
-}
-function validateDependencyReference({
-  reference,
-  argumentPath,
-  step,
-  inputSchema,
-  stepsById,
-  schemasByTool,
-  errors: errors3
-}) {
-  const expectedSchema = getExpectedSchemaOrError(inputSchema, argumentPath, step, reference, errors3);
-  if (expectedSchema) {
-    validateOutputReference({
-      reference,
-      argumentPath,
-      expectedSchema,
-      step,
-      stepsById,
-      schemasByTool,
-      errors: errors3
-    });
-  }
-}
-function resolveSourceStep(reference, stepsById, context, errors3) {
+function validateOutputReference(reference, inputPath, expectedSchema, step, stepsById, schemasByTool, errors3) {
+  const baseContext = {
+    stepId: step.stepId,
+    toolName: step.toolName,
+    argumentPath: inputPath,
+    fromStepId: reference.$fromStep,
+    outputPath: reference.$outputKey
+  };
   const sourceStep = stepsById.get(reference.$fromStep);
   if (!sourceStep) {
-    errors3.push(createValidationError("dependency_step_missing", `Step "${reference.$fromStep}" not found`, context));
-    return null;
+    errors3.push({
+      code: "dependency_step_missing",
+      message: `Step "${reference.$fromStep}" not found`,
+      ...baseContext
+    });
+    return;
   }
-  return sourceStep;
-}
-function resolveSourceSchemas(sourceStep, schemasByTool, context, errors3) {
   const sourceSchemas = schemasByTool.get(sourceStep.toolName);
   if (!sourceSchemas) {
-    errors3.push(createValidationError("schema_parse_error", `Output schema for tool "${sourceStep.toolName}" could not be parsed`, context));
-    return null;
+    errors3.push({
+      code: "schema_parse_error",
+      message: `Output schema for tool "${sourceStep.toolName}" could not be parsed`,
+      ...baseContext
+    });
+    return;
   }
-  return sourceSchemas;
-}
-function resolveOutputSchema(reference, sourceSchemas, sourceStep, context, errors3) {
   const outputSchema = getSchemaAtPath(sourceSchemas.output, parsePath(reference.$outputKey));
   if (!outputSchema) {
-    errors3.push(createValidationError("output_key_missing", `Output key "${reference.$outputKey}" not found on tool "${sourceStep.toolName}"`, context));
-    return null;
-  }
-  return outputSchema;
-}
-function validateOutputReference({
-  reference,
-  argumentPath,
-  expectedSchema,
-  step,
-  stepsById,
-  schemasByTool,
-  errors: errors3
-}) {
-  const context = createErrorContext(step, argumentPath, reference);
-  const sourceStep = resolveSourceStep(reference, stepsById, context, errors3);
-  if (!sourceStep)
-    return;
-  const sourceSchemas = resolveSourceSchemas(sourceStep, schemasByTool, context, errors3);
-  if (!sourceSchemas)
-    return;
-  const outputSchema = resolveOutputSchema(reference, sourceSchemas, sourceStep, context, errors3);
-  if (!outputSchema)
+    errors3.push({
+      code: "output_key_missing",
+      message: `Output key "${reference.$outputKey}" not found on tool "${sourceStep.toolName}"`,
+      ...baseContext
+    });
     return;
+  }
   if (!isSchemaCompatible(expectedSchema, outputSchema)) {
-    errors3.push(createValidationError("type_mismatch", `Type mismatch for "${context.argumentPath}"`, context, {
+    errors3.push({
+      code: "type_mismatch",
+      message: `Type mismatch for "${inputPath}"`,
+      ...baseContext,
       expectedType: describeSchemaType(expectedSchema),
       actualType: describeSchemaType(outputSchema)
-    }));
+    });
   }
 }
-function validateStringTemplateReference({
-  reference,
-  argumentPath,
-  step,
-  inputSchema,
-  stepsById,
-  schemasByTool,
-  errors: errors3
-}) {
-  const expectedSchema = getExpectedSchemaOrError(inputSchema, argumentPath, step, undefined, errors3);
+function validateStringTemplateReference(reference, inputPath, step, inputSchema, stepsById, schemasByTool, errors3) {
+  const formattedInputPath = formatPath(inputPath);
+  const expectedSchema = getSchemaAtPath(inputSchema, inputPath);
   if (!expectedSchema) {
+    errors3.push({
+      code: "input_key_missing",
+      message: `Input path "${formattedInputPath}" not found on tool "${step.toolName}"`,
+      stepId: step.stepId,
+      toolName: step.toolName,
+      argumentPath: formattedInputPath
+    });
     return;
   }
-  const context = createErrorContext(step, argumentPath);
   if (!isSchemaCompatible(expectedSchema, exports_external.string())) {
-    errors3.push(createValidationError("type_mismatch", `Type mismatch for "${context.argumentPath}"`, context, {
+    errors3.push({
+      code: "type_mismatch",
+      message: `Type mismatch for "${formattedInputPath}"`,
+      stepId: step.stepId,
+      toolName: step.toolName,
+      argumentPath: formattedInputPath,
       expectedType: describeSchemaType(expectedSchema),
       actualType: "string"
-    }));
+    });
   }
   const stringCoercible = exports_external.union([
     exports_external.string(),
@@ -20879,53 +20818,98 @@ function validateStringTemplateReference({
     exports_external.array(exports_external.any())
   ]);
   for (const ref of reference.$values) {
-    validateOutputReference({
-      reference: ref,
-      argumentPath,
-      expectedSchema: stringCoercible,
-      step,
-      stepsById,
-      schemasByTool,
-      errors: errors3
-    });
+    validateOutputReference(ref, formattedInputPath, stringCoercible, step, stepsById, schemasByTool, errors3);
   }
 }
 function getSchemaAtPath(schema, path2) {
-  let current = unwrapSchema(schema);
-  for (const segment of path2) {
-    if (typeof segment === "number") {
-      if (!(current instanceof exports_external.ZodArray)) {
-        return;
-      }
-      current = unwrapSchema(current.element);
-      continue;
-    }
-    if (current instanceof exports_external.ZodArray && isNumericString(segment)) {
-      current = unwrapSchema(current.element);
-      continue;
-    }
-    if (!(current instanceof exports_external.ZodObject)) {
+  const unwrapped = unwrapSchema(schema);
+  if (path2.length === 0) {
+    return unwrapped;
+  }
+  if (unwrapped instanceof exports_external.ZodUnion || unwrapped instanceof exports_external.ZodXor) {
+    const resolvedOptions = unwrapped.options.map((option) => getSchemaAtPath(option, path2)).filter((resolved) => resolved !== undefined);
+    if (resolvedOptions.length === 0) {
       return;
     }
-    const shape = current.shape;
-    const child = shape[segment];
-    if (!child) {
+    if (resolvedOptions.length === 1) {
+      return resolvedOptions[0];
+    }
+    return exports_external.union(resolvedOptions);
+  }
+  const segment = path2[0];
+  if (segment === undefined) {
+    return unwrapped;
+  }
+  const remainingPath = path2.slice(1);
+  if (typeof segment === "number") {
+    if (!(unwrapped instanceof exports_external.ZodArray)) {
       return;
     }
-    current = unwrapSchema(child);
+    return getSchemaAtPath(unwrapped.element, remainingPath);
   }
-  return current;
+  if (unwrapped instanceof exports_external.ZodArray && isNumericString(segment)) {
+    return getSchemaAtPath(unwrapped.element, remainingPath);
+  }
+  if (!(unwrapped instanceof exports_external.ZodObject)) {
+    return;
+  }
+  const shape = unwrapped.shape;
+  const childSchema = shape[segment];
+  if (!childSchema) {
+    return;
+  }
+  return getSchemaAtPath(childSchema, remainingPath);
 }
 function unwrapSchema(schema) {
   if (schema instanceof exports_external.ZodOptional || schema instanceof exports_external.ZodDefault || schema instanceof exports_external.ZodNullable) {
-    return unwrapSchema(schema._def.innerType);
+    return unwrapSchema(schema.def.innerType);
   }
   return schema;
 }
 function isSchemaCompatible(expected, actual) {
+  const expectedUnwrapped = unwrapSchema(expected);
+  const actualUnwrapped = unwrapSchema(actual);
+  if (expectedUnwrapped instanceof exports_external.ZodAny) {
+    return true;
+  }
+  if (expectedUnwrapped instanceof exports_external.ZodUnion || expectedUnwrapped instanceof exports_external.ZodXor) {
+    return expectedUnwrapped.options.some((option) => isSchemaCompatible(option, actualUnwrapped));
+  }
+  if (actualUnwrapped instanceof exports_external.ZodUnion || actualUnwrapped instanceof exports_external.ZodXor) {
+    return actualUnwrapped.options.some((option) => isSchemaCompatible(expectedUnwrapped, option));
+  }
+  if (expectedUnwrapped instanceof exports_external.ZodArray && actualUnwrapped instanceof exports_external.ZodArray) {
+    return isSchemaCompatible(expectedUnwrapped.element, actualUnwrapped.element);
+  }
+  if (expectedUnwrapped instanceof exports_external.ZodObject && actualUnwrapped instanceof exports_external.ZodObject) {
+    const expectedShape = expectedUnwrapped.shape;
+    const actualShape = actualUnwrapped.shape;
+    for (const [key, expectedFieldSchema] of Object.entries(expectedShape)) {
+      if (isOptionalField(expectedFieldSchema)) {
+        continue;
+      }
+      const actualFieldSchema = actualShape[key];
+      if (!actualFieldSchema) {
+        return false;
+      }
+      if (!isSchemaCompatible(expectedFieldSchema, actualFieldSchema)) {
+        return false;
+      }
+    }
+    for (const [key, actualFieldSchema] of Object.entries(actualShape)) {
+      const expectedFieldSchema = expectedShape[key];
+      if (!expectedFieldSchema) {
+        continue;
+      }
+      if (!isSchemaCompatible(expectedFieldSchema, actualFieldSchema)) {
+        return false;
+      }
+    }
+    return true;
+  }
   const expectedTypes = getTypeSet(expected);
   const actualTypes = getTypeSet(actual);
-  if (expectedTypes.has("any")) {
+  if (expectedTypes.has("any") || actualTypes.has("unknown")) {
     return true;
   }
   for (const actualType of actualTypes) {
@@ -20935,6 +20919,9 @@ function isSchemaCompatible(expected, actual) {
   }
   return false;
 }
+function isOptionalField(schema) {
+  return schema instanceof exports_external.ZodOptional || schema instanceof exports_external.ZodDefault;
+}
 var KNOWN_ZOD_TYPES = [
   [exports_external.ZodAny, "any"],
   [exports_external.ZodString, "string"],
@@ -20942,8 +20929,15 @@ var KNOWN_ZOD_TYPES = [
   [exports_external.ZodBoolean, "boolean"],
   [exports_external.ZodNull, "null"],
   [exports_external.ZodArray, "array"],
-  [exports_external.ZodObject, "object"]
+  [exports_external.ZodTuple, "array"],
+  [exports_external.ZodObject, "object"],
+  [exports_external.ZodEnum, "string"]
 ];
+var LITERAL_TYPE_MAP = {
+  string: "string",
+  number: "number",
+  boolean: "boolean"
+};
 function getTypeSet(schema) {
   const unwrapped = unwrapSchema(schema);
   for (const [ZodClass, typeName] of KNOWN_ZOD_TYPES) {
@@ -20951,7 +20945,11 @@ function getTypeSet(schema) {
       return new Set([typeName]);
     }
   }
-  if (unwrapped instanceof exports_external.ZodUnion) {
+  if (unwrapped instanceof exports_external.ZodLiteral) {
+    const type = LITERAL_TYPE_MAP[typeof unwrapped.value];
+    return new Set([type ?? "unknown"]);
+  }
+  if (unwrapped instanceof exports_external.ZodUnion || unwrapped instanceof exports_external.ZodXor) {
     const types = new Set;
     for (const option of unwrapped.options) {
       for (const type of getTypeSet(option)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirha/planner",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "SDK for tool-planning agents - generate and execute DAG execution plans from natural language",
   "type": "module",
   "main": "./dist/index.js",