@cuylabs/agent-core 0.5.0 → 0.6.0

package/dist/{chunk-IMGQOTU2.js → chunk-3C4VKG4P.js}

@@ -8,7 +8,7 @@ import {
   buildReasoningOptionsSync
 } from "./chunk-X635CM2F.js";
 
-// src/runtime/observer.ts
+// src/runtime/task/observer.ts
 function defaultAgentTaskCheckpointStrategy(input) {
   switch (input.event.type) {
     case "step-finish":
@@ -26,7 +26,7 @@ function defaultAgentTaskCheckpointStrategy(input) {
   }
 }
 
-// src/runtime/task-runner.ts
+// src/runtime/task/runner.ts
 import { randomUUID } from "crypto";
 
 // src/runtime/turn-state.ts
@@ -197,7 +197,7 @@ function failAgentTurnState(state, error, updatedAt) {
   };
 }
 
-// src/runtime/task-runner.ts
+// src/runtime/task/runner.ts
 function normalizeNonEmpty(value, label) {
   const normalized = value.trim();
   if (!normalized) {
@@ -604,6 +604,7 @@ function prepareModelStep(options) {
     modelMessages,
     llmInput: {
       sessionID: options.sessionId,
+      step: options.step,
       model: options.config.model,
       system: options.systemPrompts,
       messages: modelMessages,
@@ -959,6 +960,101 @@ function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttem
 var OUTPUT_TOKEN_MAX = 32e3;
 
 // src/execution/llm/stream.ts
+function buildModelCallContext(input) {
+  return {
+    sessionID: input.sessionID,
+    step: input.step ?? 1,
+    cwd: input.cwd,
+    abort: input.abort,
+    model: input.model,
+    toolNames: Object.keys(input.tools),
+    mcpToolNames: Object.keys(input.mcpTools ?? {})
+  };
+}
+function buildModelCallInput(input) {
+  return {
+    model: input.model,
+    system: [...input.system],
+    messages: [...input.messages],
+    temperature: input.temperature,
+    topP: input.topP,
+    maxOutputTokens: input.maxOutputTokens,
+    maxSteps: input.maxSteps,
+    reasoningLevel: input.reasoningLevel,
+    telemetry: input.telemetry,
+    customStreamProvider: input.customStreamProvider,
+    toolExecutionMode: input.toolExecutionMode
+  };
+}
+function applyModelCallInput(target, modelCall) {
+  target.model = modelCall.model;
+  target.system = [...modelCall.system];
+  target.messages = [...modelCall.messages];
+  target.temperature = modelCall.temperature;
+  target.topP = modelCall.topP;
+  target.maxOutputTokens = modelCall.maxOutputTokens;
+  target.maxSteps = modelCall.maxSteps;
+  target.reasoningLevel = modelCall.reasoningLevel;
+  target.telemetry = modelCall.telemetry;
+  target.customStreamProvider = modelCall.customStreamProvider;
+  target.toolExecutionMode = modelCall.toolExecutionMode;
+  target.activeModelCall = modelCall;
+}
+function isBlockedModelCall(value) {
+  return "block" in value && value.block === true;
+}
+async function resolveModelCallInput(input) {
+  if (!input.middleware?.hasMiddleware) {
+    const current = buildModelCallInput(input);
+    input.activeModelCall = current;
+    return current;
+  }
+  const next = await input.middleware.runModelInput(
+    buildModelCallInput(input),
+    buildModelCallContext(input)
+  );
+  if (isBlockedModelCall(next)) {
+    return next;
+  }
+  applyModelCallInput(input, next);
+  return next;
+}
+function wrapModelStream(stream2, input) {
+  const normalizedText = Promise.resolve(stream2.text);
+  const normalizedUsage = Promise.resolve(stream2.usage).then((usage) => ({
+    inputTokens: usage.inputTokens ?? 0,
+    outputTokens: usage.outputTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0
+  }));
+  const normalizedFinishReason = Promise.resolve(stream2.finishReason).then(
+    (reason) => String(reason)
+  );
+  if (!input.middleware?.hasMiddleware) {
+    return {
+      fullStream: stream2.fullStream,
+      text: normalizedText,
+      usage: normalizedUsage,
+      finishReason: normalizedFinishReason
+    };
+  }
+  return {
+    fullStream: (async function* () {
+      const ctx = buildModelCallContext(input);
+      for await (const rawChunk of stream2.fullStream) {
+        const chunk = await input.middleware.runModelChunk(
+          rawChunk,
+          ctx
+        );
+        if (chunk) {
+          yield chunk;
+        }
+      }
+    })(),
+    text: normalizedText,
+    usage: normalizedUsage,
+    finishReason: normalizedFinishReason
+  };
+}
 async function createCustomStream(input) {
   const system = input.system.filter(Boolean).join("\n");
   return input.customStreamProvider({
@@ -1033,17 +1129,27 @@ async function callStreamTextWithOtelContext(options) {
 }
 async function stream(input) {
   const messageID = crypto.randomUUID();
+  const resolvedInput = await resolveModelCallInput(input);
+  const modelInfo = getModelInfo(input);
+  if (isBlockedModelCall(resolvedInput)) {
+    throw new LLMError({
+      message: resolvedInput.reason,
+      category: "invalid_request",
+      provider: modelInfo.provider,
+      model: modelInfo.model
+    });
+  }
   const system = input.system.filter(Boolean).join("\n");
   if (input.customStreamProvider) {
     const runCustomStream = async () => await createCustomStream(input);
     if (!input.retry || input.retry.maxAttempts === 0) {
-      return await runCustomStream();
+      return wrapModelStream(await runCustomStream(), input);
     }
-    return await withRetry(
+    return wrapModelStream(await withRetry(
       async () => await runCustomStream(),
       input.retry,
       input.abort
-    );
+    ), input);
   }
   const toolSet = await buildToolSet({
     tools: input.tools,
@@ -1061,7 +1167,6 @@ async function stream(input) {
     ...input.mcpTools ?? {}
   };
   const providerOptions = input.reasoningLevel ? buildReasoningOptionsSync(input.model, input.reasoningLevel) : void 0;
-  const modelInfo = getModelInfo(input);
   const createStream = async () => {
     try {
       return await callStreamTextWithOtelContext({
@@ -1075,13 +1180,13 @@ async function stream(input) {
     }
   };
   if (!input.retry || input.retry.maxAttempts === 0) {
-    return await createStream();
+    return wrapModelStream(await createStream(), input);
   }
-  return await withRetry(
+  return wrapModelStream(await withRetry(
     async () => await createStream(),
     input.retry,
     input.abort
-  );
+  ), input);
 }
 async function streamOnce(input) {
   return await stream({ ...input, retry: void 0 });
@@ -1381,6 +1486,18 @@ async function processStream(stream2, options) {
 }
 
 // src/runtime/turn-runner/stream-step.ts
+function buildModelCallContext2(options) {
+  const input = options.preparedStep.llmInput;
+  return {
+    sessionID: input.sessionID,
+    step: input.step ?? options.preparedStep.step,
+    cwd: input.cwd,
+    abort: input.abort,
+    model: input.model,
+    toolNames: Object.keys(input.tools),
+    mcpToolNames: Object.keys(input.mcpTools ?? {})
+  };
+}
 async function* runModelStep(options) {
   const { preparedStep, turnEngine, applyCommitBatch } = options;
   const stream2 = await LLM.streamStep(preparedStep.llmInput);
@@ -1468,6 +1585,19 @@ async function* runModelStep(options) {
       `Agent step ${preparedStep.step} produced no processor result`
     );
   }
+  if (middleware?.hasMiddleware) {
+    const revised = await middleware.runModelOutput(
+      {
+        text: result.text,
+        usage: result.usage,
+        finishReason: result.finishReason
+      },
+      buildModelCallContext2(options)
+    );
+    result.text = revised.text;
+    result.usage = revised.usage;
+    result.finishReason = revised.finishReason;
+  }
   return result;
 }
 

package/dist/{chunk-OTUGSCED.js → chunk-O2ZCFQL6.js}

@@ -1,4 +1,7 @@
 // src/middleware/runner.ts
+function isBlockedModelCall(value) {
+  return "block" in value && value.block === true;
+}
 var MiddlewareRunner = class {
   stack;
   constructor(middleware = []) {
@@ -17,6 +20,76 @@ var MiddlewareRunner = class {
     return this.stack;
   }
   // --------------------------------------------------------------------------
+  // model.input — array order, first block wins
+  // --------------------------------------------------------------------------
+  async runModelInput(input, ctx) {
+    let current = input;
+    for (const mw of this.stack) {
+      if (!mw.model?.input) continue;
+      try {
+        const next = await mw.model.input(current, ctx);
+        if (!next) continue;
+        if (isBlockedModelCall(next)) {
+          return next;
+        }
+        current = next;
+      } catch (err) {
+        return {
+          block: true,
+          reason: `Middleware "${mw.name}" model input error: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    return current;
+  }
+  // --------------------------------------------------------------------------
+  // model.chunk — array order, streamed transformation
+  // --------------------------------------------------------------------------
+  async runModelChunk(chunk, ctx) {
+    let current = chunk;
+    for (const mw of this.stack) {
+      if (!mw.model?.chunk || current === null) continue;
+      try {
+        const next = await mw.model.chunk(current, ctx);
+        if (next === null) {
+          current = null;
+          continue;
+        }
+        if (next !== void 0) {
+          current = next;
+        }
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" model.chunk error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return current ?? void 0;
+  }
+  // --------------------------------------------------------------------------
+  // model.output — reverse order (innermost first)
+  // --------------------------------------------------------------------------
+  async runModelOutput(output, ctx) {
+    let current = output;
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const mw = this.stack[i];
+      if (!mw.model?.output) continue;
+      try {
+        const next = await mw.model.output(current, ctx);
+        if (next) {
+          current = next;
+        }
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" model.output error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return current;
+  }
+  // --------------------------------------------------------------------------
   // beforeToolCall — array order, first "deny" wins
   // --------------------------------------------------------------------------
   /**

package/dist/{index-p0kOsVsE.d.ts → index-DZQJD_hp.d.ts}

@@ -1,14 +1,14 @@
 import { LanguageModel } from 'ai';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 import { T as Tool } from './tool-pFAnJc5Y.js';
-import { f as AgentMiddleware, P as PromptConfig, A as AgentEvent, M as MiddlewareRunner } from './runner-C7aMP_x3.js';
+import { h as AgentMiddleware, e as StreamProvider, P as PromptConfig, A as AgentEvent, M as MiddlewareRunner } from './runner-G1wxEgac.js';
 import { g as SessionManager, c as SessionContext, f as SessionInfo } from './session-manager-Uawm2Le7.js';
 import { d as ToolHost } from './tool-DYp6-cC3.js';
 import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
 import { a as MCPManager } from './types-VQgymC1N.js';
 import { U as UndoResult, T as TurnChangeTracker } from './tracker-DClqYqTj.js';
-import { P as PromptBuilder } from './builder-RcTZuYnO.js';
-import { x as DoomLoopHandler, Z as StreamProvider, J as PendingIntervention, I as InterventionController, q as AgentTurnStepRuntimeConfig } from './types-MM1JoX5T.js';
+import { P as PromptBuilder } from './builder-BKkipazh.js';
+import { x as DoomLoopHandler, H as PendingIntervention, I as InterventionController, q as AgentTurnStepRuntimeConfig } from './types-BWo810L_.js';
 
 /**
  * Configuration for automatic context compaction.

package/dist/{index-tmhaADz5.d.ts → index-ipP3_ztp.d.ts}

@@ -1,4 +1,4 @@
-import { f as AgentMiddleware } from './runner-C7aMP_x3.js';
+import { h as AgentMiddleware } from './runner-G1wxEgac.js';
 import { TelemetrySettings } from 'ai';
 
 /**

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { P as Preset, A as AppliedPreset, a as Agent } from './index-p0kOsVsE.js';
-export { b as AgentConfig, c as AgentProfile, C as CompactionConfig, D as DEFAULT_MAX_CONCURRENT, d as DEFAULT_MAX_SPAWN_DEPTH, e as DEFAULT_SESSION_TITLE_PREFIX, S as SubAgentCompletedResult, f as SubAgentHandle, g as SubAgentStatus, h as SubAgentToolConfig, i as SubAgentTracker, j as SubAgentUsage, T as TracingConfig, k as createAgent, l as createSubAgentTools } from './index-p0kOsVsE.js';
+import { P as Preset, A as AppliedPreset, a as Agent } from './index-DZQJD_hp.js';
+export { b as AgentConfig, c as AgentProfile, C as CompactionConfig, D as DEFAULT_MAX_CONCURRENT, d as DEFAULT_MAX_SPAWN_DEPTH, e as DEFAULT_SESSION_TITLE_PREFIX, S as SubAgentCompletedResult, f as SubAgentHandle, g as SubAgentStatus, h as SubAgentToolConfig, i as SubAgentTracker, j as SubAgentUsage, T as TracingConfig, k as createAgent, l as createSubAgentTools } from './index-DZQJD_hp.js';
 import { LanguageModel, ToolSet } from 'ai';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 export { a as ReasoningConfig } from './types-CQaXbRsS.js';
-import { E as ErrorCategory, T as ToolExecutionMode, L as LLMStreamInput, A as AnyStreamResult, P as ProcessorOptions, a as ProcessorOutput } from './types-MM1JoX5T.js';
-export { b as AgentTurnActiveToolCall, c as AgentTurnBoundaryMetadata, d as AgentTurnBoundarySnapshot, e as AgentTurnCommitApplier, f as AgentTurnCommitBatch, g as AgentTurnCommitOptions, h as AgentTurnEngine, i as AgentTurnEngineOptions, j as AgentTurnPhase, k as AgentTurnResolvedToolCall, l as AgentTurnState, m as AgentTurnStateAdvanceOptions, n as AgentTurnStepCommitSnapshot, o as AgentTurnStepCommitToolCall, p as AgentTurnStepCommitToolResult, q as AgentTurnStepRuntimeConfig, C as CommitOutputOptions, r as CommitStepOptions, s as CreateAgentTurnStateOptions, t as CreateAgentTurnStepCommitBatchOptions, u as CustomStreamProvider, v as CustomStreamResult, D as DEFAULT_RETRY_CONFIG, w as DoomLoopAction, x as DoomLoopHandler, y as DoomLoopRequest, z as EnhancedTools, I as InterventionController, B as LLMError, F as LLMErrorOptions, G as LLMStreamResult, O as OUTPUT_TOKEN_MAX, H as OnInterventionApplied, J as PendingIntervention, K as PrepareModelStepOptions, M as PreparedAgentModelStep, R as ResponseHeaders, N as RetryConfig, Q as RetryHandlerOptions, S as RetryState, U as RunModelStepOptions, V as RunToolBatchOptions, W as RunToolBatchResult, X as StepInfo, Y as StreamChunk, Z as StreamProvider, _ as StreamProviderConfig, $ as StreamProviderFactory, a0 as StreamProviderInput, a1 as StreamProviderResult, a2 as advanceAgentTurnState, a3 as calculateDelay, a4 as createAgentTurnEngine, a5 as createAgentTurnState, a6 as createRetryHandler, a7 as createRetryState, a8 as failAgentTurnState, a9 as shouldRetry, aa as sleep, ab as withRetry } from './types-MM1JoX5T.js';
-import { M as MiddlewareRunner } from './runner-C7aMP_x3.js';
-export { A as AgentEvent, f as AgentMiddleware, g as AgentStatus, e as AgentTurnBoundaryKind, h as ApprovalEvent, E as EnvironmentInfo, I as InstructionFile, c as ModelFamily, d as ProcessorResult, a as PromptBuildContext, P as PromptConfig, b as PromptSection, S as StreamInput, T as ToolCallDecision } from './runner-C7aMP_x3.js';
+import { E as ErrorCategory, T as ToolExecutionMode, L as LLMStreamInput, A as AnyStreamResult, P as ProcessorOptions, a as ProcessorOutput } from './types-BWo810L_.js';
+export { b as AgentTurnActiveToolCall, c as AgentTurnBoundaryMetadata, d as AgentTurnBoundarySnapshot, e as AgentTurnCommitApplier, f as AgentTurnCommitBatch, g as AgentTurnCommitOptions, h as AgentTurnEngine, i as AgentTurnEngineOptions, j as AgentTurnPhase, k as AgentTurnResolvedToolCall, l as AgentTurnState, m as AgentTurnStateAdvanceOptions, n as AgentTurnStepCommitSnapshot, o as AgentTurnStepCommitToolCall, p as AgentTurnStepCommitToolResult, q as AgentTurnStepRuntimeConfig, C as CommitOutputOptions, r as CommitStepOptions, s as CreateAgentTurnStateOptions, t as CreateAgentTurnStepCommitBatchOptions, u as CustomStreamProvider, v as CustomStreamResult, D as DEFAULT_RETRY_CONFIG, w as DoomLoopAction, x as DoomLoopHandler, y as DoomLoopRequest, I as InterventionController, z as LLMError, B as LLMErrorOptions, F as LLMStreamResult, O as OUTPUT_TOKEN_MAX, G as OnInterventionApplied, H as PendingIntervention, J as PrepareModelStepOptions, K as PreparedAgentModelStep, R as ResponseHeaders, M as RetryConfig, N as RetryHandlerOptions, Q as RetryState, S as RunModelStepOptions, U as RunToolBatchOptions, V as RunToolBatchResult, W as StepInfo, X as advanceAgentTurnState, Y as calculateDelay, Z as createAgentTurnEngine, _ as createAgentTurnState, $ as createRetryHandler, a0 as createRetryState, a1 as failAgentTurnState, a2 as shouldRetry, a3 as sleep, a4 as withRetry } from './types-BWo810L_.js';
+import { M as MiddlewareRunner } from './runner-G1wxEgac.js';
+export { A as AgentEvent, h as AgentMiddleware, i as AgentModelHooks, j as AgentStatus, g as AgentTurnBoundaryKind, k as ApprovalEvent, B as BlockedModelCall, E as EnhancedTools, l as EnvironmentInfo, I as InstructionFile, m as ModelCallContext, f as ModelCallInput, n as ModelCallOutput, c as ModelFamily, d as ProcessorResult, a as PromptBuildContext, P as PromptConfig, b as PromptSection, S as StreamChunk, o as StreamInput, e as StreamProvider, p as StreamProviderConfig, q as StreamProviderFactory, r as StreamProviderInput, s as StreamProviderResult, T as ToolCallDecision } from './runner-G1wxEgac.js';
 import { T as TokenUsage } from './messages-BYWGn8TY.js';
 export { A as AssistantMessage, M as Message, a as MessageBase, b as MessageError, c as MessageRole, S as Session, d as SystemMessage, e as ToolMessage, U as UserMessage } from './messages-BYWGn8TY.js';
 import { T as Tool } from './tool-pFAnJc5Y.js';
@@ -16,7 +16,7 @@ export { D as DirEntry, E as ExecOptions, f as ExecResult, F as FileOperationMet
 export { ContextLimits, ContextManager, DEFAULT_CONTEXT_LIMITS, PruneContextOptions, PruneResult, SummarizationOptions, estimateConversationTokens, estimateMessageTokens, estimateTokens, findCutPoint, generateSummary, isContextOverflowing, pruneContext, pruneToolResults, shouldPruneContext } from './context/index.js';
 export { F as FileBaseline, T as TurnChangeTracker, a as TurnFileChange, b as TurnSummary, c as TurnTrackerConfig, U as UndoResult, d as createTurnTracker } from './tracker-DClqYqTj.js';
 export { DEFAULT_INSTRUCTION_PATTERNS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_FILE_SIZE, PRIORITY_BASE, PRIORITY_CUSTOM, PRIORITY_ENVIRONMENT, PRIORITY_INSTRUCTIONS, PRIORITY_OVERRIDE, PRIORITY_SKILLS, detectModelFamily, discoverInstructions, formatEnvironment, formatInstructions, gatherEnvironment, getAvailableFamilies, getTemplate, loadGlobalInstructions, summarizeEnvironment } from './prompt/index.js';
-export { P as PromptBuilder, c as createPromptBuilder } from './builder-RcTZuYnO.js';
+export { P as PromptBuilder, c as createPromptBuilder } from './builder-BKkipazh.js';
 export { c as ModelCapabilities, d as ModelCapabilityResolver, M as ModelEntry, N as NetworkStatus, P as ProviderCompatibility, R as ResolverOptions, g as configureResolver, h as getDefaultResolver } from './resolver-DOfZ-xuk.js';
 export { g as getModelId, a as getProviderId } from './identifiers-BLUxFqV_.js';
 export { g as getNetworkStatus } from './network-D76DS5ot.js';
@@ -24,8 +24,8 @@ export { b as buildReasoningOptions, a as buildReasoningOptionsSync, g as getRea
 export { B as BranchEntry, C as CompactionEntry, a as CreateSessionOptions, F as FileEntry, M as MessageEntry, b as MetadataEntry, S as STORAGE_VERSION, c as SessionContext, d as SessionEntry, e as SessionHeader, f as SessionInfo, g as SessionManager, h as SessionStorage } from './session-manager-Uawm2Le7.js';
 export { FileStorage, FileStorageOptions, MemoryStorage, buildMessagesFromEntries, configureDefaultSessionManager, deserializeMessage, generateEntryId, getDataDir, getDefaultSessionManager, getLeafId, getProjectSessionsDir, getSessionsDir, parseJSONL, serializeMessage, toJSONL } from './storage/index.js';
 export { AgentTaskChatAdapter, AgentTaskCheckpointReason, AgentTaskCheckpointStrategy, AgentTaskCheckpointStrategyInput, AgentTaskExecutionCheckpoint, AgentTaskExecutionContext, AgentTaskExecutionRun, AgentTaskExecutionSnapshot, AgentTaskObserver, AgentTaskPayload, AgentTaskResult, AgentTaskRunner, AgentTaskRunnerOptions, AgentWorkflowAssistantMessageSnapshot, AgentWorkflowCommitResult, AgentWorkflowMessageSnapshot, AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult, AgentWorkflowOperationPlan, AgentWorkflowOutputCommitPlan, AgentWorkflowReplayDecision, AgentWorkflowStepCommitPlan, AgentWorkflowSystemMessageSnapshot, AgentWorkflowToolBatchResult, AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult, AgentWorkflowToolCallSnapshot, AgentWorkflowToolMessageSnapshot, AgentWorkflowTurnPhase, AgentWorkflowTurnState, AgentWorkflowUserMessageSnapshot, CreateAgentWorkflowTurnStateOptions, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, cloneAgentWorkflowTurnState, commitOutput, commitStep, convertAgentMessagesToModelMessages, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages } from './runtime/index.js';
-import { R as RiskLevel, A as ApprovalConfig, a as ApprovalRule } from './index-tmhaADz5.js';
-export { b as ApprovalAction, c as ApprovalMiddlewareConfig, d as ApprovalRequest, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from './index-tmhaADz5.js';
+import { R as RiskLevel, A as ApprovalConfig, a as ApprovalRule } from './index-ipP3_ztp.js';
+export { b as ApprovalAction, c as ApprovalMiddlewareConfig, d as ApprovalRequest, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from './index-ipP3_ztp.js';
 export { ChangeSet, Checkpoint, CheckpointConfig, CheckpointManager, FileChange, TrackedToolMetadata, clearCheckpoints, createCheckpointManager, extractFilePathsFromArgs, shouldCaptureBaseline, withFileTracking } from './tracking/index.js';
 export { H as HttpTransportConfig, M as MCPConfig, a as MCPManager, b as MCPPrompt, c as MCPResource, d as MCPServerConfig, e as MCPServerStatus, S as SseTransportConfig, f as StdioTransportConfig } from './types-VQgymC1N.js';
 export { createMCPManager, defineServer, httpServer, sseServer, stdioServer } from './mcp/index.js';

package/dist/index.js

@@ -43,7 +43,7 @@ import {
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages,
   withRetry
-} from "./chunk-IMGQOTU2.js";
+} from "./chunk-3C4VKG4P.js";
 import {
   createSkillResourceTool,
   createSkillTool,
@@ -132,7 +132,7 @@ import {
   createTelemetryConfig,
   getToolRisk,
   otelMiddleware
-} from "./chunk-OTUGSCED.js";
+} from "./chunk-O2ZCFQL6.js";
 import {
   createResolver
 } from "./chunk-6TDTQJ4P.js";
@@ -422,7 +422,11 @@ async function* runChatLoop(deps) {
     }
     chatUsage = accumulatedUsage;
     chatOutput = finalStepText || void 0;
-    yield { type: "complete", usage: accumulatedUsage };
+    yield {
+      type: "complete",
+      usage: accumulatedUsage,
+      output: finalStepText || void 0
+    };
   } catch (error) {
     chatError = error instanceof Error ? error : new Error(String(error));
     throw error;
@@ -1819,6 +1823,7 @@ var Agent = class _Agent {
           break;
         case "complete":
           if (event.usage) usage = event.usage;
+          if (event.output !== void 0) response = event.output;
           break;
         case "error":
           throw event.error;

package/dist/middleware/index.d.ts

@@ -1,7 +1,8 @@
-export { f as AgentMiddleware, M as MiddlewareRunner, T as ToolCallDecision } from '../runner-C7aMP_x3.js';
-export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-tmhaADz5.js';
+export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, f as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-G1wxEgac.js';
+export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-ipP3_ztp.js';
 import 'ai';
 import '../messages-BYWGn8TY.js';
 import '../tool-pFAnJc5Y.js';
 import 'zod';
 import '../tool-DYp6-cC3.js';
+import '../types-CQaXbRsS.js';

package/dist/middleware/index.js

@@ -3,7 +3,7 @@ import {
   approvalMiddleware,
   createTelemetryConfig,
   otelMiddleware
-} from "../chunk-OTUGSCED.js";
+} from "../chunk-O2ZCFQL6.js";
 export {
   MiddlewareRunner,
   approvalMiddleware,

package/dist/prompt/index.d.ts

@@ -1,10 +1,11 @@
-import { c as ModelFamily, E as EnvironmentInfo, I as InstructionFile } from '../runner-C7aMP_x3.js';
-export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-C7aMP_x3.js';
+import { c as ModelFamily, l as EnvironmentInfo, I as InstructionFile } from '../runner-G1wxEgac.js';
+export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-G1wxEgac.js';
 import { LanguageModel } from 'ai';
-export { P as PromptBuilder, c as createPromptBuilder } from '../builder-RcTZuYnO.js';
+export { P as PromptBuilder, c as createPromptBuilder } from '../builder-BKkipazh.js';
 export { d as SkillConfig } from '../tool-pFAnJc5Y.js';
 import '../messages-BYWGn8TY.js';
 import '../tool-DYp6-cC3.js';
+import '../types-CQaXbRsS.js';
 import '../registry-CuRWWtcT.js';
 import 'zod';