@theokit/agents 0.4.0 → 0.6.0

package/dist/{chunk-NC5EE7HN.js → chunk-KTYBQ7HY.js}

@@ -9,14 +9,16 @@ import {
   TOOL_METHODS,
   Trace,
   getAgentConfig,
+  getContextWindowConfig,
   getGatewayConfig,
   getMcpConfig,
   getMemoryConfig,
   getMeta,
   getMixins,
+  getProjectContextConfig,
   getSkillsConfig,
   getSubAgents
-} from "./chunk-O4UG4RXE.js";
+} from "./chunk-MVEY7HEY.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -40,6 +42,68 @@ function isAgentContext(ctx) {
 }
 __name(isAgentContext, "isAgentContext");
 
+// src/bridge/compile-context-window.ts
+var STRATEGY_KNOBS = [
+  "compactionStrategy",
+  "preserveLastN",
+  "preserveToolResults",
+  "preserveSystemPrompt"
+];
+function compileContextWindow(options) {
+  const context = {};
+  if (typeof options.maxTokens === "number") {
+    context.maxTokens = options.maxTokens;
+  }
+  const opts = options;
+  const metadataOnlyKnobs = STRATEGY_KNOBS.filter((knob) => opts[knob] !== void 0);
+  return {
+    context,
+    metadataOnlyKnobs
+  };
+}
+__name(compileContextWindow, "compileContextWindow");
+
+// src/bridge/compile-project-context.ts
+var UNMAPPED_KNOBS = [
+  "indexStrategy",
+  "relevanceStrategy",
+  "maxFilesInContext",
+  "includeExtensions",
+  "rootMarkers"
+];
+function projectContextMetadataOnlyKnobs(options) {
+  const opts = options;
+  return UNMAPPED_KNOBS.filter((knob) => opts[knob] !== void 0);
+}
+__name(projectContextMetadataOnlyKnobs, "projectContextMetadataOnlyKnobs");
+function compileProjectContext(options, base) {
+  return async (promptCtx) => {
+    const cwd = promptCtx.cwd;
+    if (!cwd) {
+      return base ?? "";
+    }
+    const { buildEnvContext, buildRepoMap } = await import("@theokit/sdk-tools");
+    const { readProjectInstructions } = await import("@theokit/sdk/project");
+    const env = buildEnvContext(cwd);
+    const repoMap = buildRepoMap(cwd, {
+      ignore: options.ignorePatterns
+    });
+    let instructions = "";
+    try {
+      instructions = (await readProjectInstructions(cwd)).content ?? "";
+    } catch {
+      instructions = "";
+    }
+    return [
+      env,
+      repoMap,
+      instructions,
+      base
+    ].filter(Boolean).join("\n\n");
+  };
+}
+__name(compileProjectContext, "compileProjectContext");
+
 // src/bridge/walk-agent-metadata.ts
 import "reflect-metadata";
 import { Reflector } from "@theokit/http";
@@ -49,7 +113,9 @@ var USE_FILTERS = /* @__PURE__ */ Symbol.for("theokit:http-decorators:use-filter
 var AgentWarningCode = {
   INTERCEPTOR_METADATA_ONLY: "THEO_AGENT_INTERCEPTOR_METADATA_ONLY",
   FILTER_METADATA_ONLY: "THEO_AGENT_FILTER_METADATA_ONLY",
-  BUDGET_TOP_LEVEL_METADATA_ONLY: "THEO_AGENT_BUDGET_TOP_LEVEL_METADATA_ONLY"
+  BUDGET_TOP_LEVEL_METADATA_ONLY: "THEO_AGENT_BUDGET_TOP_LEVEL_METADATA_ONLY",
+  CONTEXT_STRATEGY_METADATA_ONLY: "THEO_AGENT_CONTEXT_STRATEGY_METADATA_ONLY",
+  PROJECT_CONTEXT_KNOB_METADATA_ONLY: "THEO_AGENT_PROJECT_CONTEXT_KNOB_METADATA_ONLY"
 };
 var reflectorInstance = new Reflector();
 function walkToolbox(ToolboxClass) {
@@ -88,6 +154,21 @@ function walkToolbox(ToolboxClass) {
   };
 }
 __name(walkToolbox, "walkToolbox");
+function warnUnmappedDecoratorKnobs(agentName, contextWindow, projectContext) {
+  if (contextWindow) {
+    const { metadataOnlyKnobs } = compileContextWindow(contextWindow);
+    if (metadataOnlyKnobs.length > 0) {
+      console.warn(`[${AgentWarningCode.CONTEXT_STRATEGY_METADATA_ONLY}] Agent ${agentName}: @ContextWindow knob(s) ${metadataOnlyKnobs.join(", ")} are metadata-only \u2014 the SDK manages transcript compaction internally. Only maxTokens is forwarded to Agent.create({ context }).`);
+    }
+  }
+  if (projectContext) {
+    const unmapped = projectContextMetadataOnlyKnobs(projectContext);
+    if (unmapped.length > 0) {
+      console.warn(`[${AgentWarningCode.PROJECT_CONTEXT_KNOB_METADATA_ONLY}] Agent ${agentName}: @ProjectContext knob(s) ${unmapped.join(", ")} are metadata-only \u2014 the repo map is composed via buildRepoMap/buildEnvContext/readProjectInstructions; only ignorePatterns is forwarded.`);
+    }
+  }
+}
+__name(warnUnmappedDecoratorKnobs, "warnUnmappedDecoratorKnobs");
 var agentWalkCache = /* @__PURE__ */ new WeakMap();
 function walkAgentMetadata(AgentClass, toolboxClasses = []) {
   if (toolboxClasses.length === 0) {
@@ -121,6 +202,9 @@ function walkAgentMetadata(AgentClass, toolboxClasses = []) {
   const memory = getMemoryConfig(AgentClass);
   const skills = getSkillsConfig(AgentClass);
   const mcpServers = getMcpConfig(AgentClass);
+  const contextWindow = getContextWindowConfig(AgentClass);
+  const projectContext = getProjectContextConfig(AgentClass);
+  warnUnmappedDecoratorKnobs(AgentClass.name, contextWindow, projectContext);
   const result = {
     agentConfig,
     mainLoop,
@@ -133,6 +217,8 @@ function walkAgentMetadata(AgentClass, toolboxClasses = []) {
     subAgentClasses,
     memory,
     skills,
+    contextWindow,
+    projectContext,
     mcpServers
   };
   if (toolboxClasses.length === 0) {
@@ -153,6 +239,20 @@ function validateUniqueRoutes(results) {
 }
 __name(validateUniqueRoutes, "validateUniqueRoutes");
 
+// src/bridge/compile-skills.ts
+function compileSkills(options) {
+  if (options.autoDiscover) {
+    return {
+      autoInject: true
+    };
+  }
+  return {
+    enabled: options.include,
+    autoInject: true
+  };
+}
+__name(compileSkills, "compileSkills");
+
 // src/bridge/agent-compiler.ts
 function compileTools(toolboxes, toolboxInstances) {
   const tools = [];
@@ -200,7 +300,9 @@ function compileAgent(walkResult, toolboxInstances = /* @__PURE__ */ new Map())
     tools,
     agents,
     memory: walkResult.memory,
-    skills: walkResult.skills,
+    skills: walkResult.skills ? compileSkills(walkResult.skills) : void 0,
+    context: walkResult.contextWindow ? compileContextWindow(walkResult.contextWindow).context : void 0,
+    projectContext: walkResult.projectContext,
     mcpServers: walkResult.mcpServers,
     maxIterations: walkResult.mainLoop.maxIterations ?? walkResult.agentConfig.maxIterations,
     timeoutMs: walkResult.mainLoop.timeoutMs ?? walkResult.agentConfig.timeoutMs,
@@ -375,7 +477,8 @@ function translateSystemEvent(msg, runId) {
 __name(translateSystemEvent, "translateSystemEvent");
 function translateAssistantEvent(msg) {
   const events = [];
-  const content = msg.content;
+  const message = msg.message;
+  const content = message?.content;
   if (!Array.isArray(content)) return events;
   for (const block of content) {
     const b = block;
@@ -399,12 +502,14 @@ function translateAssistantEvent(msg) {
 __name(translateAssistantEvent, "translateAssistantEvent");
 function translateToolCallEvent(msg) {
   const status = msg.status;
+  const callId = asString(msg.call_id, `tc-${Date.now()}`);
+  const toolName = asString(msg.name, "unknown");
   if (status === "completed") {
     return [
       {
         type: "tool_result",
-        callId: asString(msg.id, `tc-${Date.now()}`),
-        toolName: asString(msg.name, "unknown"),
+        callId,
+        toolName,
         output: asString(msg.result, ""),
         durationMs: 0,
         isError: false
@@ -415,9 +520,9 @@ function translateToolCallEvent(msg) {
     return [
       {
         type: "tool_result",
-        callId: asString(msg.id, `tc-${Date.now()}`),
-        toolName: asString(msg.name, "unknown"),
-        output: asString(msg.error, "Tool failed"),
+        callId,
+        toolName,
+        output: asString(msg.result, "Tool failed"),
         durationMs: 0,
         isError: true
       }
@@ -428,7 +533,7 @@ function translateToolCallEvent(msg) {
 __name(translateToolCallEvent, "translateToolCallEvent");
 function translateStatusEvent(msg) {
   const s = msg.status;
-  if (s === "done" || s === "completed") {
+  if (s === "FINISHED" || s === "CANCELLED") {
     return [
       {
         type: "done",
@@ -443,12 +548,12 @@ function translateStatusEvent(msg) {
       }
     ];
   }
-  if (s === "error") {
+  if (s === "ERROR" || s === "EXPIRED") {
     return [
       {
         type: "error",
         code: "AGENT_ERROR",
-        message: asString(msg.error, "Agent error"),
+        message: asString(msg.message, "Agent error"),
         retryable: false
       }
     ];
@@ -468,7 +573,7 @@ function translateSdkEvent(msg, runId) {
       return [
         {
           type: "thinking",
-          content: asString(msg.content, "")
+          content: asString(msg.text, "")
         }
       ];
     case "status":
@@ -480,8 +585,37 @@ function translateSdkEvent(msg, runId) {
 __name(translateSdkEvent, "translateSdkEvent");
 
 // src/bridge/sdk-adapter.ts
-function createSdkAgentStream(agentWalk, compiledTools, apiKey, envModel) {
-  const model = envModel ?? agentWalk.agentConfig.model ?? "openai/gpt-4o-mini";
+function assembleM8CreateOptions(compiled) {
+  const options = {};
+  const applied = [];
+  const base = compiled.systemPrompt;
+  if (compiled.skills) {
+    options.skills = compiled.skills;
+    options.local = {
+      settingSources: [
+        "project"
+      ]
+    };
+    applied.push("skills");
+  }
+  if (compiled.context) {
+    options.context = compiled.context;
+    applied.push("context");
+  }
+  if (compiled.projectContext) {
+    options.systemPrompt = compileProjectContext(compiled.projectContext, base);
+    applied.push("projectContext");
+  } else if (base !== void 0) {
+    options.systemPrompt = base;
+  }
+  return {
+    options,
+    applied
+  };
+}
+__name(assembleM8CreateOptions, "assembleM8CreateOptions");
+function createSdkAgentStream(compiled, compiledTools, apiKey, envModel) {
+  const model = envModel ?? compiled.model ?? "openai/gpt-4o-mini";
   return (message, _sessionId) => ({
     async *[Symbol.asyncIterator]() {
       const runId = `run-${Date.now()}`;
@@ -508,32 +642,44 @@ function createSdkAgentStream(agentWalk, compiledTools, apiKey, envModel) {
         handler: t.handler
       }));
       try {
+        const { options: m8, applied } = assembleM8CreateOptions(compiled);
+        if (applied.length > 0) {
+          console.debug("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
+            skills: applied.includes("skills"),
+            context: applied.includes("context"),
+            projectContext: applied.includes("projectContext")
+          });
+        }
         const agent = await Agent.create({
           apiKey,
           model: {
             id: model
           },
           tools: sdkTools,
-          systemPrompt: agentWalk.agentConfig.systemPrompt
+          ...m8
         });
         const run = await agent.send(message);
+        let sawTerminal = false;
         for await (const sdkEvent of run.stream()) {
           const translated = translateSdkEvent(sdkEvent, runId);
           for (const event of translated) {
+            if (event.type === "done" || event.type === "error") sawTerminal = true;
             yield event;
           }
         }
-        yield {
-          type: "done",
-          result: "",
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0,
-            totalTokens: 0
-          },
-          durationMs: Date.now() - t0,
-          cost: 0
-        };
+        if (!sawTerminal) {
+          yield {
+            type: "done",
+            result: "",
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0,
+              totalTokens: 0
+            },
+            durationMs: Date.now() - t0,
+            cost: 0
+          };
+        }
         await agent.dispose();
       } catch (err) {
         yield {
@@ -548,7 +694,66 @@ function createSdkAgentStream(agentWalk, compiledTools, apiKey, envModel) {
 }
 __name(createSdkAgentStream, "createSdkAgentStream");
 
-// src/bridge/agent-orchestrator.ts
+// src/loop/loop-strategy.ts
+import { z } from "zod";
+var DEFAULT_MAX_ITERATIONS = 8;
+var loopStrategyConfigSchema = z.object({
+  name: z.enum([
+    "simple-chat",
+    "plan-act-reflect",
+    "react"
+  ]),
+  maxIterations: z.number().int().min(1)
+});
+function resolveLoopStrategy(strategy, maxIterations = DEFAULT_MAX_ITERATIONS) {
+  const cfg = loopStrategyConfigSchema.parse({
+    name: strategy,
+    maxIterations
+  });
+  if (cfg.name === "simple-chat") {
+    return {
+      name: cfg.name,
+      maxIterations: cfg.maxIterations,
+      shouldContinue: /* @__PURE__ */ __name(() => false, "shouldContinue")
+    };
+  }
+  return {
+    name: cfg.name,
+    maxIterations: cfg.maxIterations,
+    shouldContinue: /* @__PURE__ */ __name((outcome) => outcome.finishReason === "tool-calls" && outcome.round < cfg.maxIterations, "shouldContinue")
+  };
+}
+__name(resolveLoopStrategy, "resolveLoopStrategy");
+
+// src/loop/reflection-strategy.ts
+import { z as z2 } from "zod";
+var reflectionStrategyConfigSchema = z2.object({
+  name: z2.string().min(1)
+});
+var ladderReflectionStrategy = {
+  name: "ladder",
+  reflect(outcome) {
+    if (outcome.finishReason === "tool-calls") {
+      return {
+        feedback: `Tool results received (round ${outcome.round}). Reflect on whether the goal is met; if not, refine the approach and continue.`,
+        continue: true
+      };
+    }
+    return {
+      continue: false
+    };
+  }
+};
+var noopReflectionStrategy = {
+  name: "noop",
+  reflect() {
+    return {
+      continue: true
+    };
+  }
+};
+
+// src/bridge/delegation-types.ts
 var BudgetExceededError = class extends Error {
   static {
     __name(this, "BudgetExceededError");
@@ -572,16 +777,185 @@ var DelegationError = class extends Error {
     this.name = "DelegationError";
   }
 };
+
+// src/loop/run-reflective-loop.ts
 function asString2(value, fallback) {
-  if (typeof value === "string") return value;
-  return fallback;
+  return typeof value === "string" ? value : fallback;
 }
 __name(asString2, "asString");
 function asNumber(value, fallback) {
-  if (typeof value === "number") return value;
-  return fallback;
+  return typeof value === "number" ? value : fallback;
 }
 __name(asNumber, "asNumber");
+function deriveFinishReason(signals) {
+  if (signals.sawError) return "error";
+  if (signals.sawDone && signals.doneFinishReason === "tool-calls") return "tool-calls";
+  if (signals.sawToolResult) return "tool-calls";
+  return "stop";
+}
+__name(deriveFinishReason, "deriveFinishReason");
+async function consumeOneRound(factory, prompt, sessionId, signal) {
+  const r = {
+    responseText: "",
+    toolCalls: [],
+    cost: 0,
+    tokens: 0,
+    finishReason: "stop",
+    errorMessage: ""
+  };
+  const signals = {
+    sawError: false,
+    sawDone: false,
+    doneFinishReason: "",
+    sawToolResult: false
+  };
+  for await (const event of factory(prompt, sessionId)) {
+    if (signal?.aborted) break;
+    if (event.type === "text_delta" && typeof event.content === "string") {
+      r.responseText += event.content;
+    } else if (event.type === "tool_result") {
+      signals.sawToolResult = true;
+      r.toolCalls.push({
+        name: asString2(event.toolName, "unknown"),
+        input: event.input ?? {},
+        output: asString2(event.output, "")
+      });
+    } else if (event.type === "done") {
+      signals.sawDone = true;
+      signals.doneFinishReason = asString2(event.finishReason, "");
+      r.cost = asNumber(event.cost, 0);
+      r.tokens = event.usage?.totalTokens ?? 0;
+    } else if (event.type === "error") {
+      signals.sawError = true;
+      r.errorMessage = asString2(event.message, "Unknown agent error");
+    }
+  }
+  r.finishReason = deriveFinishReason(signals);
+  return r;
+}
+__name(consumeOneRound, "consumeOneRound");
+async function runReflectiveLoop(factory, message, sessionId, config) {
+  const { loop, reflection, budget = Number.POSITIVE_INFINITY, signal, agentName = loop.name } = config;
+  const acc = {
+    response: "",
+    toolCalls: [],
+    cost: 0,
+    tokens: 0,
+    rounds: 0
+  };
+  let round = 1;
+  let feedback;
+  while (!signal?.aborted) {
+    const prompt = round === 1 || !feedback ? message : `${message}
+
+[reflection] ${feedback}`;
+    let r;
+    try {
+      r = await consumeOneRound(factory, prompt, sessionId, signal);
+    } catch (err) {
+      if (err instanceof BudgetExceededError || err instanceof DelegationError) throw err;
+      throw new DelegationError(agentName, err);
+    }
+    acc.response += r.responseText;
+    acc.toolCalls.push(...r.toolCalls);
+    acc.cost += r.cost;
+    acc.tokens += r.tokens;
+    if (r.finishReason === "error") throw new DelegationError(agentName, r.errorMessage);
+    if (Number.isFinite(budget) && acc.cost > budget) {
+      throw new BudgetExceededError(agentName, acc.cost, budget);
+    }
+    const outcome = {
+      finishReason: r.finishReason,
+      round,
+      toolCalls: r.toolCalls,
+      responseText: r.responseText
+    };
+    const reflectionResult = reflection.reflect(outcome);
+    if (!(reflectionResult.continue && loop.shouldContinue(outcome))) {
+      acc.rounds = round;
+      console.debug("[THEO_AGENT_MAINLOOP_RUNTIME_APPLIED]", {
+        strategy: loop.name,
+        rounds: round
+      });
+      return acc;
+    }
+    feedback = reflectionResult.feedback;
+    round += 1;
+  }
+  acc.rounds = round - 1;
+  return acc;
+}
+__name(runReflectiveLoop, "runReflectiveLoop");
+
+// src/loop/agent-runner.ts
+var AgentRunner = class {
+  static {
+    __name(this, "AgentRunner");
+  }
+  compiled;
+  agentName;
+  loopStrategy;
+  reflectionStrategy;
+  streamEnabled;
+  constructor(compiled, agentName, loopStrategy, reflectionStrategy, streamEnabled) {
+    this.compiled = compiled;
+    this.agentName = agentName;
+    this.loopStrategy = loopStrategy;
+    this.reflectionStrategy = reflectionStrategy;
+    this.streamEnabled = streamEnabled;
+  }
+  /** Start a fluent builder for `AgentClass`. */
+  static builder(AgentClass) {
+    return new AgentRunnerBuilder(AgentClass);
+  }
+  /** Run the agent to a terminal result via the shared reflective loop. */
+  run(message, opts) {
+    const streamFactory = createSdkAgentStream(this.compiled, this.compiled.tools, opts.apiKey, this.compiled.model);
+    const sessionId = opts.sessionId ?? `runner-${crypto.randomUUID()}`;
+    return runReflectiveLoop(streamFactory, message, sessionId, {
+      loop: this.loopStrategy,
+      reflection: this.reflectionStrategy,
+      budget: opts.budget,
+      agentName: this.agentName,
+      signal: opts.signal
+    });
+  }
+};
+var AgentRunnerBuilder = class {
+  static {
+    __name(this, "AgentRunnerBuilder");
+  }
+  AgentClass;
+  reflectionOverride;
+  streamEnabled = true;
+  constructor(AgentClass) {
+    this.AgentClass = AgentClass;
+  }
+  /** Override the default reflection strategy (OCP — plan Drawback #2). No arg ⇒ keep default. */
+  reflection(strategy) {
+    if (strategy) this.reflectionOverride = strategy;
+    return this;
+  }
+  /** Record the streaming preference (see {@link AgentRunner.streamEnabled}). */
+  stream(enabled = true) {
+    this.streamEnabled = enabled;
+    return this;
+  }
+  /** Walk + compile + resolve strategies — the compile→execute boundary (no I/O). */
+  build() {
+    const walk = walkAgentMetadata(this.AgentClass, []);
+    const toolboxInstances = new Map(walk.toolboxes.map((tb) => [
+      tb.class,
+      new tb.class()
+    ]));
+    const compiled = compileAgent(walk, toolboxInstances);
+    const loopStrategy = resolveLoopStrategy(walk.mainLoop.strategy, walk.mainLoop.maxIterations);
+    const reflectionStrategy = this.reflectionOverride ?? (walk.mainLoop.strategy === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
+    return new AgentRunner(compiled, walk.agentConfig.name, loopStrategy, reflectionStrategy, this.streamEnabled);
+  }
+};
+
+// src/bridge/agent-orchestrator.ts
 function requireApiKey(opts, agentName) {
   const apiKey = opts.apiKey ?? "";
   if (!apiKey) {
@@ -599,33 +973,6 @@ function mergeTools(parentTools, subTools) {
   ];
 }
 __name(mergeTools, "mergeTools");
-function processStreamEvent(event, acc, budget, agentName) {
-  if (event.type === "text_delta" && typeof event.content === "string") {
-    acc.response += event.content;
-    return;
-  }
-  if (event.type === "tool_result") {
-    acc.toolCalls.push({
-      name: asString2(event.toolName, "unknown"),
-      input: event.input ?? {},
-      output: asString2(event.output, "")
-    });
-    return;
-  }
-  if (event.type === "done") {
-    acc.cost = asNumber(event.cost, 0);
-    const usage = event.usage;
-    acc.tokens = usage?.totalTokens ?? 0;
-    if (Number.isFinite(budget) && acc.cost > budget) {
-      throw new BudgetExceededError(agentName, acc.cost, budget);
-    }
-    return;
-  }
-  if (event.type === "error") {
-    throw new DelegationError(agentName, asString2(event.message, "Unknown agent error"));
-  }
-}
-__name(processStreamEvent, "processStreamEvent");
 async function delegate(SubAgentClass, message, opts = {}) {
   const apiKey = requireApiKey(opts, SubAgentClass.name);
   const walk = walkAgentMetadata(SubAgentClass, []);
@@ -636,26 +983,17 @@ async function delegate(SubAgentClass, message, opts = {}) {
   const compiled = compileAgent(walk, toolboxInstances);
   const allTools = mergeTools(opts.parentTools ?? [], compiled.tools);
   const budget = Math.min(opts.budget ?? Infinity, opts.parentBudgetRemaining ?? Infinity);
-  const streamFactory = createSdkAgentStream(walk, allTools, apiKey, walk.agentConfig.model);
+  const streamFactory = createSdkAgentStream(compiled, allTools, apiKey, walk.agentConfig.model);
   const sessionId = opts.sessionId ?? `sub-${crypto.randomUUID()}`;
-  const acc = {
-    response: "",
-    toolCalls: [],
-    cost: 0,
-    tokens: 0
-  };
-  try {
-    for await (const event of streamFactory(message, sessionId)) {
-      processStreamEvent(event, acc, budget, SubAgentClass.name);
-    }
-  } catch (err) {
-    if (err instanceof BudgetExceededError || err instanceof DelegationError) throw err;
-    throw new DelegationError(SubAgentClass.name, err);
-  }
-  if (Number.isFinite(budget) && acc.cost > budget) {
-    throw new BudgetExceededError(SubAgentClass.name, acc.cost, budget);
-  }
-  return acc;
+  const loopStrategy = resolveLoopStrategy(walk.mainLoop.strategy, walk.mainLoop.maxIterations);
+  const reflection = loopStrategy.name === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy;
+  return runReflectiveLoop(streamFactory, message, sessionId, {
+    loop: loopStrategy,
+    reflection,
+    budget,
+    agentName: SubAgentClass.name,
+    signal: opts.signal
+  });
 }
 __name(delegate, "delegate");
 
@@ -786,9 +1124,13 @@ __name(matchRoute, "matchRoute");
 export {
   createAgentExecutionContext,
   isAgentContext,
+  compileContextWindow,
+  projectContextMetadataOnlyKnobs,
+  compileProjectContext,
   AgentWarningCode,
   walkAgentMetadata,
   validateUniqueRoutes,
+  compileSkills,
   compileTools,
   compileAgent,
   streamAgentResponse,
@@ -801,10 +1143,18 @@ export {
   generateAgentRoutes,
   translateSdkEvent,
   createSdkAgentStream,
+  DEFAULT_MAX_ITERATIONS,
+  loopStrategyConfigSchema,
+  resolveLoopStrategy,
+  reflectionStrategyConfigSchema,
+  ladderReflectionStrategy,
+  noopReflectionStrategy,
   BudgetExceededError,
   DelegationError,
+  AgentRunner,
+  AgentRunnerBuilder,
   delegate,
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-NC5EE7HN.js.map
+//# sourceMappingURL=chunk-KTYBQ7HY.js.map