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

package/dist/index.cjs

@@ -64,7 +64,8 @@ var init_compile_observe = __esm({
 
 // src/components/Agent.tsx
 function Agent(props) {
-  const { id, input, output, description, tags, loopValidator, loopConfig, tools: propsTools, children } = props;
+  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");
   }
@@ -75,13 +76,31 @@ function Agent(props) {
     throw new Error("Agent: output schema is required");
   }
   if (!children || children.length === 0) {
+    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");
   }
   const toolsNode = children.find((child) => child?.type === "Tools");
   const nonToolsChildren = children.filter((child) => child?.type !== "Tools");
-  const [prompt, ...rest] = nonToolsChildren;
-  if (!prompt || prompt.type !== "Prompt") {
-    throw new Error("Agent: first non-Tools child must be a Prompt component");
+  let prompt;
+  let rest;
+  if (isPure) {
+    const firstChild = nonToolsChildren[0];
+    if (firstChild?.type === "Prompt") {
+      prompt = firstChild;
+      rest = nonToolsChildren.slice(1);
+    } else {
+      prompt = void 0;
+      rest = nonToolsChildren;
+    }
+  } else {
+    const [first, ...remaining] = nonToolsChildren;
+    if (!first || first.type !== "Prompt") {
+      throw new Error("Agent: first non-Tools child must be a Prompt component");
+    }
+    prompt = first;
+    rest = remaining;
   }
   const result = rest.find((child) => child?.type === "Result");
   if (!result) {
@@ -91,9 +110,8 @@ function Agent(props) {
   const validate = rest.find((child) => child?.type === "Validate");
   const retry = rest.find((child) => child?.type === "Retry");
   const mergedTools = mergeTools(propsTools, toolsNode);
-  const orderedChildren = [
-    prompt
-  ];
+  const orderedChildren = [];
+  if (prompt) orderedChildren.push(prompt);
   if (observe) orderedChildren.push(observe);
   orderedChildren.push(result);
   if (validate) orderedChildren.push(validate);
@@ -105,6 +123,7 @@ function Agent(props) {
       id,
       input,
       output,
+      mode,
       description,
       tags,
       loopValidator,
@@ -1074,24 +1093,26 @@ 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");
-  if (!promptNode) {
+  if (!isPure && !promptNode) {
     throw new Error("Agent must have a Prompt node");
   }
   if (!resultNode) {
     throw new Error("Agent must have a Result node");
   }
-  const buildPrompt = compilePrompt(promptNode);
+  const buildPrompt = promptNode ? compilePrompt(promptNode) : () => [];
   const observe = observeNode ? compileObserve(observeNode) : void 0;
   const extractOutput = compileResult(resultNode, observe);
   const validateOutput = validateNode ? compileValidate(validateNode) : void 0;
   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,
@@ -1222,6 +1243,9 @@ function createLazyAgentComponent(astNode) {
     get id() {
       return astNode.props.id;
     },
+    get mode() {
+      return astNode.props.mode;
+    },
     get inputSchema() {
       return astNode.props.input;
     },
@@ -2596,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({
@@ -2695,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) {
@@ -3365,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,
@@ -5060,6 +5170,10 @@ async function executeStepNode(node, ctx, adapter, config) {
     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");
     }
@@ -5281,6 +5395,7 @@ exports.Conditional = Conditional;
 exports.DEADLINE_PROMPT = DEADLINE_PROMPT;
 exports.DEBUG_ENABLED = DEBUG_ENABLED;
 exports.DebugLogger = DebugLogger;
+exports.EMPTY_LLM_RESULT = EMPTY_LLM_RESULT;
 exports.ForEach = ForEach;
 exports.InMemoryStore = InMemoryStore;
 exports.InMemoryTrace = InMemoryTrace;