@autonoma-ai/planner 0.1.10 → 0.1.11

package/dist/index.js

@@ -3564,6 +3564,9 @@ async function sendRequest(config, payload) {
   }
   return { ok: res.ok, status: res.status, body };
 }
+async function discover(config) {
+  return sendRequest(config, { action: "discover" });
+}
 async function up(config, create, testRunId) {
   return sendRequest(config, {
     action: "up",
@@ -3585,6 +3588,130 @@ var init_http_client = __esm({
   }
 });
 
+// src/agents/04-recipe-builder/discover-schema.ts
+function parseDiscoverBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const schema = body.schema;
+  if (!schema || typeof schema !== "object") return null;
+  const rawModels = schema.models;
+  if (!Array.isArray(rawModels)) return null;
+  const models = /* @__PURE__ */ new Map();
+  for (const m of rawModels) {
+    if (!m || typeof m !== "object") continue;
+    const mm = m;
+    if (typeof mm.name !== "string") continue;
+    const rawFields = Array.isArray(mm.fields) ? mm.fields : [];
+    const fields = [];
+    for (const f of rawFields) {
+      if (!f || typeof f !== "object") continue;
+      const ff = f;
+      if (typeof ff.name !== "string") continue;
+      fields.push({
+        name: ff.name,
+        type: typeof ff.type === "string" ? ff.type : "string",
+        isRequired: ff.isRequired === true,
+        isId: ff.isId === true,
+        hasDefault: ff.hasDefault === true
+      });
+    }
+    models.set(mm.name, { name: mm.name, tableName: typeof mm.tableName === "string" ? mm.tableName : mm.name, fields });
+  }
+  const scopeField = typeof schema.scopeField === "string" && schema.scopeField.length > 0 ? schema.scopeField : null;
+  return { models, scopeField };
+}
+async function fetchDiscoverSchema(config) {
+  try {
+    const res = await discover(config);
+    if (!res.ok) return null;
+    return parseDiscoverBody(res.body);
+  } catch {
+    return null;
+  }
+}
+function isMandatory(field) {
+  return field.isRequired && !field.isId && !field.hasDefault;
+}
+function renderModelSchema(schema, modelName) {
+  const m = schema.models.get(modelName);
+  if (!m) return null;
+  const lines = m.fields.filter((f) => !f.isId).map((f) => {
+    const req = isMandatory(f) ? "REQUIRED" : f.hasDefault ? "optional (has default)" : "optional";
+    const scopeNote = schema.scopeField && f.name === schema.scopeField ? '  \u2190 scope/tenant field \u2014 the SDK does NOT auto-fill it; set it explicitly (use a { "_ref": "..." } to the scope entity)' : "";
+    return `  - ${f.name}: ${f.type} (${req})${scopeNote}`;
+  });
+  return `Live schema for "${modelName}" (from the SDK /discover endpoint \u2014 this is the SOURCE OF TRUTH; it overrides the entity audit when they disagree):
+${lines.join("\n")}
+
+Every REQUIRED field above must be present on every record. Do not send fields that are not listed.`;
+}
+function validateRecipeAgainstSchema(recipe, schema) {
+  const problems = [];
+  const declaredAliases = /* @__PURE__ */ new Set();
+  for (const records of Object.values(recipe)) {
+    for (const rec of records) {
+      if (typeof rec._alias === "string") declaredAliases.add(rec._alias);
+    }
+  }
+  for (const [modelName, records] of Object.entries(recipe)) {
+    const model = schema.models.get(modelName);
+    records.forEach((record, recordIndex) => {
+      if (model) {
+        for (const field of model.fields) {
+          if (!isMandatory(field)) continue;
+          const value = record[field.name];
+          if (value === void 0 || value === null) {
+            problems.push({
+              model: modelName,
+              recordIndex,
+              message: `missing required field "${field.name}" (${field.type})`
+            });
+          }
+        }
+      }
+      const refs = /* @__PURE__ */ new Set();
+      collectRefs2(record, refs);
+      for (const alias of refs) {
+        if (!declaredAliases.has(alias)) {
+          problems.push({
+            model: modelName,
+            recordIndex,
+            message: `_ref points at "${alias}", which no record in this payload declares with an _alias`
+          });
+        }
+      }
+    });
+  }
+  return problems;
+}
+function collectRefs2(value, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectRefs2(v, out);
+  } else if (value !== null && typeof value === "object") {
+    const obj = value;
+    if (typeof obj._ref === "string") {
+      out.add(obj._ref);
+      return;
+    }
+    for (const v of Object.values(obj)) collectRefs2(v, out);
+  }
+}
+function formatValidationProblems(problems) {
+  const byModel = /* @__PURE__ */ new Map();
+  for (const p10 of problems) {
+    const key = `${p10.model}[${p10.recordIndex}]`;
+    if (!byModel.has(key)) byModel.set(key, []);
+    byModel.get(key).push(p10.message);
+  }
+  return [...byModel.entries()].map(([key, msgs]) => `${key}: ${msgs.join("; ")}`).join("\n");
+}
+var init_discover_schema = __esm({
+  "src/agents/04-recipe-builder/discover-schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_http_client();
+  }
+});
+
 // src/agents/04-recipe-builder/phases/failure-classifier.ts
 import { Output as Output2, generateText as generateText2 } from "ai";
 import { z as z16 } from "zod";
@@ -3619,6 +3746,8 @@ ${args.validRefAliases?.trim() || "(none \u2014 this is a root entity with no pa
 What the entity audit recorded about how "${args.entityName}" is created:
 ${args.entityAudit?.trim() || "(not available)"}
 
+${args.liveSchema?.trim() || "(no live schema available \u2014 the /discover endpoint was unreachable)"}
+
 Test data sent:
 ${JSON.stringify(args.recipe, null, 2)}
 
@@ -3680,7 +3809,7 @@ function summarizeEntityAudit(model) {
   if (model.side_effects?.length) parts.push(`side effects: ${model.side_effects.join(", ")}`);
   return parts.join("; ");
 }
-async function proposeRecipeData(entityName, entityIndex, totalEntities, model, outputDir, _projectRoot, completedEntities) {
+async function proposeRecipeData(entityName, entityIndex, totalEntities, model, outputDir, _projectRoot, completedEntities, schemaSpec) {
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger(`propose:${entityName}`, 20);
   const finishTool = tool14({
@@ -3698,10 +3827,14 @@ async function proposeRecipeData(entityName, entityIndex, totalEntities, model,
 
 Read scenarios.md and entity-audit.md from the output directory. Design records that match the scenario data.
 
+${schemaSpec ? `${schemaSpec}
+` : ""}
 ${completedAliases ? `Already completed entities (use _ref to reference their aliases):
 ${completedAliases}
 ` : "This is a root entity \u2014 no parent references needed."}
 
+Produce records for "${entityName}" ONLY \u2014 one object per record. Do not include records for other models; the tool assembles parent entities automatically.
+
 Call finish with the JSON array of records.`;
   const readOutputTool = buildReadFileTool(outputDir);
   await runAgent(
@@ -3723,7 +3856,7 @@ Call finish with the JSON array of records.`;
   logger.summary();
   return result ?? [];
 }
-async function reviseRecipeData(entityName, entityIndex, totalEntities, current, feedback, model, outputDir, completedEntities) {
+async function reviseRecipeData(entityName, entityIndex, totalEntities, current, feedback, model, outputDir, completedEntities, schemaSpec) {
   let revised;
   const finishTool = tool14({
     description: "Submit the fixed recipe data.",
@@ -3747,11 +3880,12 @@ ${completedAliases}
       systemPrompt: `You are fixing recipe data based on user feedback (or a validation failure). Read the error, the current data, and the user's feedback. Read scenarios.md and entity-audit.md if needed. Fix the data and call finish.
 
 Rules:
+- Return records for "${entityName}" ONLY \u2014 a flat JSON array, one object per record. NEVER group records by model name or nest other models (Client/User/etc.) inside this array. The tool assembles parent entities into the request automatically; your job is only this one entity's rows.
 - _alias fields must be unique identifiers (e.g., "card_1", "transaction_1")
 - _ref fields must reference an alias that ALREADY EXISTS on a parent entity \u2014 see the list of valid targets below. Never invent a _ref to an alias that isn't listed.
 - If the error says "references unknown alias(es): X", a _ref points at "X" but nothing being created declares it. Correct that _ref to one of the valid targets listed below (it's usually a typo, e.g. "users_1" vs "user_1"), or drop the reference if the field is optional. Do NOT leave a _ref pointing at an alias that isn't in the valid targets list.
 - Read scenarios.md to verify you're using correct alias names from parent entities
-- Field names must match the entity's schema from entity-audit.md`,
+- Field names and required fields must match the live schema below when present (it is the source of truth), otherwise the entity's schema from entity-audit.md`,
       model,
       maxSteps: 15,
       tools: (_heartbeat) => ({
@@ -3769,6 +3903,8 @@ What's wrong / what to change:
 ${feedback}
 
 ${aliasBlock}
+${schemaSpec ? `${schemaSpec}
+` : ""}
 Read scenarios.md and entity-audit.md to understand the correct aliases and schema. Apply the change and call finish.`,
     () => revised
   );
@@ -3843,7 +3979,7 @@ Read the creation file from the project to understand the existing service/funct
   logger.summary();
   return result ?? "No instructions generated. Check the entity audit for creation_file and creation_function.";
 }
-async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir, completedEntities) {
+async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir, completedEntities, schemaSpec) {
   p5.log.info(
     `Legend for recipe fields:
   _alias \u2014 Internal ID used to reference this record from other entities (e.g., { "_ref": "org_1" })
@@ -3898,7 +4034,8 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
         feedback.trim(),
         model,
         outputDir,
-        completedEntities
+        completedEntities,
+        schemaSpec
       );
     }
   }
@@ -3923,7 +4060,8 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
     error: errorBody,
     recipe: ctx.recipe,
     validRefAliases: ctx.validRefAliases,
-    entityAudit: ctx.entityAudit
+    entityAudit: ctx.entityAudit,
+    liveSchema: ctx.liveSchema
   });
   if (ctx.budget.attempts < MAX_AUTOFIX_ATTEMPTS) {
     ctx.budget.attempts++;
@@ -3961,10 +4099,22 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
   if (p5.isCancel(fb)) throw new Error("Entity loop cancelled");
   return { feedback: `${fb.trim()}${errorContext}` };
 }
-async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe, grounding) {
+async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe, grounding, discoverSchema) {
   p5.log.info(`Let's verify this factory works. We'll send a test request to create ${entityName}, then check the database.`);
   const failureCtx = { ...grounding, recipe };
   while (true) {
+    if (discoverSchema) {
+      const problems = validateRecipeAgainstSchema(recipe, discoverSchema);
+      if (problems.length > 0) {
+        const errorBody = `Recipe failed local schema validation against /discover (not sent to the server):
+${formatValidationProblems(problems)}`;
+        p5.log.error(errorBody);
+        const action = await promptOnFailure(entityName, errorBody, failureCtx, "create");
+        if (action === "skip") return "skip";
+        if (action === "retry") continue;
+        return action;
+      }
+    }
     const testRunId = `test-${Date.now()}`;
     p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
     let upResult;
@@ -4023,6 +4173,15 @@ ${formatException(err)}`);
 async function runEntityLoop(state, models, model, projectRoot, outputDir, nonInteractive) {
   const total = state.entityOrder.length;
   const modelMap = new Map(models.map((m) => [m.name, m]));
+  async function loadLiveSchema(name) {
+    if (!state.sdkEndpointUrl || !state.sharedSecret) return { schema: null };
+    const schema = await fetchDiscoverSchema({
+      endpointUrl: state.sdkEndpointUrl,
+      sharedSecret: state.sharedSecret
+    });
+    if (!schema) return { schema: null };
+    return { schema, spec: renderModelSchema(schema, name) ?? void 0 };
+  }
   p5.log.info(
     `We're going to set up your test data factories one entity at a time. Each factory teaches the Autonoma SDK how to create and tear down a specific type of record in YOUR database, using YOUR existing service functions.
 
@@ -4052,6 +4211,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     const depInfo = isRoot ? "This is a root entity \u2014 no dependencies." : `This depends on: ${auditModel.created_by.map((d) => d.owner).join(", ")}`;
     p5.log.step(`[${i + 1}/${total}] ${entityName}`);
     p5.log.info(depInfo);
+    const { spec: recipeSchemaSpec } = await loadLiveSchema(entityName);
     let recipeData = existing?.recipeData;
     if (!recipeData || existing?.status === "pending") {
       recipeData = await proposeRecipeData(
@@ -4061,11 +4221,12 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         model,
         outputDir,
         projectRoot,
-        state.entities
+        state.entities,
+        recipeSchemaSpec
       );
     }
     if (!nonInteractive) {
-      recipeData = await reviewRecipeData(entityName, i, total, recipeData, model, outputDir, state.entities);
+      recipeData = await reviewRecipeData(entityName, i, total, recipeData, model, outputDir, state.entities, recipeSchemaSpec);
     }
     state.entities[entityName] = {
       entityName,
@@ -4160,17 +4321,19 @@ Saved to: ${join23(outputDir, "autonoma-config.json")}`,
         endpointUrl: state.sdkEndpointUrl,
         sharedSecret: state.sharedSecret
       };
+      const { schema: discoverSchema, spec: liveSchemaSpec } = await loadLiveSchema(entityName);
       const autofixBudget = { attempts: 0 };
       const grounding = {
         model,
         budget: autofixBudget,
         validRefAliases: summarizeCompletedAliases(state.entities, entityName),
-        entityAudit: summarizeEntityAudit(models.find((m) => m.name === entityName))
+        entityAudit: summarizeEntityAudit(models.find((m) => m.name === entityName)),
+        liveSchema: liveSchemaSpec
       };
       let testDone = false;
       while (!testDone) {
         const singleRecipe = buildSingleEntityRecipe(entityName, models, state.entityOrder, state.entities);
-        const testResult = await testUpDown(entityName, i, total, sdkConfig, singleRecipe, grounding);
+        const testResult = await testUpDown(entityName, i, total, sdkConfig, singleRecipe, grounding, discoverSchema ?? void 0);
         if (testResult === "success") {
           state.entities[entityName].status = "tested-down";
           p5.log.success(`[${i + 1}/${total}] ${entityName} \u2014 factory verified`);
@@ -4190,7 +4353,8 @@ Saved to: ${join23(outputDir, "autonoma-config.json")}`,
             testResult.feedback,
             model,
             outputDir,
-            state.entities
+            state.entities,
+            liveSchemaSpec
           );
           state.entities[entityName].recipeData = revised;
           await saveRecipeState(outputDir, state);
@@ -4219,6 +4383,7 @@ var init_entity_loop = __esm({
     init_notify();
     init_recipe();
     init_http_client();
+    init_discover_schema();
     init_failure_classifier();
     PROPOSAL_PROMPT = `You are a recipe data designer. Given an entity from the entity audit and the scenario data, produce a JSON array of records for this entity.
 
@@ -4255,7 +4420,7 @@ When done, call finish with the instructions text.`;
 import * as p6 from "@clack/prompts";
 import { tool as tool15 } from "ai";
 import { z as z18 } from "zod";
-async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder) {
+async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder, schemaSpec) {
   let revised;
   const finishTool = tool15({
     description: "Submit the revised full recipe: an object mapping each entity name to its array of records.",
@@ -4281,9 +4446,11 @@ Rules:
 - Apply the user's feedback across whatever entities it touches.
 - Keep _ref values pointing to aliases that actually exist in the recipe. Never invent a _ref to a missing alias.
 - Entities are created in this order (parents first): ${entityOrder.join(" \u2192 ")}. A record may only _ref an alias declared by an entity earlier in that order.
-- Field names/types must match the schema in entity-audit.md.
+- Field names, types, and required fields must match the live schema below when present (it is the source of truth), otherwise the schema in entity-audit.md.
 - Read scenarios.md and entity-audit.md from the output directory as needed.
-
+${schemaSpec ? `
+${schemaSpec}
+` : ""}
 Return the COMPLETE revised recipe (all entities, not just the changed ones) via finish.`,
       model,
       maxSteps: 20,
@@ -4345,8 +4512,19 @@ async function runFullValidation(state, _models, outputDir, model) {
     endpointUrl: state.sdkEndpointUrl,
     sharedSecret: state.sharedSecret ?? ""
   };
+  const discoverSchema = await fetchDiscoverSchema(sdkConfig);
+  const fullSchemaSpec = discoverSchema ? state.entityOrder.map((name) => renderModelSchema(discoverSchema, name)).filter(Boolean).join("\n\n") || void 0 : void 0;
   let fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
   while (true) {
+    if (discoverSchema) {
+      const problems = validateRecipeAgainstSchema(fullRecipe, discoverSchema);
+      if (problems.length > 0) {
+        p6.log.warn(
+          `Heads up \u2014 the recipe has likely schema problems (from /discover); the full UP may fail:
+${formatValidationProblems(problems)}`
+        );
+      }
+    }
     const testRunId = `full-${Date.now()}`;
     p6.log.step(`[Full validation] Creating all ${total} entities...`);
     let upResult;
@@ -4420,7 +4598,7 @@ ${formatException(err)}`);
       return false;
     }
     p6.log.info("Revising the full recipe based on your feedback...");
-    const revised = await reviseFullRecipe(fullRecipe, feedback.trim(), model, outputDir, state.entityOrder);
+    const revised = await reviseFullRecipe(fullRecipe, feedback.trim(), model, outputDir, state.entityOrder, fullSchemaSpec);
     if (!revised) {
       p6.log.warn("Couldn't revise automatically. Edit recipe.json manually and re-run with --resume.");
       return false;
@@ -4447,6 +4625,7 @@ var init_full_validation = __esm({
     init_state();
     init_recipe();
     init_http_client();
+    init_discover_schema();
   }
 });