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

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, description, tags, loopValidator, loopConfig, tools: propsTools, mode, children } = props;
+  const resolvedMode = mode ?? "llm";
   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 (resolvedMode === "pure") {
+      throw new Error("Agent: pure mode 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 (resolvedMode === "pure") {
+    const firstNonTools = nonToolsChildren[0];
+    if (firstNonTools?.type === "Prompt") {
+      prompt = firstNonTools;
+      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);
@@ -109,7 +127,8 @@ function Agent(props) {
       tags,
       loopValidator,
       loopConfig,
-      tools: mergedTools
+      tools: mergedTools,
+      mode: resolvedMode
     },
     children: orderedChildren
   };
@@ -1079,13 +1098,14 @@ function compileAgent(ast) {
   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) {
+  const mode = ast.props.mode ?? "llm";
+  if (mode !== "pure" && !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;
@@ -1097,6 +1117,9 @@ function compileAgent(ast) {
     buildPrompt,
     extractOutput
   };
+  if (mode === "pure") {
+    component.mode = "pure";
+  }
   if (validateOutput) {
     component.validateOutput = validateOutput;
   }
@@ -1237,6 +1260,9 @@ 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);
@@ -2876,6 +2902,7 @@ var DEFAULT_LLM_LOOP_CONFIG = {
   // 2 minutes
   verbose: false
 };
+var DEADLINE_PROMPT = `\u26A0\uFE0F DEADLINE REACHED: You have reached the maximum allowed rounds or time limit. You MUST immediately provide your final answer based on the information gathered so far. Do NOT call any more tools. Respond with your best final output NOW.`;
 async function executeLLMLoop(adapter, initialMessages, tools, config, ctx, loopConfig = {}, validator) {
   const cfg = { ...DEFAULT_LLM_LOOP_CONFIG, ...loopConfig };
   const messagesWithMemory = await injectRelevantMemories(
@@ -2889,6 +2916,7 @@ async function executeLLMLoop(adapter, initialMessages, tools, config, ctx, loop
   let toolCallsExecuted = 0;
   let response;
   let toolCallsThisRound = [];
+  const startTime = Date.now();
   while (rounds < cfg.maxToolRounds) {
     rounds++;
     toolCallsThisRound = [];
@@ -2936,10 +2964,6 @@ async function executeLLMLoop(adapter, initialMessages, tools, config, ctx, loop
       }
       break;
     }
-    if (rounds >= cfg.maxToolRounds) {
-      errors.push(`Maximum tool rounds (${cfg.maxToolRounds}) exceeded`);
-      break;
-    }
     for (const toolCall of response.toolCalls) {
       const alreadyExecuted = toolCall._alreadyExecuted;
       if (alreadyExecuted) {
@@ -3007,6 +3031,23 @@ async function executeLLMLoop(adapter, initialMessages, tools, config, ctx, loop
     if (allPreExecuted) {
       break;
     }
+    const isTimeout = cfg.timeout > 0 && Date.now() - startTime >= cfg.timeout;
+    const isLastRound = rounds >= cfg.maxToolRounds;
+    if (isTimeout || isLastRound) {
+      messages.push({
+        role: "user",
+        content: DEADLINE_PROMPT
+      });
+      try {
+        response = await adapter.generate(messages, void 0, config, ctx);
+        messages.push({ role: "assistant", content: response.content });
+      } catch (_error) {
+      }
+      errors.push(
+        isTimeout ? `Timeout reached (${cfg.timeout}ms)` : `Maximum tool rounds (${cfg.maxToolRounds}) reached`
+      );
+      break;
+    }
   }
   return {
     response,
@@ -3246,6 +3287,17 @@ async function executeWithRetry(component, ctx, executeFn) {
     }
     const shouldRetry = retryConfig.shouldRetry ? retryConfig.shouldRetry(attempts, output, ctx) : attempts < retryConfig.maxAttempts;
     if (!shouldRetry) {
+      const lastOutput = outputHistory[outputHistory.length - 1];
+      if (lastOutput !== void 0) {
+        return {
+          output: lastOutput,
+          success: true,
+          attempts,
+          errors: validation.errors ?? ["Validation failed (used best-effort output)"],
+          validationHistory,
+          outputHistory
+        };
+      }
       return {
         success: false,
         attempts,
@@ -3330,6 +3382,13 @@ 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 = [];
@@ -4344,7 +4403,7 @@ zod.z.object({
   sessionId: zod.z.string().min(1, "Session ID cannot be empty"),
   workflowName: zod.z.string().min(1, "Workflow name cannot be empty"),
   pausedAt: zod.z.string().datetime("Must be ISO 8601 datetime"),
-  version: zod.z.string().regex(/^\d+\.\d+\.\d+$/, "Must be semver format (e.g., 4.0.0)"),
+  version: zod.z.string().regex(/^\d+\.\d+\.\d+$/, "Must be semver format (e.g., 1.0.0)"),
   state: PausedSessionStateSchema,
   metadata: PausedSessionMetadataSchema
 });
@@ -4360,7 +4419,7 @@ var SessionSerializer = class {
   metadata;
   constructor() {
     this.metadata = {
-      version: "4.0.0",
+      version: "1.0.0",
       timestamp: /* @__PURE__ */ new Date(),
       specialFields: []
     };
@@ -5030,6 +5089,9 @@ 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;
@@ -5217,6 +5279,56 @@ 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",
@@ -5252,8 +5364,10 @@ function createLoopNode(child, maxIterations) {
 
 exports.Agent = Agent;
 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;