@limo-labs/deity 0.3.0-alpha.0 → 0.3.0-alpha.1

package/dist/index.cjs

@@ -64,8 +64,8 @@ var init_compile_observe = __esm({
 
 // src/components/Agent.tsx
 function Agent(props) {
-  const { id, input, output, description, tags, loopValidator, loopConfig, tools: propsTools, mode, children } = props;
-  const resolvedMode = mode ?? "llm";
+  const { id, input, output, mode, description, tags, loopValidator, loopConfig, tools: propsTools, children } = props;
+  const isPure = mode === "pure";
   if (!id) {
     throw new Error("Agent: id is required");
   }
@@ -76,8 +76,8 @@ function Agent(props) {
     throw new Error("Agent: output schema is required");
   }
   if (!children || children.length === 0) {
-    if (resolvedMode === "pure") {
-      throw new Error("Agent: pure mode must have at least a Result child");
+    if (isPure) {
+      throw new Error("Agent: pure mode agent must have at least a Result child");
     }
     throw new Error("Agent: must have at least Prompt and Result children");
   }
@@ -85,10 +85,10 @@ function Agent(props) {
   const nonToolsChildren = children.filter((child) => child?.type !== "Tools");
   let prompt;
   let rest;
-  if (resolvedMode === "pure") {
-    const firstNonTools = nonToolsChildren[0];
-    if (firstNonTools?.type === "Prompt") {
-      prompt = firstNonTools;
+  if (isPure) {
+    const firstChild = nonToolsChildren[0];
+    if (firstChild?.type === "Prompt") {
+      prompt = firstChild;
       rest = nonToolsChildren.slice(1);
     } else {
       prompt = void 0;
@@ -123,12 +123,12 @@ function Agent(props) {
       id,
       input,
       output,
+      mode,
       description,
       tags,
       loopValidator,
       loopConfig,
-      tools: mergedTools,
-      mode: resolvedMode
+      tools: mergedTools
     },
     children: orderedChildren
   };
@@ -1093,13 +1093,13 @@ function compileAgent(ast) {
   if (!children || children.length === 0) {
     throw new Error("Agent must have children");
   }
+  const isPure = ast.props.mode === "pure";
   const promptNode = children.find((n) => n?.type === "Prompt");
   const observeNode = children.find((n) => n?.type === "Observe");
   const resultNode = children.find((n) => n?.type === "Result");
   const validateNode = children.find((n) => n?.type === "Validate");
   const retryNode = children.find((n) => n?.type === "Retry");
-  const mode = ast.props.mode ?? "llm";
-  if (mode !== "pure" && !promptNode) {
+  if (!isPure && !promptNode) {
     throw new Error("Agent must have a Prompt node");
   }
   if (!resultNode) {
@@ -1112,14 +1112,12 @@ function compileAgent(ast) {
   const retry = retryNode ? compileRetry(retryNode) : void 0;
   const component = {
     id: ast.props.id,
+    mode: ast.props.mode,
     inputSchema: ast.props.input,
     outputSchema: ast.props.output,
     buildPrompt,
     extractOutput
   };
-  if (mode === "pure") {
-    component.mode = "pure";
-  }
   if (validateOutput) {
     component.validateOutput = validateOutput;
   }
@@ -1245,6 +1243,9 @@ function createLazyAgentComponent(astNode) {
     get id() {
       return astNode.props.id;
     },
+    get mode() {
+      return astNode.props.mode;
+    },
     get inputSchema() {
       return astNode.props.input;
     },
@@ -1260,9 +1261,6 @@ function createLazyAgentComponent(astNode) {
     get loopConfig() {
       return astNode.props.loopConfig;
     },
-    get mode() {
-      return astNode.props.mode;
-    },
     // Lazy methods - compile on first call
     buildPrompt(ctx) {
       return ensureCompiled().buildPrompt(ctx);
@@ -2622,6 +2620,18 @@ var PreflightChecker = class {
    * Check agent structure
    */
   checkAgentStructure(agent, errors) {
+    const isPure = agent.props.mode === "pure";
+    if (isPure) {
+      const resultNode2 = agent.children.find((n) => n?.type === "Result");
+      if (!resultNode2) {
+        errors.push({
+          type: "invalid_structure",
+          message: "Pure mode Agent must have a Result node",
+          nodeType: "Agent"
+        });
+      }
+      return;
+    }
     const [promptNode, ...rest] = agent.children;
     if (!promptNode || promptNode.type !== "Prompt") {
       errors.push({
@@ -2721,6 +2731,13 @@ async function preflight(agent, options) {
 }
 
 // src/testing/test-utils.ts
+var EMPTY_LLM_RESULT = {
+  response: { content: "", toolCalls: void 0 },
+  messages: [],
+  rounds: 0,
+  toolCallsExecuted: 0,
+  errors: []
+};
 async function runObserve(agent, options) {
   const observeNode = agent.children.find((n) => n?.type === "Observe");
   if (!observeNode) {
@@ -3382,13 +3399,6 @@ function parseComponentOutput(content, schema) {
 }
 
 // src/engine/executor.ts
-var EMPTY_LLM_RESULT = {
-  response: { content: "" },
-  messages: [],
-  rounds: 0,
-  toolCallsExecuted: 0,
-  errors: []
-};
 async function executeComponent(component, ctx, adapter, config) {
   const startTime = Date.now();
   const llmResults = [];
@@ -3398,6 +3408,73 @@ async function executeComponent(component, ctx, adapter, config) {
     stageId: component.id,
     timestamp: /* @__PURE__ */ new Date()
   });
+  if (component.mode === "pure") {
+    try {
+      ctx.ui?.stepProgress(component.id, 50, "Executing pure agent...");
+      const syntheticLLMResult = {
+        response: { content: "", toolCalls: void 0 },
+        messages: [],
+        rounds: 0,
+        toolCallsExecuted: 0,
+        errors: []
+      };
+      let output;
+      if (component.extractOutput) {
+        const extracted = await Promise.resolve(component.extractOutput(ctx, syntheticLLMResult));
+        const validation = component.outputSchema.safeParse(extracted);
+        if (!validation.success) {
+          const errors = validation.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          throw new Error(`Output validation failed: ${errors}`);
+        }
+        output = validation.data;
+      } else {
+        throw new Error("Pure mode agent must have an extractOutput (Result) function");
+      }
+      if (component.validateOutput) {
+        const validationResult = await Promise.resolve(component.validateOutput(output, ctx));
+        if (!validationResult.valid) {
+          const errorMessages = validationResult.errors?.join("; ") ?? validationResult.feedback ?? "Validation failed";
+          throw new Error(errorMessages);
+        }
+      }
+      const duration2 = Date.now() - startTime;
+      await ctx.trace.log({
+        type: "stage_complete",
+        output,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      ctx.ui?.completeStep(
+        component.id,
+        `Completed (pure) in ${Math.round(duration2 / 1e3)}s`
+      );
+      return {
+        output,
+        success: true,
+        attempts: 1,
+        llmResults: [syntheticLLMResult],
+        retryResult: {
+          success: true,
+          output,
+          attempts: 1,
+          errors: [],
+          validationHistory: [],
+          outputHistory: [output]
+        },
+        duration: duration2
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await ctx.trace.log({
+        type: "stage_failed",
+        error: errorMessage,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      ctx.ui?.failStep(component.id, errorMessage);
+      throw new Error(
+        `Component ${component.id} (pure mode) failed: ${errorMessage}`
+      );
+    }
+  }
   const retryResult = await executeWithRetry(
     component,
     ctx,
@@ -5089,13 +5166,14 @@ async function executeStepNode(node, ctx, adapter, config) {
   if (!node.component) {
     throw new Error("Step node missing component");
   }
-  if (node.component.mode === "pure") {
-    return executePureComponent(node.component, ctx);
-  }
   if (!adapter) {
     if (node.component.model?.adapter) {
       adapter = node.component.model.adapter;
       config = node.component.model.config;
+    } else if (node.component.mode === "pure") {
+      adapter = {
+        generate: async () => ({ content: "", toolCalls: void 0 })
+      };
     } else {
       throw new Error("No LLM adapter provided");
     }
@@ -5279,56 +5357,6 @@ function createIterationContext(baseCtx, currentItem, index, totalItems, itemMod
     isLastIteration: index === totalItems - 1
   };
 }
-async function executePureComponent(component, ctx) {
-  ctx.ui?.startStep(component.id, component.id);
-  await ctx.trace.log({
-    type: "stage_start",
-    stageId: component.id,
-    timestamp: /* @__PURE__ */ new Date()
-  });
-  try {
-    if (!component.extractOutput) {
-      throw new Error(`Pure component '${component.id}' must have extractOutput defined`);
-    }
-    const output = await Promise.resolve(
-      component.extractOutput(ctx, EMPTY_LLM_RESULT)
-    );
-    const schemaResult = component.outputSchema.safeParse(output);
-    if (!schemaResult.success) {
-      const errors = schemaResult.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
-      throw new Error(`Pure component '${component.id}' output validation failed: ${errors}`);
-    }
-    const validatedOutput = schemaResult.data;
-    if (component.validateOutput) {
-      const validationResult = await Promise.resolve(
-        component.validateOutput(validatedOutput, ctx)
-      );
-      if (!validationResult.valid) {
-        const feedback = validationResult.feedback || validationResult.errors?.join("; ") || "Validation failed";
-        throw new Error(`Pure component '${component.id}' validateOutput failed: ${feedback}`);
-      }
-    }
-    if (ctx instanceof ExecutionContext) {
-      ctx.previousOutputs[component.id] = validatedOutput;
-    }
-    await ctx.trace.log({
-      type: "stage_complete",
-      output: validatedOutput,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    ctx.ui?.completeStep(component.id, "Pure execution complete");
-    return validatedOutput;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    await ctx.trace.log({
-      type: "stage_failed",
-      error: errorMessage,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    ctx.ui?.failStep(component.id, errorMessage);
-    throw error;
-  }
-}
 function createStepNode(component) {
   return {
     type: "step",