@kirha/planner 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -0,0 +1,857 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  parsePlanSteps: () => parsePlanSteps,
+  isValidPlan: () => isValidPlan,
+  Planner: () => Planner,
+  Plan: () => Plan,
+  LATEST_MODEL_NAME: () => LATEST_MODEL_NAME
+});
+module.exports = __toCommonJS(exports_src);
+var import_openai = __toESM(require("openai"));
+var import_json53 = __toESM(require("json5"));
+
+// src/parser/index.ts
+var import_zod = require("zod");
+var import_json5 = __toESM(require("json5"));
+var import_uuid = require("uuid");
+
+// src/utils.ts
+var BRACKET_INDEX_REGEX = /\[(\d+)\]/g;
+var BRACKET_DOUBLE_QUOTE_REGEX = /\["([^"]+)"\]/g;
+var BRACKET_SINGLE_QUOTE_REGEX = /\['([^']+)'\]/g;
+var INDEX_MARKER_PREFIX = "\x00IDX:";
+function createIndexMarker(index) {
+  return `${INDEX_MARKER_PREFIX}${index}`;
+}
+function isIndexMarker(segment) {
+  return segment.startsWith(INDEX_MARKER_PREFIX);
+}
+function parseIndexMarker(segment) {
+  return Number(segment.slice(INDEX_MARKER_PREFIX.length));
+}
+function normalizeToSegments(path) {
+  if (!path) {
+    return "";
+  }
+  return path.replace(BRACKET_INDEX_REGEX, (_, index) => `.${createIndexMarker(index)}`).replace(BRACKET_DOUBLE_QUOTE_REGEX, ".$1").replace(BRACKET_SINGLE_QUOTE_REGEX, ".$1");
+}
+function parsePath(path) {
+  const normalized = normalizeToSegments(path);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split(".").filter(Boolean).map((segment) => {
+    if (isIndexMarker(segment)) {
+      return parseIndexMarker(segment);
+    }
+    return segment;
+  });
+}
+function normalizePath(path) {
+  return formatPath(parsePath(path));
+}
+function formatPath(path) {
+  if (path.length === 0) {
+    return "";
+  }
+  return path.reduce((acc, part) => {
+    if (typeof part === "number") {
+      return `${acc}[${part}]`;
+    }
+    return acc ? `${acc}.${part}` : part;
+  }, "");
+}
+function isNumericString(value) {
+  return /^\d+$/.test(value);
+}
+function getNestedValue(obj, path) {
+  let current = obj;
+  for (const part of path) {
+    if (current === null || current === undefined) {
+      return;
+    }
+    if (typeof part === "number") {
+      if (!Array.isArray(current)) {
+        return;
+      }
+      current = current[part];
+      continue;
+    }
+    if (Array.isArray(current) && isNumericString(part)) {
+      current = current[Number(part)];
+      continue;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function traverseReferences(value, callbacks, currentPath = []) {
+  if (isDependencyReference(value)) {
+    callbacks.onDependency?.(value, currentPath);
+    return;
+  }
+  if (isStringTemplateReference(value)) {
+    callbacks.onTemplate?.(value, currentPath);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      traverseReferences(item, callbacks, [...currentPath, index]);
+    }
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const [key, item] of Object.entries(value)) {
+      traverseReferences(item, callbacks, [...currentPath, key]);
+    }
+  }
+}
+function extractDependencyStepIds(args) {
+  const deps = [];
+  traverseReferences(args, {
+    onDependency: (ref) => deps.push(ref.$fromStep),
+    onTemplate: (ref) => {
+      for (const val of ref.$values) {
+        deps.push(val.$fromStep);
+      }
+    }
+  });
+  return [...new Set(deps)];
+}
+function isDependencyReference(value) {
+  return typeof value === "object" && value !== null && "$fromStep" in value && "$outputKey" in value;
+}
+function isStringTemplateReference(value) {
+  return typeof value === "object" && value !== null && "$fromTemplateString" in value && "$values" in value && Array.isArray(value.$values);
+}
+function isRawDependencyReference(value) {
+  return typeof value === "object" && value !== null && "fromStep" in value && "outputKey" in value;
+}
+
+// src/parser/template-string-parser.ts
+var NUMERIC_PLACEHOLDER = /\{(\d+)(?:\.([^}]+))?\}/g;
+function parseTemplateString(tpl, stepIdByIndex) {
+  const matches = Array.from(tpl.matchAll(NUMERIC_PLACEHOLDER));
+  if (matches.length === 0)
+    return tpl;
+  const values = [];
+  let result = "";
+  let lastIndex = 0;
+  for (const match of matches) {
+    const [full, idxStr, path] = match;
+    if (!idxStr) {
+      console.error("Invalid template reference: missing index", {
+        template: tpl,
+        index: idxStr
+      });
+      result += tpl.slice(lastIndex, (match.index ?? 0) + full.length);
+      lastIndex = (match.index ?? 0) + full.length;
+      continue;
+    }
+    const idx = Number.parseInt(idxStr, 10);
+    const stepId = stepIdByIndex.get(idx);
+    if (!stepId) {
+      console.error(`Invalid template reference: step index ${idx} not found`, {
+        template: tpl,
+        index: idx,
+        path
+      });
+      result += tpl.slice(lastIndex, (match.index ?? 0) + full.length);
+      lastIndex = (match.index ?? 0) + full.length;
+      continue;
+    }
+    values.push({
+      $fromStep: stepId,
+      $outputKey: path ? normalizePath(path) : ""
+    });
+    const start = match.index ?? 0;
+    result += `${tpl.slice(lastIndex, start)}{${values.length - 1}}`;
+    lastIndex = start + full.length;
+  }
+  result += tpl.slice(lastIndex);
+  if (values.length === 0) {
+    return tpl;
+  }
+  return { $fromTemplateString: result, $values: values };
+}
+
+// src/parser/index.ts
+var DependencyReferenceSchema = import_zod.z.object({
+  fromStep: import_zod.z.number(),
+  outputKey: import_zod.z.string()
+});
+var ParamSchema = import_zod.z.lazy(() => import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null(),
+  import_zod.z.array(ParamSchema),
+  DependencyReferenceSchema,
+  import_zod.z.record(import_zod.z.string(), ParamSchema)
+]));
+var ToolStepSchema = import_zod.z.object({
+  toolName: import_zod.z.string().optional(),
+  tool: import_zod.z.string().optional(),
+  arguments: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  params: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  parameters: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  thought: import_zod.z.string().optional()
+}).transform((step) => ({
+  toolName: step.toolName ?? step.tool,
+  arguments: step.arguments ?? step.args ?? step.params ?? step.parameters ?? {},
+  thought: step.thought
+})).refine((step) => step.toolName !== undefined, {
+  message: 'Step must have either "toolName" or "tool"'
+});
+var PlanSchema = import_zod.z.array(ToolStepSchema);
+function parseModelOutput(raw) {
+  const thinkMatch = raw.match(/<think>([\s\S]*?)<\/think>/);
+  const planMatch = raw.match(/<plan>([\s\S]*?)<\/plan>/);
+  const think = thinkMatch?.[1] ? thinkMatch[1].trim() : undefined;
+  const plan = planMatch?.[1] ? parsePlanSteps(planMatch[1]) : undefined;
+  return { think, plan };
+}
+function parsePlanSteps(rawSteps) {
+  const parsedRawSteps = parseJsonCodeBlock(rawSteps);
+  const rawPlan = PlanSchema.safeParse(parsedRawSteps);
+  if (!rawPlan.success) {
+    console.error(`Invalid plan: ${rawPlan.error.message}`, {
+      rawPlan,
+      rawSteps
+    });
+    throw new Error(`invalid json parsing: ${rawPlan.error.message}`);
+  }
+  const stepIdByIndex = new Map;
+  const rawPlanWithIds = rawPlan.data.map((step, index) => {
+    const stepId = import_uuid.v4();
+    stepIdByIndex.set(index, stepId);
+    return {
+      stepId,
+      ...step
+    };
+  });
+  return rawPlanWithIds.map((step) => ({
+    stepId: step.stepId,
+    status: "pending" /* Pending */,
+    toolName: step.toolName,
+    arguments: transformParams(step.arguments, stepIdByIndex),
+    thought: step.thought
+  }));
+}
+function parseJsonCodeBlock(codeBlock) {
+  const trimmed = codeBlock.trim();
+  const starts = ["{", "["].map((c) => trimmed.indexOf(c)).filter((i) => i !== -1);
+  const ends = ["}", "]"].map((c) => trimmed.lastIndexOf(c)).filter((i) => i !== -1);
+  if (starts.length === 0 || ends.length === 0) {
+    throw new Error("invalid json parsing: no JSON object or array found");
+  }
+  const start = Math.min(...starts);
+  const end = Math.max(...ends);
+  if (end < start) {
+    throw new Error("invalid json parsing: malformed JSON boundaries");
+  }
+  const jsonSubstring = trimmed.slice(start, end + 1);
+  try {
+    return import_json5.default.parse(jsonSubstring);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`invalid json parsing: ${error.message}`, { codeBlock });
+      throw new Error(`invalid json parsing: ${error.message}`);
+    }
+    throw new Error("invalid json parsing");
+  }
+}
+function transformParams(params, stepIdByIndex) {
+  const transformedParams = {};
+  for (const [key, value] of Object.entries(params)) {
+    transformedParams[key] = transformParamsValue(value, stepIdByIndex);
+  }
+  return transformedParams;
+}
+function transformParamsValue(value, stepIdByIndex) {
+  if (Array.isArray(value)) {
+    return value.map((v) => transformParamsValue(v, stepIdByIndex));
+  }
+  if (typeof value === "string") {
+    const spec = parseTemplateString(value, stepIdByIndex);
+    if (typeof spec !== "string") {
+      return spec;
+    }
+    return spec;
+  }
+  if (isRawDependencyReference(value)) {
+    const ref = value;
+    const stepId = stepIdByIndex.get(ref.fromStep);
+    if (!stepId) {
+      console.error(`Invalid dependency reference: step ${ref.fromStep} not found`, { dependencyReference: value });
+      throw new Error(`Invalid dependency reference: step ${ref.fromStep} not found`);
+    }
+    return { $fromStep: stepId, $outputKey: normalizePath(ref.outputKey) };
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = {};
+    for (const [k, v] of Object.entries(value)) {
+      obj[k] = transformParamsValue(v, stepIdByIndex);
+    }
+    return obj;
+  }
+  return value;
+}
+
+// src/executor/index.ts
+async function executePlan(steps, options) {
+  const toolsByName = new Map(options.tools.map((t) => [t.name, t]));
+  const results = [];
+  const outputsByStepId = new Map;
+  const statusByStepId = new Map(steps.map((s) => [s.stepId, "pending" /* Pending */]));
+  const tryExecuteStep = async (step) => {
+    const tool = toolsByName.get(step.toolName);
+    if (!tool) {
+      statusByStepId.set(step.stepId, "skipped" /* Skipped */);
+      results.push({
+        stepId: step.stepId,
+        toolName: step.toolName,
+        arguments: {},
+        output: null,
+        error: `Tool "${step.toolName}" not found`
+      });
+      return;
+    }
+    let resolvedArgs;
+    try {
+      resolvedArgs = resolveArguments(step.arguments, outputsByStepId);
+    } catch (error) {
+      statusByStepId.set(step.stepId, "skipped" /* Skipped */);
+      results.push({
+        stepId: step.stepId,
+        toolName: step.toolName,
+        arguments: {},
+        output: null,
+        error: `Failed to resolve arguments: ${error instanceof Error ? error.message : String(error)}`
+      });
+      return;
+    }
+    statusByStepId.set(step.stepId, "executing" /* Executing */);
+    try {
+      const output = await tool.handler(resolvedArgs);
+      outputsByStepId.set(step.stepId, output);
+      statusByStepId.set(step.stepId, "done" /* Done */);
+      results.push({
+        stepId: step.stepId,
+        toolName: step.toolName,
+        arguments: resolvedArgs,
+        output
+      });
+    } catch (error) {
+      statusByStepId.set(step.stepId, "failed" /* Failed */);
+      results.push({
+        stepId: step.stepId,
+        toolName: step.toolName,
+        arguments: resolvedArgs,
+        output: null,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const getReadySteps = () => {
+    return steps.filter((step) => {
+      if (statusByStepId.get(step.stepId) !== "pending" /* Pending */) {
+        return false;
+      }
+      const deps = extractDependencyStepIds(step.arguments);
+      return deps.every((depStepId) => statusByStepId.get(depStepId) === "done" /* Done */);
+    });
+  };
+  let readySteps = getReadySteps();
+  while (readySteps.length > 0) {
+    await Promise.all(readySteps.map(tryExecuteStep));
+    readySteps = getReadySteps();
+  }
+  for (const step of steps) {
+    if (statusByStepId.get(step.stepId) === "pending" /* Pending */) {
+      statusByStepId.set(step.stepId, "skipped" /* Skipped */);
+      results.push({
+        stepId: step.stepId,
+        toolName: step.toolName,
+        arguments: step.arguments,
+        output: null,
+        error: "Skipped: dependencies not satisfied"
+      });
+    }
+  }
+  const stepOrder = new Map(steps.map((s, i) => [s.stepId, i]));
+  results.sort((a, b) => (stepOrder.get(a.stepId) ?? 0) - (stepOrder.get(b.stepId) ?? 0));
+  return results;
+}
+function resolveArguments(args, outputsByStepId) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(args)) {
+    resolved[key] = resolveValue(value, outputsByStepId);
+  }
+  return resolved;
+}
+function resolveValue(value, outputsByStepId) {
+  if (Array.isArray(value)) {
+    return value.map((v) => resolveValue(v, outputsByStepId));
+  }
+  if (isDependencyReference(value)) {
+    const stepOutput = outputsByStepId.get(value.$fromStep);
+    if (stepOutput === undefined) {
+      throw new Error(`Step ${value.$fromStep} output not found`);
+    }
+    return getNestedValue(stepOutput, parsePath(value.$outputKey));
+  }
+  if (isStringTemplateReference(value)) {
+    let result = value.$fromTemplateString;
+    for (const [i, ref] of value.$values.entries()) {
+      const stepOutput = outputsByStepId.get(ref.$fromStep);
+      const resolvedValue = getNestedValue(stepOutput, parsePath(ref.$outputKey));
+      const stringified = typeof resolvedValue === "object" && resolvedValue !== null ? JSON.stringify(resolvedValue) : String(resolvedValue);
+      result = result.replace(`{${i}}`, stringified);
+    }
+    return result;
+  }
+  if (typeof value === "object" && value !== null) {
+    const resolved = {};
+    for (const [k, v] of Object.entries(value)) {
+      resolved[k] = resolveValue(v, outputsByStepId);
+    }
+    return resolved;
+  }
+  return value;
+}
+
+// src/validator/index.ts
+var import_json52 = __toESM(require("json5"));
+var import_zod2 = require("zod");
+function isValidPlan(steps, tools) {
+  const errors = [];
+  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) {
+    try {
+      schemasByTool.set(tool.name, {
+        input: parseSchema(tool.inputSchema),
+        output: parseSchema(tool.outputSchema)
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      errors.push({
+        code: "schema_parse_error",
+        message: `Failed to parse input/output schema for tool "${tool.name}": ${detail}`,
+        toolName: tool.name
+      });
+    }
+  }
+  for (const step of steps) {
+    const tool = toolsByName.get(step.toolName);
+    if (!tool) {
+      errors.push({
+        code: "tool_not_found",
+        message: `Tool "${step.toolName}" not found`,
+        stepId: step.stepId,
+        toolName: step.toolName
+      });
+      continue;
+    }
+    const schemas = schemasByTool.get(tool.name);
+    if (!schemas) {
+      errors.push({
+        code: "schema_parse_error",
+        message: `Schemas for tool "${tool.name}" could not be parsed`,
+        stepId: step.stepId,
+        toolName: tool.name
+      });
+      continue;
+    }
+    traverseReferences(step.arguments, {
+      onDependency: (ref, inputPath) => {
+        const formattedInputPath = formatPath(inputPath);
+        const expectedSchema = getSchemaAtPath(schemas.input, inputPath);
+        if (!expectedSchema) {
+          errors.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, errors);
+      },
+      onTemplate: (ref, inputPath) => {
+        validateStringTemplateReference(ref, inputPath, step, schemas.input, stepsById, schemasByTool, errors);
+      }
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function parseSchema(rawSchema) {
+  try {
+    return import_zod2.z.fromJSONSchema(import_json52.default.parse(rawSchema));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON schema: ${message}`);
+  }
+}
+function validateOutputReference(reference, inputPath, expectedSchema, step, stepsById, schemasByTool, errors) {
+  const baseContext = {
+    stepId: step.stepId,
+    toolName: step.toolName,
+    argumentPath: inputPath,
+    fromStepId: reference.$fromStep,
+    outputPath: reference.$outputKey
+  };
+  const sourceStep = stepsById.get(reference.$fromStep);
+  if (!sourceStep) {
+    errors.push({
+      code: "dependency_step_missing",
+      message: `Step "${reference.$fromStep}" not found`,
+      ...baseContext
+    });
+    return;
+  }
+  const sourceSchemas = schemasByTool.get(sourceStep.toolName);
+  if (!sourceSchemas) {
+    errors.push({
+      code: "schema_parse_error",
+      message: `Output schema for tool "${sourceStep.toolName}" could not be parsed`,
+      ...baseContext
+    });
+    return;
+  }
+  const outputSchema = getSchemaAtPath(sourceSchemas.output, parsePath(reference.$outputKey));
+  if (!outputSchema) {
+    errors.push({
+      code: "output_key_missing",
+      message: `Output key "${reference.$outputKey}" not found on tool "${sourceStep.toolName}"`,
+      ...baseContext
+    });
+    return;
+  }
+  if (!isSchemaCompatible(expectedSchema, outputSchema)) {
+    errors.push({
+      code: "type_mismatch",
+      message: `Type mismatch for "${inputPath}"`,
+      ...baseContext,
+      expectedType: describeSchemaType(expectedSchema),
+      actualType: describeSchemaType(outputSchema)
+    });
+  }
+}
+function validateStringTemplateReference(reference, inputPath, step, inputSchema, stepsById, schemasByTool, errors) {
+  const formattedInputPath = formatPath(inputPath);
+  const expectedSchema = getSchemaAtPath(inputSchema, inputPath);
+  if (!expectedSchema) {
+    errors.push({
+      code: "input_key_missing",
+      message: `Input path "${formattedInputPath}" not found on tool "${step.toolName}"`,
+      stepId: step.stepId,
+      toolName: step.toolName,
+      argumentPath: formattedInputPath
+    });
+    return;
+  }
+  if (!isSchemaCompatible(expectedSchema, import_zod2.z.string())) {
+    errors.push({
+      code: "type_mismatch",
+      message: `Type mismatch for "${formattedInputPath}"`,
+      stepId: step.stepId,
+      toolName: step.toolName,
+      argumentPath: formattedInputPath,
+      expectedType: describeSchemaType(expectedSchema),
+      actualType: "string"
+    });
+  }
+  const stringCoercible = import_zod2.z.union([
+    import_zod2.z.string(),
+    import_zod2.z.number(),
+    import_zod2.z.boolean(),
+    import_zod2.z.object({}),
+    import_zod2.z.array(import_zod2.z.any())
+  ]);
+  for (const ref of reference.$values) {
+    validateOutputReference(ref, formattedInputPath, stringCoercible, step, stepsById, schemasByTool, errors);
+  }
+}
+function getSchemaAtPath(schema, path) {
+  const unwrapped = unwrapSchema(schema);
+  if (path.length === 0) {
+    return unwrapped;
+  }
+  if (unwrapped instanceof import_zod2.z.ZodUnion || unwrapped instanceof import_zod2.z.ZodXor) {
+    const resolvedOptions = unwrapped.options.map((option) => getSchemaAtPath(option, path)).filter((resolved) => resolved !== undefined);
+    if (resolvedOptions.length === 0) {
+      return;
+    }
+    if (resolvedOptions.length === 1) {
+      return resolvedOptions[0];
+    }
+    return import_zod2.z.union(resolvedOptions);
+  }
+  const segment = path[0];
+  if (segment === undefined) {
+    return unwrapped;
+  }
+  const remainingPath = path.slice(1);
+  if (typeof segment === "number") {
+    if (!(unwrapped instanceof import_zod2.z.ZodArray)) {
+      return;
+    }
+    return getSchemaAtPath(unwrapped.element, remainingPath);
+  }
+  if (unwrapped instanceof import_zod2.z.ZodArray && isNumericString(segment)) {
+    return getSchemaAtPath(unwrapped.element, remainingPath);
+  }
+  if (!(unwrapped instanceof import_zod2.z.ZodObject)) {
+    return;
+  }
+  const childSchema = getObjectChildSchema(unwrapped, segment);
+  if (!childSchema) {
+    return;
+  }
+  return getSchemaAtPath(childSchema, remainingPath);
+}
+function getObjectChildSchema(schema, segment) {
+  const shape = schema.shape;
+  const direct = shape[segment];
+  if (direct) {
+    return direct;
+  }
+  const catchall = schema.def.catchall;
+  if (catchall && !(catchall instanceof import_zod2.z.ZodUnknown) && !(catchall instanceof import_zod2.z.ZodAny) && !(catchall instanceof import_zod2.z.ZodNever)) {
+    return catchall;
+  }
+  if (Object.keys(shape).length === 0) {
+    return import_zod2.z.any();
+  }
+  return;
+}
+function unwrapSchema(schema) {
+  if (schema instanceof import_zod2.z.ZodOptional || schema instanceof import_zod2.z.ZodDefault || schema instanceof import_zod2.z.ZodNullable) {
+    return unwrapSchema(schema.def.innerType);
+  }
+  return schema;
+}
+function isSchemaCompatible(expected, actual) {
+  const expectedUnwrapped = unwrapSchema(expected);
+  const actualUnwrapped = unwrapSchema(actual);
+  if (expectedUnwrapped instanceof import_zod2.z.ZodAny || actualUnwrapped instanceof import_zod2.z.ZodAny) {
+    return true;
+  }
+  if (expectedUnwrapped instanceof import_zod2.z.ZodUnion || expectedUnwrapped instanceof import_zod2.z.ZodXor) {
+    return expectedUnwrapped.options.some((option) => isSchemaCompatible(option, actualUnwrapped));
+  }
+  if (actualUnwrapped instanceof import_zod2.z.ZodUnion || actualUnwrapped instanceof import_zod2.z.ZodXor) {
+    return actualUnwrapped.options.some((option) => isSchemaCompatible(expectedUnwrapped, option));
+  }
+  if (expectedUnwrapped instanceof import_zod2.z.ZodArray && actualUnwrapped instanceof import_zod2.z.ZodArray) {
+    return isSchemaCompatible(expectedUnwrapped.element, actualUnwrapped.element);
+  }
+  if (expectedUnwrapped instanceof import_zod2.z.ZodObject && actualUnwrapped instanceof import_zod2.z.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") || actualTypes.has("unknown")) {
+    return true;
+  }
+  for (const actualType of actualTypes) {
+    if (expectedTypes.has(actualType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isOptionalField(schema) {
+  return schema instanceof import_zod2.z.ZodOptional || schema instanceof import_zod2.z.ZodDefault;
+}
+var KNOWN_ZOD_TYPES = [
+  [import_zod2.z.ZodAny, "any"],
+  [import_zod2.z.ZodUnknown, "any"],
+  [import_zod2.z.ZodString, "string"],
+  [import_zod2.z.ZodNumber, "number"],
+  [import_zod2.z.ZodBoolean, "boolean"],
+  [import_zod2.z.ZodNull, "null"],
+  [import_zod2.z.ZodArray, "array"],
+  [import_zod2.z.ZodTuple, "array"],
+  [import_zod2.z.ZodObject, "object"],
+  [import_zod2.z.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) {
+    if (unwrapped instanceof ZodClass) {
+      return new Set([typeName]);
+    }
+  }
+  if (unwrapped instanceof import_zod2.z.ZodLiteral) {
+    const type = LITERAL_TYPE_MAP[typeof unwrapped.value];
+    return new Set([type ?? "unknown"]);
+  }
+  if (unwrapped instanceof import_zod2.z.ZodUnion || unwrapped instanceof import_zod2.z.ZodXor) {
+    const types = new Set;
+    for (const option of unwrapped.options) {
+      for (const type of getTypeSet(option)) {
+        types.add(type);
+      }
+    }
+    return types;
+  }
+  return new Set(["unknown"]);
+}
+function describeSchemaType(schema) {
+  return [...getTypeSet(schema)].sort().join(" | ");
+}
+// src/index.ts
+var LATEST_MODEL_NAME = "kirha/planner";
+
+class Plan {
+  steps;
+  think;
+  constructor(steps, think) {
+    this.steps = steps;
+    this.think = think;
+  }
+  async execute(options) {
+    return executePlan(this.steps, options);
+  }
+}
+
+class Planner {
+  openai;
+  model;
+  constructor(baseUrl, {
+    apiKey,
+    model = LATEST_MODEL_NAME
+  }) {
+    this.openai = new import_openai.default({
+      baseURL: baseUrl,
+      apiKey: apiKey ?? ""
+    });
+    this.model = model;
+  }
+  async generatePlan(query, options) {
+    const tools = import_json53.default.stringify(options.tools);
+    const additionalInstructions = options.instructions ? `# Instructions
+${options.instructions}
+` : "";
+    const systemPrompt = `${additionalInstructions}# Available tools
+<tools>${tools}</tools>`;
+    const response = await this.openai.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: query }
+      ],
+      temperature: options.temperature ?? 0.3,
+      max_tokens: options.maxTokens ?? 1e4
+    });
+    const choice = response.choices?.[0];
+    if (!choice) {
+      throw new Error("No response from model");
+    }
+    const rawResponse = choice.message.content;
+    if (!rawResponse) {
+      throw new Error("No plan generated");
+    }
+    const { think, plan } = parseModelOutput(rawResponse);
+    return plan ? new Plan(plan, think) : undefined;
+  }
+}