llmist 2.6.0 → 3.1.0

package/dist/cli.cjs

@@ -317,7 +317,7 @@ Example fixes:
     );
   }
 }
-function findUnknownTypes(schema, path5 = []) {
+function findUnknownTypes(schema, path6 = []) {
   const issues = [];
   if (!schema || typeof schema !== "object") {
     return issues;
@@ -329,7 +329,7 @@ function findUnknownTypes(schema, path5 = []) {
   }
   if (schema.properties) {
     for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      const propPath = [...path5, propName];
+      const propPath = [...path6, propName];
       if (hasNoType(propSchema)) {
         issues.push(propPath.join(".") || propName);
       }
@@ -337,7 +337,7 @@ function findUnknownTypes(schema, path5 = []) {
     }
   }
   if (schema.items) {
-    const itemPath = [...path5, "[]"];
+    const itemPath = [...path6, "[]"];
     if (hasNoType(schema.items)) {
       issues.push(itemPath.join("."));
     }
@@ -345,17 +345,17 @@ function findUnknownTypes(schema, path5 = []) {
   }
   if (schema.anyOf) {
     schema.anyOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path5, `anyOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path6, `anyOf[${index}]`]));
     });
   }
   if (schema.oneOf) {
     schema.oneOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path5, `oneOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path6, `oneOf[${index}]`]));
     });
   }
   if (schema.allOf) {
     schema.allOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path5, `allOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path6, `allOf[${index}]`]));
     });
   }
   return issues;
@@ -530,13 +530,13 @@ var init_prompt_config = __esm({
 });
 
 // src/core/messages.ts
-function normalizeContent(content) {
+function normalizeMessageContent(content) {
   if (typeof content === "string") {
     return [{ type: "text", text: content }];
   }
   return content;
 }
-function extractText(content) {
+function extractMessageText(content) {
   if (typeof content === "string") {
     return content;
   }
@@ -896,7 +896,17 @@ Produces: { "items": ["first", "second"] }`);
         this.messages.push({ role: "user", content: parts });
         return this;
       }
-      addGadgetCall(gadget, parameters, result, media, mediaIds) {
+      /**
+       * Record a gadget execution result in the message history.
+       * Creates an assistant message with the gadget invocation and a user message with the result.
+       *
+       * @param gadget - Name of the gadget that was executed
+       * @param parameters - Parameters that were passed to the gadget
+       * @param result - Text result from the gadget execution
+       * @param media - Optional media outputs from the gadget
+       * @param mediaIds - Optional IDs for the media outputs
+       */
+      addGadgetCallResult(gadget, parameters, result, media, mediaIds) {
         const paramStr = this.formatBlockParameters(parameters, "");
         this.messages.push({
           role: "assistant",
@@ -1164,21 +1174,21 @@ var init_media_store = __esm({
 });
 
 // src/gadgets/exceptions.ts
-var BreakLoopException, HumanInputException, TimeoutException, AbortError;
+var TaskCompletionSignal, HumanInputRequiredException, TimeoutException, AbortException;
 var init_exceptions = __esm({
   "src/gadgets/exceptions.ts"() {
     "use strict";
-    BreakLoopException = class extends Error {
+    TaskCompletionSignal = class extends Error {
       constructor(message) {
         super(message ?? "Agent loop terminated by gadget");
-        this.name = "BreakLoopException";
+        this.name = "TaskCompletionSignal";
       }
     };
-    HumanInputException = class extends Error {
+    HumanInputRequiredException = class extends Error {
       question;
       constructor(question) {
         super(`Human input required: ${question}`);
-        this.name = "HumanInputException";
+        this.name = "HumanInputRequiredException";
         this.question = question;
       }
     };
@@ -1192,10 +1202,10 @@ var init_exceptions = __esm({
         this.timeoutMs = timeoutMs;
       }
     };
-    AbortError = class extends Error {
+    AbortException = class extends Error {
       constructor(message) {
         super(message || "Gadget execution was aborted");
-        this.name = "AbortError";
+        this.name = "AbortException";
       }
     };
   }
@@ -1294,29 +1304,29 @@ function schemaToJSONSchema(schema, options) {
 }
 function detectDescriptionMismatch(schema, jsonSchema) {
   const mismatches = [];
-  function checkSchema(zodSchema, json, path5) {
+  function checkSchema(zodSchema, json, path6) {
     if (!zodSchema || typeof zodSchema !== "object") return;
     const def = zodSchema._def;
     const jsonObj = json;
     if (def?.description && !jsonObj?.description) {
-      mismatches.push(path5 || "root");
+      mismatches.push(path6 || "root");
     }
     if (def?.typeName === "ZodObject" && def?.shape) {
       const shape = typeof def.shape === "function" ? def.shape() : def.shape;
       for (const [key, fieldSchema] of Object.entries(shape)) {
         const properties = jsonObj?.properties;
         const jsonProp = properties?.[key];
-        checkSchema(fieldSchema, jsonProp, path5 ? `${path5}.${key}` : key);
+        checkSchema(fieldSchema, jsonProp, path6 ? `${path6}.${key}` : key);
       }
     }
     if (def?.typeName === "ZodArray" && def?.type) {
-      checkSchema(def.type, jsonObj?.items, path5 ? `${path5}[]` : "[]");
+      checkSchema(def.type, jsonObj?.items, path6 ? `${path6}[]` : "[]");
     }
     if ((def?.typeName === "ZodOptional" || def?.typeName === "ZodNullable") && def?.innerType) {
-      checkSchema(def.innerType, json, path5);
+      checkSchema(def.innerType, json, path6);
     }
     if (def?.typeName === "ZodDefault" && def?.innerType) {
-      checkSchema(def.innerType, json, path5);
+      checkSchema(def.innerType, json, path6);
     }
   }
   checkSchema(schema, jsonSchema, "");
@@ -1364,7 +1374,7 @@ var init_schema_to_json = __esm({
 });
 
 // src/gadgets/gadget.ts
-function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
+function formatParamsForBlockExample(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
   const lines = [];
   for (const [key, value] of Object.entries(params)) {
     const fullPath = prefix ? `${prefix}/${key}` : key;
@@ -1372,14 +1382,14 @@ function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX)
       value.forEach((item, index) => {
         const itemPath = `${fullPath}/${index}`;
         if (typeof item === "object" && item !== null) {
-          lines.push(formatParamsAsBlock(item, itemPath, argPrefix));
+          lines.push(formatParamsForBlockExample(item, itemPath, argPrefix));
         } else {
           lines.push(`${argPrefix}${itemPath}`);
           lines.push(String(item));
         }
       });
     } else if (typeof value === "object" && value !== null) {
-      lines.push(formatParamsAsBlock(value, fullPath, argPrefix));
+      lines.push(formatParamsForBlockExample(value, fullPath, argPrefix));
     } else {
       lines.push(`${argPrefix}${fullPath}`);
       lines.push(String(value));
@@ -1468,7 +1478,7 @@ function formatSchemaAsPlainText(schema, indent = "", atRoot = true) {
   }
   return lines.join("\n");
 }
-var BaseGadget;
+var AbstractGadget;
 var init_gadget = __esm({
   "src/gadgets/gadget.ts"() {
     "use strict";
@@ -1476,7 +1486,7 @@ var init_gadget = __esm({
     init_exceptions();
     init_schema_to_json();
     init_schema_validator();
-    BaseGadget = class {
+    AbstractGadget = class {
       /**
        * The name of the gadget. Used for identification when LLM calls it.
        * If not provided, defaults to the class name.
@@ -1504,14 +1514,14 @@ var init_gadget = __esm({
        */
       examples;
       /**
-       * Throws an AbortError if the execution has been aborted.
+       * Throws an AbortException if the execution has been aborted.
        *
        * Call this at key checkpoints in long-running gadgets to allow early exit
        * when the gadget has been cancelled (e.g., due to timeout). This enables
        * resource cleanup and prevents unnecessary work after cancellation.
        *
        * @param ctx - The execution context containing the abort signal
-       * @throws AbortError if ctx.signal.aborted is true
+       * @throws AbortException if ctx.signal.aborted is true
        *
        * @example
        * ```typescript
@@ -1536,7 +1546,7 @@ var init_gadget = __esm({
        */
       throwIfAborted(ctx) {
         if (ctx?.signal?.aborted) {
-          throw new AbortError();
+          throw new AbortException();
         }
       }
       /**
@@ -1678,7 +1688,7 @@ var init_gadget = __esm({
             }
             parts.push(`${effectiveStartPrefix}${gadgetName}`);
             parts.push(
-              formatParamsAsBlock(example.params, "", effectiveArgPrefix)
+              formatParamsForBlockExample(example.params, "", effectiveArgPrefix)
             );
             parts.push(effectiveEndPrefix);
             if (example.output !== void 0) {
@@ -1696,7 +1706,7 @@ var init_gadget = __esm({
 
 // src/gadgets/create-gadget.ts
 function createGadget(config) {
-  class DynamicGadget extends BaseGadget {
+  class DynamicGadget extends AbstractGadget {
     name = config.name;
     description = config.description;
     parameterSchema = config.schema;
@@ -2334,8 +2344,8 @@ var init_conversation_manager = __esm({
       addAssistantMessage(content) {
         this.historyBuilder.addAssistant(content);
       }
-      addGadgetCall(gadgetName, parameters, result, media, mediaIds) {
-        this.historyBuilder.addGadgetCall(gadgetName, parameters, result, media, mediaIds);
+      addGadgetCallResult(gadgetName, parameters, result, media, mediaIds) {
+        this.historyBuilder.addGadgetCallResult(gadgetName, parameters, result, media, mediaIds);
       }
       getMessages() {
         return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
@@ -2355,7 +2365,7 @@ var init_conversation_manager = __esm({
           if (msg.role === "user") {
             this.historyBuilder.addUser(msg.content);
           } else if (msg.role === "assistant") {
-            this.historyBuilder.addAssistant(extractText(msg.content));
+            this.historyBuilder.addAssistant(extractMessageText(msg.content));
           }
         }
       }
@@ -3205,12 +3215,12 @@ var init_cost_reporting_client = __esm({
 });
 
 // src/gadgets/error-formatter.ts
-var GadgetErrorFormatter;
+var GadgetExecutionErrorFormatter;
 var init_error_formatter = __esm({
   "src/gadgets/error-formatter.ts"() {
     "use strict";
     init_constants();
-    GadgetErrorFormatter = class {
+    GadgetExecutionErrorFormatter = class {
       argPrefix;
       startPrefix;
       endPrefix;
@@ -3231,8 +3241,8 @@ var init_error_formatter = __esm({
         const parts = [];
         parts.push(`Error: Invalid parameters for '${gadgetName}':`);
         for (const issue of zodError.issues) {
-          const path5 = issue.path.join(".") || "root";
-          parts.push(`  - ${path5}: ${issue.message}`);
+          const path6 = issue.path.join(".") || "root";
+          parts.push(`  - ${path6}: ${issue.message}`);
         }
         parts.push("");
         parts.push("Gadget Usage:");
@@ -3296,16 +3306,16 @@ function stripMarkdownFences(content) {
   cleaned = cleaned.replace(closingFence, "");
   return cleaned.trim();
 }
-var globalInvocationCounter, StreamParser;
+var globalInvocationCounter, GadgetCallParser;
 var init_parser = __esm({
   "src/gadgets/parser.ts"() {
     "use strict";
     init_constants();
     init_block_params();
     globalInvocationCounter = 0;
-    StreamParser = class {
+    GadgetCallParser = class {
       buffer = "";
-      lastReportedTextLength = 0;
+      lastEmittedTextOffset = 0;
       startPrefix;
       endPrefix;
       argPrefix;
@@ -3314,16 +3324,20 @@ var init_parser = __esm({
         this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
         this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
       }
-      takeTextUntil(index) {
-        if (index <= this.lastReportedTextLength) {
+      /**
+       * Extract and consume text up to the given index.
+       * Returns undefined if no meaningful text to emit.
+       */
+      extractTextSegment(index) {
+        if (index <= this.lastEmittedTextOffset) {
           return void 0;
         }
-        const segment = this.buffer.slice(this.lastReportedTextLength, index);
-        this.lastReportedTextLength = index;
+        const segment = this.buffer.slice(this.lastEmittedTextOffset, index);
+        this.lastEmittedTextOffset = index;
         return segment.trim().length > 0 ? segment : void 0;
       }
       /**
-       * Parse gadget name with optional invocation ID and dependencies.
+       * Parse gadget invocation metadata from the header line.
        *
        * Supported formats:
        * - `GadgetName` - Auto-generate ID, no dependencies
@@ -3332,24 +3346,24 @@ var init_parser = __esm({
        *
        * Dependencies must be comma-separated invocation IDs.
        */
-      parseGadgetName(gadgetName) {
-        const parts = gadgetName.split(":");
+      parseInvocationMetadata(headerLine) {
+        const parts = headerLine.split(":");
         if (parts.length === 1) {
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: `gadget_${++globalInvocationCounter}`,
             dependencies: []
           };
         } else if (parts.length === 2) {
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: parts[1].trim(),
             dependencies: []
           };
         } else {
           const deps = parts[2].split(",").map((d) => d.trim()).filter((d) => d.length > 0);
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: parts[1].trim(),
             dependencies: deps
           };
@@ -3381,19 +3395,15 @@ var init_parser = __esm({
         while (true) {
           const partStartIndex = this.buffer.indexOf(this.startPrefix, startIndex);
           if (partStartIndex === -1) break;
-          const textBefore = this.takeTextUntil(partStartIndex);
+          const textBefore = this.extractTextSegment(partStartIndex);
           if (textBefore !== void 0) {
             yield { type: "text", content: textBefore };
           }
           const metadataStartIndex = partStartIndex + this.startPrefix.length;
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex === -1) break;
-          const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-          const {
-            actualName: actualGadgetName,
-            invocationId,
-            dependencies
-          } = this.parseGadgetName(gadgetName);
+          const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
+          const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
           const contentStartIndex = metadataEndIndex + 1;
           let partEndIndex;
           let endMarkerLength = 0;
@@ -3413,7 +3423,7 @@ var init_parser = __esm({
           yield {
             type: "gadget_call",
             call: {
-              gadgetName: actualGadgetName,
+              gadgetName,
               invocationId,
               parametersRaw,
               parameters,
@@ -3422,37 +3432,33 @@ var init_parser = __esm({
             }
           };
           startIndex = partEndIndex + endMarkerLength;
-          this.lastReportedTextLength = startIndex;
+          this.lastEmittedTextOffset = startIndex;
         }
         if (startIndex > 0) {
           this.buffer = this.buffer.substring(startIndex);
-          this.lastReportedTextLength = 0;
+          this.lastEmittedTextOffset = 0;
         }
       }
       // Finalize parsing and return remaining text or incomplete gadgets
       *finalize() {
-        const startIndex = this.buffer.indexOf(this.startPrefix, this.lastReportedTextLength);
+        const startIndex = this.buffer.indexOf(this.startPrefix, this.lastEmittedTextOffset);
         if (startIndex !== -1) {
-          const textBefore = this.takeTextUntil(startIndex);
+          const textBefore = this.extractTextSegment(startIndex);
           if (textBefore !== void 0) {
             yield { type: "text", content: textBefore };
           }
           const metadataStartIndex = startIndex + this.startPrefix.length;
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex !== -1) {
-            const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-            const {
-              actualName: actualGadgetName,
-              invocationId,
-              dependencies
-            } = this.parseGadgetName(gadgetName);
+            const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
+            const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
             const contentStartIndex = metadataEndIndex + 1;
             const parametersRaw = this.buffer.substring(contentStartIndex).trim();
             const { parameters, parseError } = this.parseParameters(parametersRaw);
             yield {
               type: "gadget_call",
               call: {
-                gadgetName: actualGadgetName,
+                gadgetName,
                 invocationId,
                 parametersRaw,
                 parameters,
@@ -3463,7 +3469,7 @@ var init_parser = __esm({
             return;
           }
         }
-        const remainingText = this.takeTextUntil(this.buffer.length);
+        const remainingText = this.extractTextSegment(this.buffer.length);
         if (remainingText !== void 0) {
           yield { type: "text", content: remainingText };
         }
@@ -3471,7 +3477,7 @@ var init_parser = __esm({
       // Reset parser state (note: global invocation counter is NOT reset to ensure unique IDs)
       reset() {
         this.buffer = "";
-        this.lastReportedTextLength = 0;
+        this.lastEmittedTextOffset = 0;
       }
     };
   }
@@ -3490,14 +3496,17 @@ var init_executor = __esm({
     init_exceptions();
     init_parser();
     GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore) {
+      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig, onNestedEvent) {
         this.registry = registry;
-        this.onHumanInputRequired = onHumanInputRequired;
+        this.requestHumanInput = requestHumanInput;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
         this.client = client;
         this.mediaStore = mediaStore;
+        this.agentConfig = agentConfig;
+        this.subagentConfig = subagentConfig;
+        this.onNestedEvent = onNestedEvent;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
-        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
+        this.errorFormatter = new GadgetExecutionErrorFormatter(errorFormatterOptions);
         this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
       }
       logger;
@@ -3517,11 +3526,11 @@ var init_executor = __esm({
         });
       }
       /**
-       * Normalizes gadget execute result to consistent format.
+       * Unify gadget execute result to consistent internal format.
        * Handles string returns (backwards compat), object returns with cost,
        * and object returns with media.
        */
-      normalizeExecuteResult(raw) {
+      unifyExecuteResult(raw) {
         if (typeof raw === "string") {
           return { result: raw, cost: 0 };
         }
@@ -3639,7 +3648,11 @@ var init_executor = __esm({
           const ctx = {
             reportCost,
             llmist: this.client ? new CostReportingLLMistWrapper(this.client, reportCost) : void 0,
-            signal: abortController.signal
+            signal: abortController.signal,
+            agentConfig: this.agentConfig,
+            subagentConfig: this.subagentConfig,
+            invocationId: call.invocationId,
+            onNestedEvent: this.onNestedEvent
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -3654,7 +3667,7 @@ var init_executor = __esm({
           } else {
             rawResult = await Promise.resolve(gadget.execute(validatedParameters, ctx));
           }
-          const { result, media, cost: returnCost } = this.normalizeExecuteResult(rawResult);
+          const { result, media, cost: returnCost } = this.unifyExecuteResult(rawResult);
           const totalCost = callbackCost + returnCost;
           let mediaIds;
           let storedMedia;
@@ -3700,7 +3713,7 @@ var init_executor = __esm({
             storedMedia
           };
         } catch (error) {
-          if (error instanceof BreakLoopException) {
+          if (error instanceof TaskCompletionSignal) {
             this.logger.info("Gadget requested loop termination", {
               gadgetName: call.gadgetName,
               message: error.message
@@ -3728,7 +3741,7 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
-          if (error instanceof AbortError) {
+          if (error instanceof AbortException) {
             this.logger.info("Gadget execution was aborted", {
               gadgetName: call.gadgetName,
               executionTimeMs: Date.now() - startTime
@@ -3741,14 +3754,14 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
-          if (error instanceof HumanInputException) {
+          if (error instanceof HumanInputRequiredException) {
             this.logger.info("Gadget requested human input", {
               gadgetName: call.gadgetName,
               question: error.question
             });
-            if (this.onHumanInputRequired) {
+            if (this.requestHumanInput) {
               try {
-                const answer = await this.onHumanInputRequired(error.question);
+                const answer = await this.requestHumanInput(error.question);
                 this.logger.debug("Human input received", {
                   gadgetName: call.gadgetName,
                   answerLength: answer.length
@@ -3846,13 +3859,13 @@ var init_stream_processor = __esm({
       parser;
       executor;
       stopOnGadgetError;
-      shouldContinueAfterError;
-      accumulatedText = "";
-      shouldStopExecution = false;
+      canRecoverFromGadgetError;
+      responseText = "";
+      executionHalted = false;
       observerFailureCount = 0;
       // Dependency tracking for gadget execution DAG
       /** Gadgets waiting for their dependencies to complete */
-      pendingGadgets = /* @__PURE__ */ new Map();
+      gadgetsAwaitingDependencies = /* @__PURE__ */ new Map();
       /** Completed gadget results, keyed by invocation ID */
       completedResults = /* @__PURE__ */ new Map();
       /** Invocation IDs of gadgets that have failed (error or skipped due to dependency) */
@@ -3863,27 +3876,36 @@ var init_stream_processor = __esm({
         this.hooks = options.hooks ?? {};
         this.logger = options.logger ?? createLogger({ name: "llmist:stream-processor" });
         this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.shouldContinueAfterError = options.shouldContinueAfterError;
-        this.parser = new StreamParser({
+        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
+        this.parser = new GadgetCallParser({
           startPrefix: options.gadgetStartPrefix,
           endPrefix: options.gadgetEndPrefix,
           argPrefix: options.gadgetArgPrefix
         });
         this.executor = new GadgetExecutor(
           options.registry,
-          options.onHumanInputRequired,
+          options.requestHumanInput,
           this.logger.getSubLogger({ name: "executor" }),
           options.defaultGadgetTimeoutMs,
           { argPrefix: options.gadgetArgPrefix },
           options.client,
-          options.mediaStore
+          options.mediaStore,
+          options.agentConfig,
+          options.subagentConfig,
+          options.onNestedEvent
         );
       }
       /**
-       * Process an LLM stream and return structured results.
+       * Process an LLM stream and yield events in real-time.
+       *
+       * This is an async generator that yields events immediately as they occur:
+       * - Text events are yielded as text is streamed from the LLM
+       * - gadget_call events are yielded immediately when a gadget call is parsed
+       * - gadget_result events are yielded when gadget execution completes
+       *
+       * The final event is always a StreamCompletionEvent containing metadata.
        */
-      async process(stream2) {
-        const outputs = [];
+      async *process(stream2) {
         let finishReason = null;
         let usage;
         let didExecuteGadgets = false;
@@ -3897,7 +3919,7 @@ var init_stream_processor = __esm({
             if (this.hooks.interceptors?.interceptRawChunk) {
               const context = {
                 iteration: this.iteration,
-                accumulatedText: this.accumulatedText,
+                accumulatedText: this.responseText,
                 logger: this.logger
               };
               const intercepted = this.hooks.interceptors.interceptRawChunk(processedChunk, context);
@@ -3908,7 +3930,7 @@ var init_stream_processor = __esm({
               }
             }
             if (processedChunk) {
-              this.accumulatedText += processedChunk;
+              this.responseText += processedChunk;
             }
           }
           if (this.hooks.observers?.onStreamChunk && (processedChunk || chunk.usage)) {
@@ -3917,7 +3939,7 @@ var init_stream_processor = __esm({
               const context = {
                 iteration: this.iteration,
                 rawChunk: processedChunk,
-                accumulatedText: this.accumulatedText,
+                accumulatedText: this.responseText,
                 usage,
                 logger: this.logger
               };
@@ -3929,67 +3951,66 @@ var init_stream_processor = __esm({
             continue;
           }
           for (const event of this.parser.feed(processedChunk)) {
-            const processedEvents = await this.processEvent(event);
-            outputs.push(...processedEvents);
-            if (processedEvents.some((e) => e.type === "gadget_result")) {
-              didExecuteGadgets = true;
-            }
-            for (const evt of processedEvents) {
-              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-                shouldBreakLoop = true;
+            for await (const processedEvent of this.processEventGenerator(event)) {
+              yield processedEvent;
+              if (processedEvent.type === "gadget_result") {
+                didExecuteGadgets = true;
+                if (processedEvent.result.breaksLoop) {
+                  shouldBreakLoop = true;
+                }
               }
             }
           }
-          if (this.shouldStopExecution) {
+          if (this.executionHalted) {
             this.logger.info("Breaking from LLM stream due to gadget error");
             break;
           }
         }
-        if (!this.shouldStopExecution) {
+        if (!this.executionHalted) {
           for (const event of this.parser.finalize()) {
-            const processedEvents = await this.processEvent(event);
-            outputs.push(...processedEvents);
-            if (processedEvents.some((e) => e.type === "gadget_result")) {
-              didExecuteGadgets = true;
-            }
-            for (const evt of processedEvents) {
-              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-                shouldBreakLoop = true;
+            for await (const processedEvent of this.processEventGenerator(event)) {
+              yield processedEvent;
+              if (processedEvent.type === "gadget_result") {
+                didExecuteGadgets = true;
+                if (processedEvent.result.breaksLoop) {
+                  shouldBreakLoop = true;
+                }
               }
             }
           }
-          const finalPendingEvents = await this.processPendingGadgets();
-          outputs.push(...finalPendingEvents);
-          if (finalPendingEvents.some((e) => e.type === "gadget_result")) {
-            didExecuteGadgets = true;
-          }
-          for (const evt of finalPendingEvents) {
-            if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-              shouldBreakLoop = true;
+          for await (const evt of this.processPendingGadgetsGenerator()) {
+            yield evt;
+            if (evt.type === "gadget_result") {
+              didExecuteGadgets = true;
+              if (evt.result.breaksLoop) {
+                shouldBreakLoop = true;
+              }
             }
           }
         }
-        let finalMessage = this.accumulatedText;
+        let finalMessage = this.responseText;
         if (this.hooks.interceptors?.interceptAssistantMessage) {
           const context = {
             iteration: this.iteration,
-            rawResponse: this.accumulatedText,
+            rawResponse: this.responseText,
             logger: this.logger
           };
           finalMessage = this.hooks.interceptors.interceptAssistantMessage(finalMessage, context);
         }
-        return {
-          outputs,
+        const completionEvent = {
+          type: "stream_complete",
           shouldBreakLoop,
           didExecuteGadgets,
           finishReason,
           usage,
-          rawResponse: this.accumulatedText,
+          rawResponse: this.responseText,
           finalMessage
         };
+        yield completionEvent;
       }
       /**
        * Process a single parsed event (text or gadget call).
+       * @deprecated Use processEventGenerator for real-time streaming
        */
       async processEvent(event) {
         if (event.type === "text") {
@@ -3999,6 +4020,23 @@ var init_stream_processor = __esm({
         }
         return [event];
       }
+      /**
+       * Process a single parsed event, yielding events in real-time.
+       * Generator version of processEvent for streaming support.
+       */
+      async *processEventGenerator(event) {
+        if (event.type === "text") {
+          for (const e of await this.processTextEvent(event)) {
+            yield e;
+          }
+        } else if (event.type === "gadget_call") {
+          for await (const e of this.processGadgetCallGenerator(event.call)) {
+            yield e;
+          }
+        } else {
+          yield event;
+        }
+      }
       /**
        * Process a text event through interceptors.
        */
@@ -4007,7 +4045,7 @@ var init_stream_processor = __esm({
         if (this.hooks.interceptors?.interceptTextChunk) {
           const context = {
             iteration: this.iteration,
-            accumulatedText: this.accumulatedText,
+            accumulatedText: this.responseText,
             logger: this.logger
           };
           const intercepted = this.hooks.interceptors.interceptTextChunk(content, context);
@@ -4026,7 +4064,7 @@ var init_stream_processor = __esm({
        * After each execution, pending gadgets are checked to see if they can now run.
        */
       async processGadgetCall(call) {
-        if (this.shouldStopExecution) {
+        if (this.executionHalted) {
           this.logger.debug("Skipping gadget execution due to previous error", {
             gadgetName: call.gadgetName
           });
@@ -4065,7 +4103,7 @@ var init_stream_processor = __esm({
               invocationId: call.invocationId,
               waitingOn: unsatisfied
             });
-            this.pendingGadgets.set(call.invocationId, call);
+            this.gadgetsAwaitingDependencies.set(call.invocationId, call);
             return events;
           }
         }
@@ -4075,9 +4113,68 @@ var init_stream_processor = __esm({
         events.push(...triggeredEvents);
         return events;
       }
+      /**
+       * Process a gadget call, yielding events in real-time.
+       *
+       * Key difference from processGadgetCall: yields gadget_call event IMMEDIATELY
+       * when parsed (before execution), enabling real-time UI feedback.
+       */
+      async *processGadgetCallGenerator(call) {
+        if (this.executionHalted) {
+          this.logger.debug("Skipping gadget execution due to previous error", {
+            gadgetName: call.gadgetName
+          });
+          return;
+        }
+        yield { type: "gadget_call", call };
+        if (call.dependencies.length > 0) {
+          if (call.dependencies.includes(call.invocationId)) {
+            this.logger.warn("Gadget has self-referential dependency (depends on itself)", {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId
+            });
+            this.failedInvocations.add(call.invocationId);
+            const skipEvent = {
+              type: "gadget_skipped",
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: call.invocationId,
+              failedDependencyError: `Gadget "${call.invocationId}" cannot depend on itself (self-referential dependency)`
+            };
+            yield skipEvent;
+            return;
+          }
+          const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+          if (failedDep) {
+            const skipEvents = await this.handleFailedDependency(call, failedDep);
+            for (const evt of skipEvents) {
+              yield evt;
+            }
+            return;
+          }
+          const unsatisfied = call.dependencies.filter((dep) => !this.completedResults.has(dep));
+          if (unsatisfied.length > 0) {
+            this.logger.debug("Queueing gadget for later - waiting on dependencies", {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              waitingOn: unsatisfied
+            });
+            this.gadgetsAwaitingDependencies.set(call.invocationId, call);
+            return;
+          }
+        }
+        for await (const evt of this.executeGadgetGenerator(call)) {
+          yield evt;
+        }
+        for await (const evt of this.processPendingGadgetsGenerator()) {
+          yield evt;
+        }
+      }
       /**
        * Execute a gadget through the full hook lifecycle.
        * This is the core execution logic, extracted from processGadgetCall.
+       * @deprecated Use executeGadgetGenerator for real-time streaming
        */
       async executeGadgetWithHooks(call) {
         const events = [];
@@ -4087,14 +4184,14 @@ var init_stream_processor = __esm({
             error: call.parseError,
             rawParameters: call.parametersRaw
           });
-          const shouldContinue = await this.checkContinueAfterError(
+          const shouldContinue = await this.checkCanRecoverFromError(
             call.parseError,
             call.gadgetName,
             "parse",
             call.parameters
           );
           if (!shouldContinue) {
-            this.shouldStopExecution = true;
+            this.executionHalted = true;
           }
         }
         let parameters = call.parameters ?? {};
@@ -4218,18 +4315,171 @@ var init_stream_processor = __esm({
         events.push({ type: "gadget_result", result });
         if (result.error) {
           const errorType = this.determineErrorType(call, result);
-          const shouldContinue = await this.checkContinueAfterError(
+          const shouldContinue = await this.checkCanRecoverFromError(
             result.error,
             result.gadgetName,
             errorType,
             result.parameters
           );
           if (!shouldContinue) {
-            this.shouldStopExecution = true;
+            this.executionHalted = true;
           }
         }
         return events;
       }
+      /**
+       * Execute a gadget and yield the result event.
+       * Generator version that yields gadget_result immediately when execution completes.
+       */
+      async *executeGadgetGenerator(call) {
+        if (call.parseError) {
+          this.logger.warn("Gadget has parse error", {
+            gadgetName: call.gadgetName,
+            error: call.parseError,
+            rawParameters: call.parametersRaw
+          });
+          const shouldContinue = await this.checkCanRecoverFromError(
+            call.parseError,
+            call.gadgetName,
+            "parse",
+            call.parameters
+          );
+          if (!shouldContinue) {
+            this.executionHalted = true;
+          }
+        }
+        let parameters = call.parameters ?? {};
+        if (this.hooks.interceptors?.interceptGadgetParameters) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            logger: this.logger
+          };
+          parameters = this.hooks.interceptors.interceptGadgetParameters(parameters, context);
+        }
+        call.parameters = parameters;
+        let shouldSkip = false;
+        let syntheticResult;
+        if (this.hooks.controllers?.beforeGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.beforeGadgetExecution(context);
+          validateBeforeGadgetExecutionAction(action);
+          if (action.action === "skip") {
+            shouldSkip = true;
+            syntheticResult = action.syntheticResult;
+            this.logger.info("Controller skipped gadget execution", {
+              gadgetName: call.gadgetName
+            });
+          }
+        }
+        const startObservers = [];
+        if (this.hooks.observers?.onGadgetExecutionStart) {
+          startObservers.push(async () => {
+            const context = {
+              iteration: this.iteration,
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters,
+              logger: this.logger
+            };
+            await this.hooks.observers.onGadgetExecutionStart(context);
+          });
+        }
+        await this.runObserversInParallel(startObservers);
+        let result;
+        if (shouldSkip) {
+          result = {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            result: syntheticResult ?? "Execution skipped",
+            executionTimeMs: 0
+          };
+        } else {
+          result = await this.executor.execute(call);
+        }
+        const originalResult = result.result;
+        if (result.result && this.hooks.interceptors?.interceptGadgetResult) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          result.result = this.hooks.interceptors.interceptGadgetResult(result.result, context);
+        }
+        if (this.hooks.controllers?.afterGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            result: result.result,
+            error: result.error,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.afterGadgetExecution(context);
+          validateAfterGadgetExecutionAction(action);
+          if (action.action === "recover" && result.error) {
+            this.logger.info("Controller recovered from gadget error", {
+              gadgetName: result.gadgetName,
+              originalError: result.error
+            });
+            result = {
+              ...result,
+              error: void 0,
+              result: action.fallbackResult
+            };
+          }
+        }
+        const completeObservers = [];
+        if (this.hooks.observers?.onGadgetExecutionComplete) {
+          completeObservers.push(async () => {
+            const context = {
+              iteration: this.iteration,
+              gadgetName: result.gadgetName,
+              invocationId: result.invocationId,
+              parameters,
+              originalResult,
+              finalResult: result.result,
+              error: result.error,
+              executionTimeMs: result.executionTimeMs,
+              breaksLoop: result.breaksLoop,
+              cost: result.cost,
+              logger: this.logger
+            };
+            await this.hooks.observers.onGadgetExecutionComplete(context);
+          });
+        }
+        await this.runObserversInParallel(completeObservers);
+        this.completedResults.set(result.invocationId, result);
+        if (result.error) {
+          this.failedInvocations.add(result.invocationId);
+        }
+        yield { type: "gadget_result", result };
+        if (result.error) {
+          const errorType = this.determineErrorType(call, result);
+          const shouldContinue = await this.checkCanRecoverFromError(
+            result.error,
+            result.gadgetName,
+            errorType,
+            result.parameters
+          );
+          if (!shouldContinue) {
+            this.executionHalted = true;
+          }
+        }
+      }
       /**
        * Handle a gadget that cannot execute because a dependency failed.
        * Calls the onDependencySkipped controller to allow customization.
@@ -4312,11 +4562,11 @@ var init_stream_processor = __esm({
       async processPendingGadgets() {
         const events = [];
         let progress = true;
-        while (progress && this.pendingGadgets.size > 0) {
+        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
           progress = false;
           const readyToExecute = [];
           const readyToSkip = [];
-          for (const [invocationId, call] of this.pendingGadgets) {
+          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
             const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
             if (failedDep) {
               readyToSkip.push({ call, failedDep });
@@ -4328,7 +4578,7 @@ var init_stream_processor = __esm({
             }
           }
           for (const { call, failedDep } of readyToSkip) {
-            this.pendingGadgets.delete(call.invocationId);
+            this.gadgetsAwaitingDependencies.delete(call.invocationId);
             const skipEvents = await this.handleFailedDependency(call, failedDep);
             events.push(...skipEvents);
             progress = true;
@@ -4339,7 +4589,7 @@ var init_stream_processor = __esm({
               invocationIds: readyToExecute.map((c) => c.invocationId)
             });
             for (const call of readyToExecute) {
-              this.pendingGadgets.delete(call.invocationId);
+              this.gadgetsAwaitingDependencies.delete(call.invocationId);
             }
             const executePromises = readyToExecute.map((call) => this.executeGadgetWithHooks(call));
             const results = await Promise.all(executePromises);
@@ -4349,9 +4599,9 @@ var init_stream_processor = __esm({
             progress = true;
           }
         }
-        if (this.pendingGadgets.size > 0) {
-          const pendingIds = new Set(this.pendingGadgets.keys());
-          for (const [invocationId, call] of this.pendingGadgets) {
+        if (this.gadgetsAwaitingDependencies.size > 0) {
+          const pendingIds = new Set(this.gadgetsAwaitingDependencies.keys());
+          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
             const missingDeps = call.dependencies.filter((dep) => !this.completedResults.has(dep));
             const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
             const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
@@ -4382,10 +4632,103 @@ var init_stream_processor = __esm({
             };
             events.push(skipEvent);
           }
-          this.pendingGadgets.clear();
+          this.gadgetsAwaitingDependencies.clear();
         }
         return events;
       }
+      /**
+       * Process pending gadgets, yielding events in real-time.
+       * Generator version that yields events as gadgets complete.
+       *
+       * Note: Gadgets are still executed in parallel for efficiency,
+       * but results are yielded as they become available.
+       */
+      async *processPendingGadgetsGenerator() {
+        let progress = true;
+        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
+          progress = false;
+          const readyToExecute = [];
+          const readyToSkip = [];
+          for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
+            const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+            if (failedDep) {
+              readyToSkip.push({ call, failedDep });
+              continue;
+            }
+            const allSatisfied = call.dependencies.every((dep) => this.completedResults.has(dep));
+            if (allSatisfied) {
+              readyToExecute.push(call);
+            }
+          }
+          for (const { call, failedDep } of readyToSkip) {
+            this.gadgetsAwaitingDependencies.delete(call.invocationId);
+            const skipEvents = await this.handleFailedDependency(call, failedDep);
+            for (const evt of skipEvents) {
+              yield evt;
+            }
+            progress = true;
+          }
+          if (readyToExecute.length > 0) {
+            this.logger.debug("Executing ready gadgets in parallel", {
+              count: readyToExecute.length,
+              invocationIds: readyToExecute.map((c) => c.invocationId)
+            });
+            for (const call of readyToExecute) {
+              this.gadgetsAwaitingDependencies.delete(call.invocationId);
+            }
+            const eventSets = await Promise.all(
+              readyToExecute.map(async (call) => {
+                const events = [];
+                for await (const evt of this.executeGadgetGenerator(call)) {
+                  events.push(evt);
+                }
+                return events;
+              })
+            );
+            for (const events of eventSets) {
+              for (const evt of events) {
+                yield evt;
+              }
+            }
+            progress = true;
+          }
+        }
+        if (this.gadgetsAwaitingDependencies.size > 0) {
+          const pendingIds = new Set(this.gadgetsAwaitingDependencies.keys());
+          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
+            const missingDeps = call.dependencies.filter((dep) => !this.completedResults.has(dep));
+            const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
+            const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
+            let errorMessage;
+            let logLevel = "warn";
+            if (circularDeps.length > 0 && trulyMissingDeps.length > 0) {
+              errorMessage = `Dependencies unresolvable: circular=[${circularDeps.join(", ")}], missing=[${trulyMissingDeps.join(", ")}]`;
+              logLevel = "error";
+            } else if (circularDeps.length > 0) {
+              errorMessage = `Circular dependency detected: "${invocationId}" depends on "${circularDeps[0]}" which also depends on "${invocationId}" (directly or indirectly)`;
+            } else {
+              errorMessage = `Dependency "${missingDeps[0]}" was never executed - check that the invocation ID exists and is spelled correctly`;
+            }
+            this.logger[logLevel]("Gadget has unresolvable dependencies", {
+              gadgetName: call.gadgetName,
+              invocationId,
+              circularDependencies: circularDeps,
+              missingDependencies: trulyMissingDeps
+            });
+            this.failedInvocations.add(invocationId);
+            const skipEvent = {
+              type: "gadget_skipped",
+              gadgetName: call.gadgetName,
+              invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: missingDeps[0],
+              failedDependencyError: errorMessage
+            };
+            yield skipEvent;
+          }
+          this.gadgetsAwaitingDependencies.clear();
+        }
+      }
       /**
        * Safely execute an observer, catching and logging any errors.
        * Observers are non-critical, so errors are logged but don't crash the system.
@@ -4412,19 +4755,19 @@ var init_stream_processor = __esm({
         );
       }
       /**
-       * Check if execution should continue after an error.
+       * Check if execution can recover from an error.
        *
        * Returns true if we should continue processing subsequent gadgets, false if we should stop.
        *
        * Logic:
-       * - If custom shouldContinueAfterError is provided, use it
+       * - If custom canRecoverFromGadgetError is provided, use it
        * - Otherwise, use stopOnGadgetError config:
        *   - stopOnGadgetError=true → return false (stop execution)
        *   - stopOnGadgetError=false → return true (continue execution)
        */
-      async checkContinueAfterError(error, gadgetName, errorType, parameters) {
-        if (this.shouldContinueAfterError) {
-          return await this.shouldContinueAfterError({
+      async checkCanRecoverFromError(error, gadgetName, errorType, parameters) {
+        if (this.canRecoverFromGadgetError) {
+          return await this.canRecoverFromGadgetError({
             error,
             gadgetName,
             errorType,
@@ -4487,14 +4830,14 @@ var init_agent = __esm({
       gadgetStartPrefix;
       gadgetEndPrefix;
       gadgetArgPrefix;
-      onHumanInputRequired;
+      requestHumanInput;
       textOnlyHandler;
       textWithGadgetsHandler;
       stopOnGadgetError;
-      shouldContinueAfterError;
+      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       defaultMaxTokens;
-      userPromptProvided;
+      hasUserPrompt;
       // Gadget output limiting
       outputStore;
       outputLimitEnabled;
@@ -4505,6 +4848,11 @@ var init_agent = __esm({
       mediaStore;
       // Cancellation
       signal;
+      // Subagent configuration
+      agentContextConfig;
+      subagentConfig;
+      // Nested event callback for subagent gadgets
+      onNestedEvent;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -4524,11 +4872,11 @@ var init_agent = __esm({
         this.gadgetStartPrefix = options.gadgetStartPrefix;
         this.gadgetEndPrefix = options.gadgetEndPrefix;
         this.gadgetArgPrefix = options.gadgetArgPrefix;
-        this.onHumanInputRequired = options.onHumanInputRequired;
+        this.requestHumanInput = options.requestHumanInput;
         this.textOnlyHandler = options.textOnlyHandler ?? "terminate";
         this.textWithGadgetsHandler = options.textWithGadgetsHandler;
         this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.shouldContinueAfterError = options.shouldContinueAfterError;
+        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
         this.defaultGadgetTimeoutMs = options.defaultGadgetTimeoutMs;
         this.defaultMaxTokens = this.resolveMaxTokensFromCatalog(options.model);
         this.outputLimitEnabled = options.gadgetOutputLimit ?? DEFAULT_GADGET_OUTPUT_LIMIT;
@@ -4544,7 +4892,7 @@ var init_agent = __esm({
             createGadgetOutputViewer(this.outputStore, this.outputLimitCharLimit)
           );
         }
-        this.hooks = this.mergeOutputLimiterHook(options.hooks);
+        this.hooks = this.chainOutputLimiterWithUserHooks(options.hooks);
         const baseBuilder = new LLMMessageBuilder(options.promptConfig);
         if (options.systemPrompt) {
           baseBuilder.addSystem(options.systemPrompt);
@@ -4564,7 +4912,7 @@ var init_agent = __esm({
           endPrefix: options.gadgetEndPrefix,
           argPrefix: options.gadgetArgPrefix
         });
-        this.userPromptProvided = !!options.userPrompt;
+        this.hasUserPrompt = !!options.userPrompt;
         if (options.userPrompt) {
           this.conversation.addUserMessage(options.userPrompt);
         }
@@ -4577,6 +4925,12 @@ var init_agent = __esm({
           );
         }
         this.signal = options.signal;
+        this.agentContextConfig = {
+          model: this.model,
+          temperature: this.temperature
+        };
+        this.subagentConfig = options.subagentConfig;
+        this.onNestedEvent = options.onNestedEvent;
       }
       /**
        * Get the gadget registry for this agent.
@@ -4683,7 +5037,7 @@ var init_agent = __esm({
        * @throws {Error} If no user prompt was provided (when using build() without ask())
        */
       async *run() {
-        if (!this.userPromptProvided) {
+        if (!this.hasUserPrompt) {
           throw new Error(
             "No user prompt provided. Use .ask(prompt) instead of .build(), or call agent.run() after providing a prompt."
           );
@@ -4800,17 +5154,37 @@ var init_agent = __esm({
               gadgetArgPrefix: this.gadgetArgPrefix,
               hooks: this.hooks,
               logger: this.logger.getSubLogger({ name: "stream-processor" }),
-              onHumanInputRequired: this.onHumanInputRequired,
+              requestHumanInput: this.requestHumanInput,
               stopOnGadgetError: this.stopOnGadgetError,
-              shouldContinueAfterError: this.shouldContinueAfterError,
+              canRecoverFromGadgetError: this.canRecoverFromGadgetError,
               defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
               client: this.client,
-              mediaStore: this.mediaStore
+              mediaStore: this.mediaStore,
+              agentConfig: this.agentContextConfig,
+              subagentConfig: this.subagentConfig,
+              onNestedEvent: this.onNestedEvent
             });
-            const result = await processor.process(stream2);
-            for (const output of result.outputs) {
-              yield output;
+            let streamMetadata = null;
+            let gadgetCallCount = 0;
+            const textOutputs = [];
+            const gadgetResults = [];
+            for await (const event of processor.process(stream2)) {
+              if (event.type === "stream_complete") {
+                streamMetadata = event;
+                continue;
+              }
+              if (event.type === "text") {
+                textOutputs.push(event.content);
+              } else if (event.type === "gadget_result") {
+                gadgetCallCount++;
+                gadgetResults.push(event);
+              }
+              yield event;
             }
+            if (!streamMetadata) {
+              throw new Error("Stream processing completed without metadata event");
+            }
+            const result = streamMetadata;
             this.logger.info("LLM response completed", {
               finishReason: result.finishReason,
               usage: result.usage,
@@ -4835,9 +5209,6 @@ var init_agent = __esm({
             });
             let finalMessage = result.finalMessage;
             if (this.hooks.controllers?.afterLLMCall) {
-              const gadgetCallCount = result.outputs.filter(
-                (output) => output.type === "gadget_result"
-              ).length;
               const context = {
                 iteration: currentIteration,
                 maxIterations: this.maxIterations,
@@ -4858,31 +5229,29 @@ var init_agent = __esm({
                   if (msg.role === "user") {
                     this.conversation.addUserMessage(msg.content);
                   } else if (msg.role === "assistant") {
-                    this.conversation.addAssistantMessage(extractText(msg.content));
+                    this.conversation.addAssistantMessage(extractMessageText(msg.content));
                   } else if (msg.role === "system") {
-                    this.conversation.addUserMessage(`[System] ${extractText(msg.content)}`);
+                    this.conversation.addUserMessage(`[System] ${extractMessageText(msg.content)}`);
                   }
                 }
               }
             }
             if (result.didExecuteGadgets) {
               if (this.textWithGadgetsHandler) {
-                const textContent = result.outputs.filter(
-                  (output) => output.type === "text"
-                ).map((output) => output.content).join("");
+                const textContent = textOutputs.join("");
                 if (textContent.trim()) {
                   const { gadgetName, parameterMapping, resultMapping } = this.textWithGadgetsHandler;
-                  this.conversation.addGadgetCall(
+                  this.conversation.addGadgetCallResult(
                     gadgetName,
                     parameterMapping(textContent),
                     resultMapping ? resultMapping(textContent) : textContent
                   );
                 }
               }
-              for (const output of result.outputs) {
+              for (const output of gadgetResults) {
                 if (output.type === "gadget_result") {
                   const gadgetResult = output.result;
-                  this.conversation.addGadgetCall(
+                  this.conversation.addGadgetCallResult(
                     gadgetResult.gadgetName,
                     gadgetResult.parameters,
                     gadgetResult.error ?? gadgetResult.result ?? "",
@@ -4893,7 +5262,7 @@ var init_agent = __esm({
               }
             } else {
               if (finalMessage.trim()) {
-                this.conversation.addGadgetCall(
+                this.conversation.addGadgetCallResult(
                   "TellUser",
                   { message: finalMessage, done: false, type: "info" },
                   `\u2139\uFE0F  ${finalMessage}`
@@ -5019,10 +5388,10 @@ var init_agent = __esm({
         return this.client.modelRegistry.getModelLimits(unprefixedModelId)?.maxOutputTokens;
       }
       /**
-       * Merge the output limiter interceptor into user-provided hooks.
+       * Chain the output limiter interceptor with user-provided hooks.
        * The limiter runs first, then chains to any user interceptor.
        */
-      mergeOutputLimiterHook(userHooks) {
+      chainOutputLimiterWithUserHooks(userHooks) {
         if (!this.outputLimitEnabled) {
           return userHooks ?? {};
         }
@@ -5376,9 +5745,9 @@ var init_base_provider = __esm({
        */
       async *stream(options, descriptor, spec) {
         const preparedMessages = this.prepareMessages(options.messages);
-        const payload = this.buildRequestPayload(options, descriptor, spec, preparedMessages);
+        const payload = this.buildApiRequest(options, descriptor, spec, preparedMessages);
         const rawStream = await this.executeStreamRequest(payload, options.signal);
-        yield* this.wrapStream(rawStream);
+        yield* this.normalizeProviderStream(rawStream);
       }
       /**
        * Prepare messages for the request.
@@ -5478,11 +5847,11 @@ var init_anthropic = __esm({
           "Anthropic does not support speech generation. Use OpenAI (TTS) or Google Gemini (TTS) instead."
         );
       }
-      buildRequestPayload(options, descriptor, spec, messages) {
+      buildApiRequest(options, descriptor, spec, messages) {
         const systemMessages = messages.filter((message) => message.role === "system");
         const system = systemMessages.length > 0 ? systemMessages.map((m, index) => ({
           type: "text",
-          text: extractText(m.content),
+          text: extractMessageText(m.content),
           // Add cache_control to the LAST system message block
           ...index === systemMessages.length - 1 ? { cache_control: { type: "ephemeral" } } : {}
         })) : void 0;
@@ -5519,7 +5888,7 @@ var init_anthropic = __esm({
        * Handles text, images (base64 only), and applies cache_control.
        */
       convertToAnthropicContent(content, addCacheControl) {
-        const parts = normalizeContent(content);
+        const parts = normalizeMessageContent(content);
         return parts.map((part, index) => {
           const isLastPart = index === parts.length - 1;
           const cacheControl = addCacheControl && isLastPart ? { cache_control: { type: "ephemeral" } } : {};
@@ -5565,7 +5934,7 @@ var init_anthropic = __esm({
         const stream2 = await client.messages.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         let inputTokens = 0;
         let cachedInputTokens = 0;
@@ -5642,7 +6011,7 @@ var init_anthropic = __esm({
       async countTokens(messages, descriptor, _spec) {
         const client = this.client;
         const systemMessages = messages.filter((message) => message.role === "system");
-        const system = systemMessages.length > 0 ? systemMessages.map((m) => extractText(m.content)).join("\n\n") : void 0;
+        const system = systemMessages.length > 0 ? systemMessages.map((m) => extractMessageText(m.content)).join("\n\n") : void 0;
         const conversation = messages.filter(
           (message) => message.role !== "system"
         ).map((message) => ({
@@ -5664,7 +6033,7 @@ var init_anthropic = __esm({
           let totalChars = 0;
           let imageCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -6355,7 +6724,7 @@ var init_gemini = __esm({
           format: spec?.defaultFormat ?? "wav"
         };
       }
-      buildRequestPayload(options, descriptor, _spec, messages) {
+      buildApiRequest(options, descriptor, _spec, messages) {
         const contents = this.convertMessagesToContents(messages);
         const generationConfig = this.buildGenerationConfig(options);
         const config = {
@@ -6407,7 +6776,7 @@ var init_gemini = __esm({
           if (message.role === "system") {
             expandedMessages.push({
               role: "user",
-              content: extractText(message.content)
+              content: extractMessageText(message.content)
             });
             expandedMessages.push({
               role: "assistant",
@@ -6457,7 +6826,7 @@ var init_gemini = __esm({
        * Handles text, images, and audio (Gemini supports all three).
        */
       convertToGeminiParts(content) {
-        const parts = normalizeContent(content);
+        const parts = normalizeMessageContent(content);
         return parts.map((part) => {
           if (part.type === "text") {
             return { text: part.text };
@@ -6502,10 +6871,10 @@ var init_gemini = __esm({
         }
         return Object.keys(config).length > 0 ? config : null;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         for await (const chunk of stream2) {
-          const text3 = this.extractText(chunk);
+          const text3 = this.extractMessageText(chunk);
           if (text3) {
             yield { text: text3, rawEvent: chunk };
           }
@@ -6516,7 +6885,7 @@ var init_gemini = __esm({
           }
         }
       }
-      extractText(chunk) {
+      extractMessageText(chunk) {
         if (!chunk?.candidates) {
           return "";
         }
@@ -6581,7 +6950,7 @@ var init_gemini = __esm({
           let totalChars = 0;
           let mediaCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -7327,7 +7696,7 @@ var init_openai = __esm({
           format
         };
       }
-      buildRequestPayload(options, descriptor, spec, messages) {
+      buildApiRequest(options, descriptor, spec, messages) {
         const { maxTokens, temperature, topP, stopSequences, extra } = options;
         const supportsTemperature = spec?.metadata?.supportsTemperature !== false;
         const shouldIncludeTemperature = typeof temperature === "number" && supportsTemperature;
@@ -7362,7 +7731,7 @@ var init_openai = __esm({
             ...message.name ? { name: message.name } : {}
           };
         }
-        const textContent = typeof message.content === "string" ? message.content : extractText(message.content);
+        const textContent = typeof message.content === "string" ? message.content : extractMessageText(message.content);
         if (role === "system") {
           return {
             role: "system",
@@ -7422,7 +7791,7 @@ var init_openai = __esm({
         const stream2 = await client.chat.completions.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         for await (const chunk of stream2) {
           const text3 = chunk.choices.map((choice) => choice.delta?.content ?? "").join("");
@@ -7480,9 +7849,9 @@ var init_openai = __esm({
               tokenCount += OPENAI_MESSAGE_OVERHEAD_TOKENS;
               const roleText = ROLE_MAP[message.role];
               tokenCount += encoding.encode(roleText).length;
-              const textContent = extractText(message.content);
+              const textContent = extractMessageText(message.content);
               tokenCount += encoding.encode(textContent).length;
-              const parts = normalizeContent(message.content);
+              const parts = normalizeMessageContent(message.content);
               for (const part of parts) {
                 if (part.type === "image") {
                   imageCount++;
@@ -7507,7 +7876,7 @@ var init_openai = __esm({
           let totalChars = 0;
           let imageCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -8372,20 +8741,23 @@ var init_builder = __esm({
       promptConfig;
       gadgets = [];
       initialMessages = [];
-      onHumanInputRequired;
+      requestHumanInput;
       gadgetStartPrefix;
       gadgetEndPrefix;
       gadgetArgPrefix;
       textOnlyHandler;
       textWithGadgetsHandler;
       stopOnGadgetError;
-      shouldContinueAfterError;
+      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
       compactionConfig;
       signal;
       trailingMessage;
+      subagentConfig;
+      nestedEventCallback;
+      parentContext;
       constructor(client) {
         this.client = client;
       }
@@ -8476,13 +8848,13 @@ var init_builder = __esm({
        *
        * @example
        * ```typescript
-       * .withPromptConfig({
+       * .withPromptTemplateConfig({
        *   mainInstruction: "Use the gadget markers below:",
        *   rules: ["Always use markers", "Never use function calling"]
        * })
        * ```
        */
-      withPromptConfig(config) {
+      withPromptTemplateConfig(config) {
         this.promptConfig = config;
         return this;
       }
@@ -8562,7 +8934,7 @@ var init_builder = __esm({
        * ```
        */
       onHumanInput(handler) {
-        this.onHumanInputRequired = handler;
+        this.requestHumanInput = handler;
         return this;
       }
       /**
@@ -8697,9 +9069,9 @@ var init_builder = __esm({
        * Provides fine-grained control over whether to continue after different types of errors.
        * Overrides `stopOnGadgetError` when provided.
        *
-       * **Note:** This builder method configures the underlying `shouldContinueAfterError` option
+       * **Note:** This builder method configures the underlying `canRecoverFromGadgetError` option
        * in `AgentOptions`. The method is named `withErrorHandler` for better developer experience,
-       * but maps to the `shouldContinueAfterError` property internally.
+       * but maps to the `canRecoverFromGadgetError` property internally.
        *
        * @param handler - Function that decides whether to continue after an error.
        *                  Return `true` to continue execution, `false` to stop.
@@ -8720,7 +9092,7 @@ var init_builder = __esm({
        * ```
        */
       withErrorHandler(handler) {
-        this.shouldContinueAfterError = handler;
+        this.canRecoverFromGadgetError = handler;
         return this;
       }
       /**
@@ -8857,8 +9229,97 @@ var init_builder = __esm({
        * document.getElementById("cancel").onclick = () => controller.abort();
        * ```
        */
-      withSignal(signal) {
-        this.signal = signal;
+      withSignal(signal) {
+        this.signal = signal;
+        return this;
+      }
+      /**
+       * Set subagent configuration overrides.
+       *
+       * Subagent gadgets (like BrowseWeb) can read these settings from ExecutionContext
+       * to inherit model and other options from the CLI configuration.
+       *
+       * @param config - Subagent configuration map keyed by gadget name
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withSubagentConfig({
+       *   BrowseWeb: { model: "inherit", maxIterations: 20, headless: true },
+       *   CodeAnalyzer: { model: "sonnet", maxIterations: 10 }
+       * })
+       * ```
+       */
+      withSubagentConfig(config) {
+        this.subagentConfig = config;
+        return this;
+      }
+      /**
+       * Set the callback for nested subagent events.
+       *
+       * Subagent gadgets (like BrowseWeb) can use ExecutionContext.onNestedEvent
+       * to report their internal LLM calls and gadget executions in real-time.
+       * This callback receives those events, enabling hierarchical progress display.
+       *
+       * @param callback - Function to handle nested agent events
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withNestedEventCallback((event) => {
+       *   if (event.type === "llm_call_start") {
+       *     console.log(`  Nested LLM #${event.event.iteration} starting...`);
+       *   } else if (event.type === "gadget_call") {
+       *     console.log(`    ⏵ ${event.event.call.gadgetName}...`);
+       *   }
+       * })
+       * ```
+       */
+      withNestedEventCallback(callback) {
+        this.nestedEventCallback = callback;
+        return this;
+      }
+      /**
+       * Enable automatic nested event forwarding to parent agent.
+       *
+       * When building a subagent inside a gadget, call this method to automatically
+       * forward all LLM calls and gadget events to the parent agent. This enables
+       * hierarchical progress display without any manual event handling.
+       *
+       * The method extracts `invocationId` and `onNestedEvent` from the execution
+       * context and sets up automatic forwarding via hooks and event wrapping.
+       *
+       * @param ctx - ExecutionContext passed to the gadget's execute() method
+       * @param depth - Nesting depth (default: 1 for direct child)
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // In a subagent gadget like BrowseWeb - ONE LINE enables auto-forwarding:
+       * execute: async (params, ctx) => {
+       *   const agent = new AgentBuilder(client)
+       *     .withModel(model)
+       *     .withGadgets(Navigate, Click, Screenshot)
+       *     .withParentContext(ctx)  // <-- This is all you need!
+       *     .ask(params.task);
+       *
+       *   for await (const event of agent.run()) {
+       *     // Events automatically forwarded - just process normally
+       *     if (event.type === "text") {
+       *       result = event.content;
+       *     }
+       *   }
+       * }
+       * ```
+       */
+      withParentContext(ctx, depth = 1) {
+        if (ctx.onNestedEvent && ctx.invocationId) {
+          this.parentContext = {
+            invocationId: ctx.invocationId,
+            onNestedEvent: ctx.onNestedEvent,
+            depth
+          };
+        }
         return this;
       }
       /**
@@ -8928,14 +9389,58 @@ ${endPrefix}`
         return this;
       }
       /**
-       * Compose the final hooks, including trailing message if configured.
+       * Compose the final hooks, including:
+       * - Trailing message injection (if configured)
+       * - Nested event forwarding for LLM calls (if parentContext is set)
        */
       composeHooks() {
+        let hooks = this.hooks;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent, depth } = this.parentContext;
+          const existingOnLLMCallStart = hooks?.observers?.onLLMCallStart;
+          const existingOnLLMCallComplete = hooks?.observers?.onLLMCallComplete;
+          hooks = {
+            ...hooks,
+            observers: {
+              ...hooks?.observers,
+              onLLMCallStart: async (context) => {
+                onNestedEvent({
+                  type: "llm_call_start",
+                  gadgetInvocationId: invocationId,
+                  depth,
+                  event: {
+                    iteration: context.iteration,
+                    model: context.options.model
+                  }
+                });
+                if (existingOnLLMCallStart) {
+                  await existingOnLLMCallStart(context);
+                }
+              },
+              onLLMCallComplete: async (context) => {
+                onNestedEvent({
+                  type: "llm_call_end",
+                  gadgetInvocationId: invocationId,
+                  depth,
+                  event: {
+                    iteration: context.iteration,
+                    model: context.options.model,
+                    outputTokens: context.usage?.outputTokens,
+                    finishReason: context.finishReason
+                  }
+                });
+                if (existingOnLLMCallComplete) {
+                  await existingOnLLMCallComplete(context);
+                }
+              }
+            }
+          };
+        }
         if (!this.trailingMessage) {
-          return this.hooks;
+          return hooks;
         }
         const trailingMsg = this.trailingMessage;
-        const existingBeforeLLMCall = this.hooks?.controllers?.beforeLLMCall;
+        const existingBeforeLLMCall = hooks?.controllers?.beforeLLMCall;
         const trailingMessageController = async (ctx) => {
           const result = existingBeforeLLMCall ? await existingBeforeLLMCall(ctx) : { action: "proceed" };
           if (result.action === "skip") {
@@ -8950,9 +9455,9 @@ ${endPrefix}`
           };
         };
         return {
-          ...this.hooks,
+          ...hooks,
           controllers: {
-            ...this.hooks?.controllers,
+            ...hooks?.controllers,
             beforeLLMCall: trailingMessageController
           }
         };
@@ -9013,6 +9518,19 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
+        let onNestedEvent = this.nestedEventCallback;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent: parentCallback, depth } = this.parentContext;
+          const existingCallback = this.nestedEventCallback;
+          onNestedEvent = (event) => {
+            parentCallback({
+              ...event,
+              gadgetInvocationId: invocationId,
+              depth: event.depth + depth
+            });
+            existingCallback?.(event);
+          };
+        }
         return {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -9025,19 +9543,21 @@ ${endPrefix}`
           hooks: this.composeHooks(),
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
-          onHumanInputRequired: this.onHumanInputRequired,
+          requestHumanInput: this.requestHumanInput,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
-          shouldContinueAfterError: this.shouldContinueAfterError,
+          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
-          signal: this.signal
+          signal: this.signal,
+          subagentConfig: this.subagentConfig,
+          onNestedEvent
         };
       }
       ask(userPrompt) {
@@ -9194,6 +9714,19 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
+        let onNestedEvent = this.nestedEventCallback;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent: parentCallback, depth } = this.parentContext;
+          const existingCallback = this.nestedEventCallback;
+          onNestedEvent = (event) => {
+            parentCallback({
+              ...event,
+              gadgetInvocationId: invocationId,
+              depth: event.depth + depth
+            });
+            existingCallback?.(event);
+          };
+        }
         const options = {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -9206,19 +9739,21 @@ ${endPrefix}`
           hooks: this.composeHooks(),
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
-          onHumanInputRequired: this.onHumanInputRequired,
+          requestHumanInput: this.requestHumanInput,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
-          shouldContinueAfterError: this.shouldContinueAfterError,
+          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
-          signal: this.signal
+          signal: this.signal,
+          subagentConfig: this.subagentConfig,
+          onNestedEvent
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -9236,7 +9771,8 @@ var COMMANDS = {
   gadget: "gadget",
   image: "image",
   speech: "speech",
-  vision: "vision"
+  vision: "vision",
+  init: "init"
 };
 var LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var DEFAULT_MODEL = "openai:gpt-5-nano";
@@ -9312,7 +9848,7 @@ var import_commander2 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "2.6.0",
+  version: "3.0.0",
   description: "TypeScript LLM client with streaming tool execution. Tools fire mid-stream. Built-in function calling works with any model\u2014no structured outputs or native tool support required.",
   type: "module",
   main: "dist/index.cjs",
@@ -9720,7 +10256,7 @@ var askUser = createGadget({
     }
   ],
   execute: ({ question }) => {
-    throw new HumanInputException(question);
+    throw new HumanInputRequiredException(question);
   }
 });
 var tellUser = createGadget({
@@ -9770,11 +10306,59 @@ var finish = createGadget({
     }
   ],
   execute: () => {
-    throw new BreakLoopException("Task completed");
+    throw new TaskCompletionSignal("Task completed");
   }
 });
 var builtinGadgets = [askUser, tellUser, finish];
 
+// src/cli/subagent-config.ts
+var INHERIT_MODEL = "inherit";
+function resolveSubagentConfig(subagentName, parentModel, profileConfig, globalConfig) {
+  const resolved = {};
+  const globalDefaultModel = globalConfig?.["default-model"];
+  const globalSubagent = extractSubagentConfig(globalConfig, subagentName);
+  const profileSubagent = profileConfig?.[subagentName] ?? {};
+  const merged = { ...globalSubagent, ...profileSubagent };
+  const configModel = merged.model ?? globalDefaultModel ?? INHERIT_MODEL;
+  resolved.model = configModel === INHERIT_MODEL ? parentModel : configModel;
+  for (const [key, value] of Object.entries(merged)) {
+    if (key !== "model") {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+function buildSubagentConfigMap(parentModel, profileConfig, globalConfig) {
+  const subagentNames = /* @__PURE__ */ new Set();
+  if (globalConfig) {
+    for (const key of Object.keys(globalConfig)) {
+      if (key !== "default-model" && typeof globalConfig[key] === "object") {
+        subagentNames.add(key);
+      }
+    }
+  }
+  if (profileConfig) {
+    for (const key of Object.keys(profileConfig)) {
+      subagentNames.add(key);
+    }
+  }
+  const result = {};
+  for (const name of subagentNames) {
+    result[name] = resolveSubagentConfig(name, parentModel, profileConfig, globalConfig);
+  }
+  return result;
+}
+function extractSubagentConfig(globalConfig, subagentName) {
+  if (!globalConfig) {
+    return {};
+  }
+  const value = globalConfig[subagentName];
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  return {};
+}
+
 // src/cli/config.ts
 var import_node_fs3 = require("fs");
 var import_node_os2 = require("os");
@@ -9863,7 +10447,7 @@ function hasTemplateSyntax(str) {
 }
 
 // src/cli/config.ts
-var VALID_APPROVAL_MODES = ["allowed", "denied", "approval-required"];
+var VALID_PERMISSION_LEVELS = ["allowed", "denied", "approval-required"];
 var GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["log-level", "log-file", "log-reset"]);
 var VALID_LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -9903,6 +10487,8 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "gadget-end-prefix",
   "gadget-arg-prefix",
   "gadget-approval",
+  "subagents",
+  // Per-subagent configuration overrides
   "quiet",
   "inherits",
   "log-level",
@@ -9928,9 +10514,9 @@ function getConfigPath() {
   return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".llmist", "cli.toml");
 }
 var ConfigError = class extends Error {
-  constructor(message, path5) {
-    super(path5 ? `${path5}: ${message}` : message);
-    this.path = path5;
+  constructor(message, path6) {
+    super(path6 ? `${path6}: ${message}` : message);
+    this.path = path6;
     this.name = "ConfigError";
   }
 };
@@ -9986,6 +10572,63 @@ function validateInherits(value, section) {
   }
   throw new ConfigError(`[${section}].inherits must be a string or array of strings`);
 }
+function validateSingleSubagentConfig(value, subagentName, section) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(
+      `[${section}].${subagentName} must be a table (e.g., { model = "inherit", maxIterations = 20 })`
+    );
+  }
+  const result = {};
+  const rawObj = value;
+  for (const [key, val] of Object.entries(rawObj)) {
+    if (key === "model") {
+      if (typeof val !== "string") {
+        throw new ConfigError(`[${section}].${subagentName}.model must be a string`);
+      }
+      result.model = val;
+    } else if (key === "maxIterations") {
+      if (typeof val !== "number" || !Number.isInteger(val) || val < 1) {
+        throw new ConfigError(
+          `[${section}].${subagentName}.maxIterations must be a positive integer`
+        );
+      }
+      result.maxIterations = val;
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function validateSubagentConfigMap(value, section) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(
+      `[${section}].subagents must be a table (e.g., { BrowseWeb = { model = "inherit" } })`
+    );
+  }
+  const result = {};
+  for (const [subagentName, config] of Object.entries(value)) {
+    result[subagentName] = validateSingleSubagentConfig(config, subagentName, `${section}.subagents`);
+  }
+  return result;
+}
+function validateGlobalSubagentConfig(value, section) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const result = {};
+  const rawObj = value;
+  for (const [key, val] of Object.entries(rawObj)) {
+    if (key === "default-model") {
+      if (typeof val !== "string") {
+        throw new ConfigError(`[${section}].default-model must be a string`);
+      }
+      result["default-model"] = val;
+    } else {
+      result[key] = validateSingleSubagentConfig(val, key, section);
+    }
+  }
+  return result;
+}
 function validateGadgetApproval(value, section) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new ConfigError(
@@ -9997,9 +10640,9 @@ function validateGadgetApproval(value, section) {
     if (typeof mode !== "string") {
       throw new ConfigError(`[${section}].gadget-approval.${gadgetName} must be a string`);
     }
-    if (!VALID_APPROVAL_MODES.includes(mode)) {
+    if (!VALID_PERMISSION_LEVELS.includes(mode)) {
       throw new ConfigError(
-        `[${section}].gadget-approval.${gadgetName} must be one of: ${VALID_APPROVAL_MODES.join(", ")}`
+        `[${section}].gadget-approval.${gadgetName} must be one of: ${VALID_PERMISSION_LEVELS.join(", ")}`
       );
     }
     result[gadgetName] = mode;
@@ -10168,6 +10811,9 @@ function validateAgentConfig(raw, section) {
   if ("gadget-approval" in rawObj) {
     result["gadget-approval"] = validateGadgetApproval(rawObj["gadget-approval"], section);
   }
+  if ("subagents" in rawObj) {
+    result.subagents = validateSubagentConfigMap(rawObj.subagents, section);
+  }
   if ("quiet" in rawObj) {
     result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
@@ -10336,6 +10982,9 @@ function validateCustomConfig(raw, section) {
   if ("gadget-approval" in rawObj) {
     result["gadget-approval"] = validateGadgetApproval(rawObj["gadget-approval"], section);
   }
+  if ("subagents" in rawObj) {
+    result.subagents = validateSubagentConfigMap(rawObj.subagents, section);
+  }
   if ("max-tokens" in rawObj) {
     result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
       integer: true,
@@ -10383,6 +11032,8 @@ function validateConfig(raw, configPath) {
         result.prompts = validatePromptsConfig(value, key);
       } else if (key === "docker") {
         result.docker = validateDockerConfig(value, key);
+      } else if (key === "subagents") {
+        result.subagents = validateGlobalSubagentConfig(value, key);
       } else {
         result[key] = validateCustomConfig(value, key);
       }
@@ -10423,7 +11074,16 @@ function loadConfig() {
   return resolveTemplatesInConfig(inherited, configPath);
 }
 function getCustomCommandNames(config) {
-  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent", "image", "speech", "prompts", "docker"]);
+  const reserved = /* @__PURE__ */ new Set([
+    "global",
+    "complete",
+    "agent",
+    "image",
+    "speech",
+    "prompts",
+    "docker",
+    "subagents"
+  ]);
   return Object.keys(config).filter((key) => !reserved.has(key));
 }
 function resolveTemplatesInConfig(config, configPath) {
@@ -10957,11 +11617,11 @@ function resolveDevMode(config, cliDevMode) {
   }
   return { enabled: true, sourcePath };
 }
-function expandHome(path5) {
-  if (path5.startsWith("~")) {
-    return path5.replace(/^~/, (0, import_node_os4.homedir)());
+function expandHome(path6) {
+  if (path6.startsWith("~")) {
+    return path6.replace(/^~/, (0, import_node_os4.homedir)());
   }
-  return path5;
+  return path6;
 }
 function buildDockerRunArgs(ctx, imageName, devMode) {
   const args = ["run", "--rm"];
@@ -11138,9 +11798,9 @@ async function readFileBuffer(filePath, options = {}) {
 }
 
 // src/cli/gadgets.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
 init_gadget();
 
 // src/cli/builtins/filesystem/edit-file.ts
@@ -11665,6 +12325,208 @@ function isBuiltinGadgetName(name) {
   return name in builtinGadgetRegistry;
 }
 
+// src/cli/external-gadgets.ts
+var import_node_child_process = require("child_process");
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_url = require("url");
+var CACHE_DIR2 = import_node_path11.default.join(import_node_os5.default.homedir(), ".llmist", "gadget-cache");
+function isExternalPackageSpecifier(specifier) {
+  if (/^@?[a-z0-9][\w.-]*(?:@[\w.-]+)?(?::[a-z]+)?(?:\/\w+)?$/i.test(specifier)) {
+    return true;
+  }
+  if (specifier.startsWith("git+")) {
+    return true;
+  }
+  return false;
+}
+function parseGadgetSpecifier(specifier) {
+  if (specifier.startsWith("git+")) {
+    const url = specifier.slice(4);
+    const [baseUrl, ref] = url.split("#");
+    return {
+      type: "git",
+      package: baseUrl,
+      version: ref
+    };
+  }
+  const npmMatch = specifier.match(
+    /^(@?[a-z0-9][\w.-]*)(?:@([\w.-]+))?(?::([a-z]+))?(?:\/(\w+))?$/i
+  );
+  if (npmMatch) {
+    const [, pkg, version, preset, gadgetName] = npmMatch;
+    return {
+      type: "npm",
+      package: pkg,
+      version,
+      preset,
+      gadgetName
+    };
+  }
+  return null;
+}
+function getCacheDir(spec) {
+  const versionSuffix = spec.version ? `@${spec.version}` : "@latest";
+  if (spec.type === "npm") {
+    return import_node_path11.default.join(CACHE_DIR2, "npm", `${spec.package}${versionSuffix}`);
+  }
+  const sanitizedUrl = spec.package.replace(/[/:]/g, "-").replace(/^-+|-+$/g, "");
+  return import_node_path11.default.join(CACHE_DIR2, "git", `${sanitizedUrl}${versionSuffix}`);
+}
+function isCached(cacheDir) {
+  const packageJsonPath = import_node_path11.default.join(cacheDir, "package.json");
+  return import_node_fs10.default.existsSync(packageJsonPath);
+}
+async function installNpmPackage(spec, cacheDir) {
+  import_node_fs10.default.mkdirSync(cacheDir, { recursive: true });
+  const packageJson = {
+    name: "llmist-gadget-cache",
+    private: true,
+    type: "module"
+  };
+  import_node_fs10.default.writeFileSync(import_node_path11.default.join(cacheDir, "package.json"), JSON.stringify(packageJson, null, 2));
+  const packageSpec = spec.version ? `${spec.package}@${spec.version}` : spec.package;
+  try {
+    (0, import_node_child_process.execSync)(`npm install --prefix "${cacheDir}" "${packageSpec}" --save`, {
+      stdio: "pipe",
+      cwd: cacheDir
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to install npm package '${packageSpec}': ${message}`);
+  }
+}
+async function installGitPackage(spec, cacheDir) {
+  import_node_fs10.default.mkdirSync(import_node_path11.default.dirname(cacheDir), { recursive: true });
+  if (import_node_fs10.default.existsSync(cacheDir)) {
+    try {
+      (0, import_node_child_process.execSync)("git fetch", { cwd: cacheDir, stdio: "pipe" });
+      if (spec.version) {
+        (0, import_node_child_process.execSync)(`git checkout ${spec.version}`, { cwd: cacheDir, stdio: "pipe" });
+      }
+    } catch (error) {
+      import_node_fs10.default.rmSync(cacheDir, { recursive: true, force: true });
+    }
+  }
+  if (!import_node_fs10.default.existsSync(cacheDir)) {
+    try {
+      const cloneCmd = spec.version ? `git clone --branch ${spec.version} "${spec.package}" "${cacheDir}"` : `git clone "${spec.package}" "${cacheDir}"`;
+      (0, import_node_child_process.execSync)(cloneCmd, { stdio: "pipe" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to clone git repository '${spec.package}': ${message}`);
+    }
+    if (import_node_fs10.default.existsSync(import_node_path11.default.join(cacheDir, "package.json"))) {
+      try {
+        (0, import_node_child_process.execSync)("npm install", { cwd: cacheDir, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to install dependencies for '${spec.package}': ${message}`);
+      }
+      try {
+        const packageJson = JSON.parse(import_node_fs10.default.readFileSync(import_node_path11.default.join(cacheDir, "package.json"), "utf-8"));
+        if (packageJson.scripts?.build) {
+          (0, import_node_child_process.execSync)("npm run build", { cwd: cacheDir, stdio: "pipe" });
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to build package '${spec.package}': ${message}`);
+      }
+    }
+  }
+}
+function readManifest(packageDir) {
+  const packageJsonPath = import_node_path11.default.join(packageDir, "package.json");
+  if (!import_node_fs10.default.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const packageJson = JSON.parse(import_node_fs10.default.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.llmist || null;
+  } catch {
+    return null;
+  }
+}
+function getPackagePath(cacheDir, packageName) {
+  const nodeModulesPath = import_node_path11.default.join(cacheDir, "node_modules", packageName);
+  if (import_node_fs10.default.existsSync(nodeModulesPath)) {
+    return nodeModulesPath;
+  }
+  return cacheDir;
+}
+async function loadExternalGadgets(specifier, forceInstall = false) {
+  const spec = parseGadgetSpecifier(specifier);
+  if (!spec) {
+    throw new Error(`Invalid external package specifier: ${specifier}`);
+  }
+  const cacheDir = getCacheDir(spec);
+  if (!isCached(cacheDir) || forceInstall) {
+    if (spec.type === "npm") {
+      await installNpmPackage(spec, cacheDir);
+    } else {
+      await installGitPackage(spec, cacheDir);
+    }
+  }
+  const packagePath = getPackagePath(cacheDir, spec.package);
+  const manifest = readManifest(packagePath);
+  let entryPoint;
+  let gadgetNames = null;
+  if (spec.gadgetName) {
+    gadgetNames = [spec.gadgetName];
+    if (manifest?.subagents?.[spec.gadgetName]) {
+      entryPoint = manifest.subagents[spec.gadgetName].entryPoint;
+    } else {
+      entryPoint = manifest?.gadgets || "./dist/index.js";
+    }
+  } else if (spec.preset) {
+    if (!manifest?.presets?.[spec.preset]) {
+      throw new Error(`Unknown preset '${spec.preset}' in package '${spec.package}'`);
+    }
+    const preset = manifest.presets[spec.preset];
+    if (preset === "*") {
+      gadgetNames = null;
+    } else {
+      gadgetNames = preset;
+    }
+    entryPoint = manifest?.gadgets || "./dist/index.js";
+  } else {
+    entryPoint = manifest?.gadgets || "./dist/index.js";
+  }
+  const resolvedEntryPoint = import_node_path11.default.resolve(packagePath, entryPoint);
+  if (!import_node_fs10.default.existsSync(resolvedEntryPoint)) {
+    throw new Error(
+      `Entry point not found: ${resolvedEntryPoint}. Make sure the package is built (run 'npm run build' in the package directory).`
+    );
+  }
+  const moduleUrl = (0, import_node_url.pathToFileURL)(resolvedEntryPoint).href;
+  let exports2;
+  try {
+    exports2 = await import(moduleUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to import '${specifier}': ${message}`);
+  }
+  let gadgets = extractGadgetsFromModule(exports2);
+  if (gadgetNames) {
+    const gadgetSet = new Set(gadgetNames.map((n) => n.toLowerCase()));
+    gadgets = gadgets.filter((g) => {
+      const name = g.name?.toLowerCase() || "";
+      return gadgetSet.has(name);
+    });
+    const foundNames = new Set(gadgets.map((g) => g.name?.toLowerCase() || ""));
+    for (const requested of gadgetNames) {
+      if (!foundNames.has(requested.toLowerCase())) {
+        throw new Error(`Gadget '${requested}' not found in package '${spec.package}'`);
+      }
+    }
+  }
+  if (gadgets.length === 0) {
+    throw new Error(`No gadgets found in package '${spec.package}'`);
+  }
+  return gadgets;
+}
+
 // src/cli/gadgets.ts
 var PATH_PREFIXES = [".", "/", "~"];
 var BUILTIN_PREFIX = "builtin:";
@@ -11680,7 +12542,17 @@ function isGadgetConstructor(value) {
     return false;
   }
   const prototype = value.prototype;
-  return Boolean(prototype) && (prototype instanceof BaseGadget || isGadgetLike(prototype));
+  if (!prototype) {
+    return false;
+  }
+  if (prototype instanceof AbstractGadget) {
+    return true;
+  }
+  const proto = prototype;
+  if (typeof proto.execute === "function") {
+    return true;
+  }
+  return isGadgetLike(prototype);
 }
 function expandHomePath(input) {
   if (!input.startsWith("~")) {
@@ -11690,10 +12562,10 @@ function expandHomePath(input) {
   if (!home) {
     return input;
   }
-  return import_node_path11.default.join(home, input.slice(1));
+  return import_node_path12.default.join(home, input.slice(1));
 }
 function isFileLikeSpecifier(specifier) {
-  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(import_node_path11.default.sep);
+  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(import_node_path12.default.sep);
 }
 function tryResolveBuiltin(specifier) {
   if (specifier.startsWith(BUILTIN_PREFIX)) {
@@ -11716,11 +12588,11 @@ function resolveGadgetSpecifier(specifier, cwd) {
     return specifier;
   }
   const expanded = expandHomePath(specifier);
-  const resolvedPath = import_node_path11.default.resolve(cwd, expanded);
-  if (!import_node_fs10.default.existsSync(resolvedPath)) {
+  const resolvedPath = import_node_path12.default.resolve(cwd, expanded);
+  if (!import_node_fs11.default.existsSync(resolvedPath)) {
     throw new Error(`Gadget module not found at ${resolvedPath}`);
   }
-  return (0, import_node_url.pathToFileURL)(resolvedPath).href;
+  return (0, import_node_url2.pathToFileURL)(resolvedPath).href;
 }
 function extractGadgetsFromModule(moduleExports) {
   const results = [];
@@ -11733,7 +12605,7 @@ function extractGadgetsFromModule(moduleExports) {
       return;
     }
     visited.add(value);
-    if (value instanceof BaseGadget || isGadgetLike(value)) {
+    if (value instanceof AbstractGadget || isGadgetLike(value)) {
       results.push(value);
       return;
     }
@@ -11758,12 +12630,23 @@ function extractGadgetsFromModule(moduleExports) {
 }
 async function loadGadgets(specifiers, cwd, importer = (specifier) => import(specifier)) {
   const gadgets = [];
+  const usingDefaultImporter = importer.toString().includes("import(specifier)");
   for (const specifier of specifiers) {
     const builtin = tryResolveBuiltin(specifier);
     if (builtin) {
       gadgets.push(builtin);
       continue;
     }
+    if (usingDefaultImporter && isExternalPackageSpecifier(specifier)) {
+      try {
+        const externalGadgets = await loadExternalGadgets(specifier);
+        gadgets.push(...externalGadgets);
+        continue;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load external package '${specifier}': ${message}`);
+      }
+    }
     const resolved = resolveGadgetSpecifier(specifier, cwd);
     let exports2;
     try {
@@ -11789,13 +12672,13 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
 
 // src/cli/llm-logging.ts
 var import_promises4 = require("fs/promises");
-var import_node_os5 = require("os");
-var import_node_path12 = require("path");
+var import_node_os6 = require("os");
+var import_node_path13 = require("path");
 init_messages();
-var DEFAULT_LLM_LOG_DIR = (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".llmist", "logs");
+var DEFAULT_LLM_LOG_DIR = (0, import_node_path13.join)((0, import_node_os6.homedir)(), ".llmist", "logs");
 function resolveLogDir(option, subdir) {
   if (option === true) {
-    return (0, import_node_path12.join)(DEFAULT_LLM_LOG_DIR, subdir);
+    return (0, import_node_path13.join)(DEFAULT_LLM_LOG_DIR, subdir);
   }
   if (typeof option === "string") {
     return option;
@@ -11806,14 +12689,14 @@ function formatLlmRequest(messages) {
   const lines = [];
   for (const msg of messages) {
     lines.push(`=== ${msg.role.toUpperCase()} ===`);
-    lines.push(msg.content ? extractText(msg.content) : "");
+    lines.push(msg.content ? extractMessageText(msg.content) : "");
     lines.push("");
   }
   return lines.join("\n");
 }
 async function writeLogFile(dir, filename, content) {
   await (0, import_promises4.mkdir)(dir, { recursive: true });
-  await (0, import_promises4.writeFile)((0, import_node_path12.join)(dir, filename), content, "utf-8");
+  await (0, import_promises4.writeFile)((0, import_node_path13.join)(dir, filename), content, "utf-8");
 }
 function formatSessionTimestamp(date = /* @__PURE__ */ new Date()) {
   const pad = (n) => n.toString().padStart(2, "0");
@@ -11827,7 +12710,7 @@ function formatSessionTimestamp(date = /* @__PURE__ */ new Date()) {
 }
 async function createSessionDir(baseDir) {
   const timestamp = formatSessionTimestamp();
-  const sessionDir = (0, import_node_path12.join)(baseDir, timestamp);
+  const sessionDir = (0, import_node_path13.join)(baseDir, timestamp);
   try {
     await (0, import_promises4.mkdir)(sessionDir, { recursive: true });
     return sessionDir;
@@ -12021,12 +12904,14 @@ function formatMediaLine(media) {
   const id = import_chalk3.default.cyan(media.id);
   const mimeType = import_chalk3.default.dim(media.mimeType);
   const size = import_chalk3.default.yellow(formatBytes(media.sizeBytes));
-  const path5 = import_chalk3.default.dim(media.path);
-  return `${import_chalk3.default.dim("[")}${icon} ${id} ${mimeType} ${size}${import_chalk3.default.dim("]")} ${import_chalk3.default.dim("\u2192")} ${path5}`;
+  const path6 = import_chalk3.default.dim(media.path);
+  return `${import_chalk3.default.dim("[")}${icon} ${id} ${mimeType} ${size}${import_chalk3.default.dim("]")} ${import_chalk3.default.dim("\u2192")} ${path6}`;
 }
 function formatGadgetSummary2(result) {
   const gadgetLabel = import_chalk3.default.magenta.bold(result.gadgetName);
-  const timeLabel = import_chalk3.default.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const timeLabel = import_chalk3.default.dim(
+    result.executionTimeMs >= 1e3 ? `${(result.executionTimeMs / 1e3).toFixed(1)}s` : `${Math.round(result.executionTimeMs)}ms`
+  );
   const paramsStr = formatParametersInline(result.parameters);
   const paramsLabel = paramsStr ? `${import_chalk3.default.dim("(")}${paramsStr}${import_chalk3.default.dim(")")}` : "";
   if (result.error) {
@@ -12194,6 +13079,8 @@ var StreamProgress = class {
   delayTimeout = null;
   isRunning = false;
   hasRendered = false;
+  lastRenderLineCount = 0;
+  // Track lines rendered for multi-line clearing
   // Current call stats (streaming mode)
   mode = "cumulative";
   model = "";
@@ -12213,6 +13100,99 @@ var StreamProgress = class {
   totalCost = 0;
   iterations = 0;
   currentIteration = 0;
+  // In-flight gadget tracking for concurrent status display
+  inFlightGadgets = /* @__PURE__ */ new Map();
+  // Nested agent tracking for hierarchical subagent display
+  nestedAgents = /* @__PURE__ */ new Map();
+  // Nested gadget tracking for hierarchical subagent display
+  nestedGadgets = /* @__PURE__ */ new Map();
+  /**
+   * Add a gadget to the in-flight tracking (called when gadget_call event received).
+   * Triggers re-render to show the gadget in the status display.
+   */
+  addGadget(invocationId, name, params) {
+    this.inFlightGadgets.set(invocationId, { name, params, startTime: Date.now() });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Remove a gadget from in-flight tracking (called when gadget_result event received).
+   * Triggers re-render to update the status display.
+   */
+  removeGadget(invocationId) {
+    this.inFlightGadgets.delete(invocationId);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Check if there are any gadgets currently in flight.
+   */
+  hasInFlightGadgets() {
+    return this.inFlightGadgets.size > 0;
+  }
+  /**
+   * Add a nested agent LLM call (called when nested llm_call_start event received).
+   * Used to display hierarchical progress for subagent gadgets.
+   */
+  addNestedAgent(id, parentInvocationId, depth, model, iteration, inputTokens) {
+    this.nestedAgents.set(id, {
+      parentInvocationId,
+      depth,
+      model,
+      iteration,
+      startTime: Date.now(),
+      inputTokens
+    });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Update a nested agent with completion info (called when nested llm_call_end event received).
+   */
+  updateNestedAgent(id, outputTokens) {
+    const agent = this.nestedAgents.get(id);
+    if (agent) {
+      agent.outputTokens = outputTokens;
+      if (this.isRunning && this.isTTY) {
+        this.render();
+      }
+    }
+  }
+  /**
+   * Remove a nested agent (called when the nested LLM call completes).
+   */
+  removeNestedAgent(id) {
+    this.nestedAgents.delete(id);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Add a nested gadget call (called when nested gadget_call event received).
+   */
+  addNestedGadget(id, depth, parentInvocationId, name) {
+    this.nestedGadgets.set(id, {
+      depth,
+      parentInvocationId,
+      name,
+      startTime: Date.now()
+    });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Remove a nested gadget (called when nested gadget_result event received).
+   */
+  removeNestedGadget(id) {
+    this.nestedGadgets.delete(id);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
   /**
    * Starts a new LLM call. Switches to streaming mode.
    * @param model - Model name being used
@@ -12339,15 +13319,57 @@ var StreamProgress = class {
     this.isStreaming = true;
   }
   render() {
+    this.clearRenderedLines();
     const spinner = SPINNER_FRAMES[this.frameIndex++ % SPINNER_FRAMES.length];
+    const lines = [];
     if (this.mode === "streaming") {
-      this.renderStreamingMode(spinner);
+      lines.push(this.formatStreamingLine(spinner));
     } else {
-      this.renderCumulativeMode(spinner);
-    }
+      lines.push(this.formatCumulativeLine(spinner));
+    }
+    if (this.isTTY) {
+      for (const [gadgetId, gadget] of this.inFlightGadgets) {
+        const elapsed = ((Date.now() - gadget.startTime) / 1e3).toFixed(1);
+        const gadgetLine = `  ${import_chalk4.default.blue("\u23F5")} ${import_chalk4.default.magenta.bold(gadget.name)}${import_chalk4.default.dim("(...)")} ${import_chalk4.default.dim(elapsed + "s")}`;
+        lines.push(gadgetLine);
+        for (const [_agentId, nested] of this.nestedAgents) {
+          if (nested.parentInvocationId !== gadgetId) continue;
+          const indent = "  ".repeat(nested.depth + 1);
+          const nestedElapsed = ((Date.now() - nested.startTime) / 1e3).toFixed(1);
+          const tokens = nested.inputTokens ? ` ${import_chalk4.default.dim("\u2191")}${import_chalk4.default.yellow(formatTokens(nested.inputTokens))}` : "";
+          const outTokens = nested.outputTokens ? ` ${import_chalk4.default.dim("\u2193")}${import_chalk4.default.green(formatTokens(nested.outputTokens))}` : "";
+          const nestedLine = `${indent}${import_chalk4.default.cyan(`#${nested.iteration}`)} ${import_chalk4.default.dim(nested.model)}${tokens}${outTokens} ${import_chalk4.default.dim(nestedElapsed + "s")} ${import_chalk4.default.cyan(spinner)}`;
+          lines.push(nestedLine);
+        }
+        for (const [_nestedId, nestedGadget] of this.nestedGadgets) {
+          if (nestedGadget.parentInvocationId === gadgetId) {
+            const indent = "  ".repeat(nestedGadget.depth + 1);
+            const nestedElapsed = ((Date.now() - nestedGadget.startTime) / 1e3).toFixed(1);
+            const nestedGadgetLine = `${indent}${import_chalk4.default.blue("\u23F5")} ${import_chalk4.default.dim(nestedGadget.name + "(...)")} ${import_chalk4.default.dim(nestedElapsed + "s")}`;
+            lines.push(nestedGadgetLine);
+          }
+        }
+      }
+    }
+    this.lastRenderLineCount = lines.length;
+    this.target.write("\r" + lines.join("\n"));
     this.hasRendered = true;
   }
-  renderStreamingMode(spinner) {
+  /**
+   * Clears the previously rendered lines (for multi-line status display).
+   */
+  clearRenderedLines() {
+    if (!this.hasRendered || this.lastRenderLineCount === 0) return;
+    this.target.write("\r\x1B[K");
+    for (let i = 1; i < this.lastRenderLineCount; i++) {
+      this.target.write("\x1B[1A\x1B[K");
+    }
+    this.target.write("\r");
+  }
+  /**
+   * Format the streaming mode progress line (returns string, doesn't write).
+   */
+  formatStreamingLine(spinner) {
     const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
     const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
     const parts = [];
@@ -12381,7 +13403,7 @@ var StreamProgress = class {
     if (callCost > 0) {
       parts.push(import_chalk4.default.cyan(`$${formatCost(callCost)}`));
     }
-    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
+    return `${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`;
   }
   /**
    * Calculates live cost estimate for the current streaming call.
@@ -12418,7 +13440,10 @@ var StreamProgress = class {
     }
     return this.callInputTokens / limits.contextWindow * 100;
   }
-  renderCumulativeMode(spinner) {
+  /**
+   * Format the cumulative mode progress line (returns string, doesn't write).
+   */
+  formatCumulativeLine(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
     if (this.model) {
@@ -12434,10 +13459,10 @@ var StreamProgress = class {
       parts.push(import_chalk4.default.dim("cost:") + import_chalk4.default.cyan(` $${formatCost(this.totalCost)}`));
     }
     parts.push(import_chalk4.default.dim(`${elapsed}s`));
-    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
+    return `${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`;
   }
   /**
-   * Pauses the progress indicator and clears the line.
+   * Pauses the progress indicator and clears all rendered lines.
    * Can be resumed with start().
    */
   pause() {
@@ -12451,10 +13476,9 @@ var StreamProgress = class {
       this.interval = null;
     }
     this.isRunning = false;
-    if (this.hasRendered) {
-      this.target.write("\r\x1B[K\x1B[0G");
-      this.hasRendered = false;
-    }
+    this.clearRenderedLines();
+    this.hasRendered = false;
+    this.lastRenderLineCount = 0;
   }
   /**
    * Completes the progress indicator and clears the line.
@@ -12642,6 +13666,7 @@ function configToAgentOptions(config) {
   if (config.docker !== void 0) result.docker = config.docker;
   if (config["docker-cwd-permission"] !== void 0)
     result.dockerCwdPermission = config["docker-cwd-permission"];
+  if (config.subagents !== void 0) result.subagents = config.subagents;
   return result;
 }
 
@@ -12829,7 +13854,12 @@ async function executeAgent(promptArg, options, env) {
       return void 0;
     }
   };
-  const builder = new AgentBuilder(client).withModel(options.model).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
+  const resolvedSubagentConfig = buildSubagentConfigMap(
+    options.model,
+    options.subagents,
+    options.globalSubagents
+  );
+  const builder = new AgentBuilder(client).withModel(options.model).withSubagentConfig(resolvedSubagentConfig).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
     observers: {
       // onLLMCallStart: Start progress indicator for each LLM call
       // This showcases how to react to agent lifecycle events
@@ -13025,6 +14055,38 @@ Denied: ${result.reason ?? "by user"}`
       "Maximize efficiency by batching independent operations in a single response."
     ].join(" ")
   );
+  if (!options.quiet) {
+    builder.withNestedEventCallback((event) => {
+      if (event.type === "llm_call_start") {
+        const info = event.event;
+        const nestedId = `${event.gadgetInvocationId}:${info.iteration}`;
+        progress.addNestedAgent(
+          nestedId,
+          event.gadgetInvocationId,
+          event.depth,
+          info.model,
+          info.iteration,
+          info.inputTokens
+        );
+      } else if (event.type === "llm_call_end") {
+        const info = event.event;
+        const nestedId = `${event.gadgetInvocationId}:${info.iteration}`;
+        progress.updateNestedAgent(nestedId, info.outputTokens);
+        setTimeout(() => progress.removeNestedAgent(nestedId), 100);
+      } else if (event.type === "gadget_call") {
+        const gadgetEvent = event.event;
+        progress.addNestedGadget(
+          gadgetEvent.call.invocationId,
+          event.depth,
+          event.gadgetInvocationId,
+          gadgetEvent.call.gadgetName
+        );
+      } else if (event.type === "gadget_result") {
+        const resultEvent = event.event;
+        progress.removeNestedGadget(resultEvent.result.invocationId);
+      }
+    });
+  }
   let agent;
   if (options.image || options.audio) {
     const parts = [text(prompt)];
@@ -13049,10 +14111,22 @@ Denied: ${result.reason ?? "by user"}`
   try {
     for await (const event of agent.run()) {
       if (event.type === "text") {
-        progress.pause();
         textBuffer += event.content;
+      } else if (event.type === "gadget_call") {
+        flushTextBuffer();
+        if (!options.quiet) {
+          progress.addGadget(
+            event.call.invocationId,
+            event.call.gadgetName,
+            event.call.parameters
+          );
+          progress.start();
+        }
       } else if (event.type === "gadget_result") {
         flushTextBuffer();
+        if (!options.quiet) {
+          progress.removeGadget(event.result.invocationId);
+        }
         progress.pause();
         if (options.quiet) {
           if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
@@ -13067,6 +14141,9 @@ Denied: ${result.reason ?? "by user"}`
 `
           );
         }
+        if (progress.hasInFlightGadgets()) {
+          progress.start();
+        }
       }
     }
   } catch (error) {
@@ -13099,14 +14176,16 @@ Denied: ${result.reason ?? "by user"}`
     }
   }
 }
-function registerAgentCommand(program, env, config) {
+function registerAgentCommand(program, env, config, globalSubagents) {
   const cmd = program.command(COMMANDS.agent).description("Run the llmist agent loop with optional gadgets.").argument("[prompt]", "Prompt for the agent loop. Falls back to stdin when available.");
   addAgentOptions(cmd, config);
   cmd.action(
     (prompt, options) => executeAction(() => {
       const mergedOptions = {
         ...options,
-        gadgetApproval: config?.["gadget-approval"]
+        gadgetApproval: config?.["gadget-approval"],
+        subagents: config?.subagents,
+        globalSubagents
       };
       return executeAgent(prompt, mergedOptions, env);
     }, env)
@@ -13206,6 +14285,104 @@ function registerCompleteCommand(program, env, config) {
   );
 }
 
+// src/cli/init-command.ts
+var import_node_fs12 = require("fs");
+var import_node_path14 = require("path");
+var STARTER_CONFIG = `# ~/.llmist/cli.toml
+# llmist CLI configuration file
+#
+# This is a minimal starter config. For a comprehensive example with all options:
+#   https://github.com/zbigniewsobiecki/llmist/blob/main/examples/cli.example.toml
+#
+# Key concepts:
+#   - Any section can inherit from others using: inherits = "section-name"
+#   - Prompts can use templates with Eta syntax: <%~ include("@prompt-name") %>
+#   - Custom sections become CLI commands: [my-command] -> llmist my-command
+
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# GLOBAL OPTIONS
+# These apply to all commands. CLI flags override these settings.
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+[global]
+# log-level = "info"              # silly, trace, debug, info, warn, error, fatal
+# log-file = "/tmp/llmist.log"    # Enable file logging (JSON format)
+
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# COMPLETE COMMAND DEFAULTS
+# For single LLM responses: llmist complete "prompt"
+# Model format: provider:model (e.g., openai:gpt-4o, anthropic:claude-sonnet-4-5)
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+[complete]
+# model = "openai:gpt-4o"
+# temperature = 0.7               # 0-2, higher = more creative
+# max-tokens = 4096               # Maximum response length
+
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# AGENT COMMAND DEFAULTS
+# For tool-using agents: llmist agent "prompt"
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+[agent]
+# model = "anthropic:claude-sonnet-4-5"
+# max-iterations = 15             # Max tool-use loops before stopping
+# gadgets = [                     # Tools the agent can use
+#   "ListDirectory",
+#   "ReadFile",
+#   "WriteFile",
+# ]
+
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# CUSTOM COMMANDS
+# Any other section becomes a new CLI command!
+# Uncomment below to create: llmist summarize "your text"
+#\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# [summarize]
+# type = "complete"               # "complete" or "agent"
+# description = "Summarize text concisely."
+# system = "Summarize the following text in 2-3 bullet points."
+# temperature = 0.3
+`;
+async function executeInit(_options, env) {
+  const configPath = getConfigPath();
+  const configDir = (0, import_node_path14.dirname)(configPath);
+  if ((0, import_node_fs12.existsSync)(configPath)) {
+    env.stderr.write(`Configuration already exists at ${configPath}
+`);
+    env.stderr.write("\n");
+    env.stderr.write(`To view it:  cat ${configPath}
+`);
+    env.stderr.write(`To reset:    rm ${configPath} && llmist init
+`);
+    return;
+  }
+  if (!(0, import_node_fs12.existsSync)(configDir)) {
+    (0, import_node_fs12.mkdirSync)(configDir, { recursive: true });
+  }
+  (0, import_node_fs12.writeFileSync)(configPath, STARTER_CONFIG, "utf-8");
+  env.stderr.write(`Created ${configPath}
+`);
+  env.stderr.write("\n");
+  env.stderr.write("Next steps:\n");
+  env.stderr.write("  1. Set your API key:\n");
+  env.stderr.write("       export OPENAI_API_KEY=sk-...\n");
+  env.stderr.write("       export ANTHROPIC_API_KEY=sk-...\n");
+  env.stderr.write("       export GEMINI_API_KEY=...\n");
+  env.stderr.write("\n");
+  env.stderr.write(`  2. Customize your config:
+`);
+  env.stderr.write(`       $EDITOR ${configPath}
+`);
+  env.stderr.write("\n");
+  env.stderr.write("  3. See all options:\n");
+  env.stderr.write(
+    "       https://github.com/zbigniewsobiecki/llmist/blob/main/examples/cli.example.toml\n"
+  );
+  env.stderr.write("\n");
+  env.stderr.write('Try it: llmist complete "Hello, world!"\n');
+}
+function registerInitCommand(program, env) {
+  program.command(COMMANDS.init).description("Initialize llmist configuration at ~/.llmist/cli.toml").action((options) => executeAction(() => executeInit(options, env), env));
+}
+
 // src/cli/environment.ts
 var import_node_readline = __toESM(require("readline"), 1);
 var import_chalk6 = __toESM(require("chalk"), 1);
@@ -13308,7 +14485,7 @@ function createCommandEnvironment(baseEnv, config) {
     createLogger: createLoggerFactory(loggerConfig)
   };
 }
-function registerCustomCommand(program, name, config, env) {
+function registerCustomCommand(program, name, config, env, globalSubagents) {
   const type = config.type ?? "agent";
   const description = config.description ?? `Custom ${type} command`;
   const cmd = program.command(name).description(description).argument("[prompt]", "Prompt for the command. Falls back to stdin when available.");
@@ -13333,7 +14510,8 @@ function registerCustomCommand(program, name, config, env) {
         const configDefaults = configToAgentOptions(config);
         const options = {
           ...configDefaults,
-          ...cliOptions
+          ...cliOptions,
+          globalSubagents
         };
         await executeAgent(prompt, options, cmdEnv);
       }, cmdEnv);
@@ -13776,7 +14954,7 @@ function registerGadgetCommand(program, env) {
 }
 
 // src/cli/image-command.ts
-var import_node_fs11 = require("fs");
+var import_node_fs13 = require("fs");
 var DEFAULT_IMAGE_MODEL = "dall-e-3";
 async function executeImage(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
@@ -13800,7 +14978,7 @@ async function executeImage(promptArg, options, env) {
     const imageData = result.images[0];
     if (imageData.b64Json) {
       const buffer = Buffer.from(imageData.b64Json, "base64");
-      (0, import_node_fs11.writeFileSync)(options.output, buffer);
+      (0, import_node_fs13.writeFileSync)(options.output, buffer);
       if (!options.quiet) {
         env.stderr.write(`${SUMMARY_PREFIX} Image saved to ${options.output}
 `);
@@ -14241,7 +15419,7 @@ function registerModelsCommand(program, env) {
 }
 
 // src/cli/speech-command.ts
-var import_node_fs12 = require("fs");
+var import_node_fs14 = require("fs");
 var DEFAULT_SPEECH_MODEL = "tts-1";
 var DEFAULT_VOICE = "nova";
 async function executeSpeech(textArg, options, env) {
@@ -14264,7 +15442,7 @@ async function executeSpeech(textArg, options, env) {
   });
   const audioBuffer = Buffer.from(result.audio);
   if (options.output) {
-    (0, import_node_fs12.writeFileSync)(options.output, audioBuffer);
+    (0, import_node_fs14.writeFileSync)(options.output, audioBuffer);
     if (!options.quiet) {
       env.stderr.write(`${SUMMARY_PREFIX} Audio saved to ${options.output}
 `);
@@ -14338,17 +15516,18 @@ function createProgram(env, config) {
     writeErr: (str) => env.stderr.write(str)
   });
   registerCompleteCommand(program, env, config?.complete);
-  registerAgentCommand(program, env, config?.agent);
+  registerAgentCommand(program, env, config?.agent, config?.subagents);
   registerImageCommand(program, env, config?.image);
   registerSpeechCommand(program, env, config?.speech);
   registerVisionCommand(program, env);
   registerModelsCommand(program, env);
   registerGadgetCommand(program, env);
+  registerInitCommand(program, env);
   if (config) {
     const customNames = getCustomCommandNames(config);
     for (const name of customNames) {
       const cmdConfig = config[name];
-      registerCustomCommand(program, name, cmdConfig, env);
+      registerCustomCommand(program, name, cmdConfig, env, config.subagents);
     }
   }
   return program;