@nextclaw/ncp-agent-runtime 0.1.1 → 0.2.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NcpContextBuilder, NcpToolRegistry, NcpAgentRunInput, NcpContextPrepareOptions, NcpLLMApiInput, NcpRoundBuffer, NcpToolCallResult, NcpStreamEncoder, OpenAIChatChunk, NcpEncodeContext, NcpEndpointEvent, NcpTool, NcpToolDefinition, NcpLLMApi, NcpLLMApiOptions, NcpAgentRuntime, NcpAgentConversationStateManager, NcpAgentRunOptions } from '@nextclaw/ncp';
+import { NcpContextBuilder, NcpToolRegistry, NcpAgentRunInput, NcpContextPrepareOptions, NcpLLMApiInput, NcpRoundBuffer, NcpToolCallResult, NcpStreamEncoder, NcpAssistantReasoningNormalizationMode, OpenAIChatChunk, NcpEncodeContext, NcpEndpointEvent, NcpTool, NcpToolDefinition, NcpLLMApi, NcpLLMApiOptions, NcpAgentRuntime, NcpAgentConversationStateManager, NcpAgentRunOptions } from '@nextclaw/ncp';
 
 declare class DefaultNcpContextBuilder implements NcpContextBuilder {
     private readonly toolRegistry?;
@@ -24,12 +24,17 @@ declare class DefaultNcpRoundBuffer implements NcpRoundBuffer {
     clear: () => void;
 }
 
+type DefaultNcpStreamEncoderConfig = {
+    reasoningNormalizationMode?: NcpAssistantReasoningNormalizationMode;
+};
 /**
  * Converts LLM stream chunks to NCP events (text, reasoning, tool calls).
  * Does not emit RunFinished; that is the runtime's responsibility after the loop completes.
  */
 declare class DefaultNcpStreamEncoder implements NcpStreamEncoder {
-    encode: (stream: AsyncIterable<OpenAIChatChunk>, context: NcpEncodeContext) => AsyncGenerator<NcpEndpointEvent>;
+    private readonly reasoningNormalizationMode;
+    constructor(config?: DefaultNcpStreamEncoderConfig);
+    encode(stream: AsyncIterable<OpenAIChatChunk>, context: NcpEncodeContext): AsyncGenerator<NcpEndpointEvent>;
 }
 
 declare class DefaultNcpToolRegistry implements NcpToolRegistry {
@@ -52,6 +57,7 @@ type DefaultNcpAgentRuntimeConfig = {
     toolRegistry: NcpToolRegistry;
     stateManager: NcpAgentConversationStateManager;
     streamEncoder?: NcpStreamEncoder;
+    reasoningNormalizationMode?: NcpAssistantReasoningNormalizationMode;
 };
 declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
     private readonly contextBuilder;
@@ -59,6 +65,7 @@ declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
     private readonly toolRegistry;
     private readonly stateManager;
     private readonly streamEncoder;
+    private readonly reasoningNormalizationMode;
     constructor(config: DefaultNcpAgentRuntimeConfig);
     run: (this: DefaultNcpAgentRuntime, input: NcpAgentRunInput, options?: NcpAgentRunOptions) => AsyncGenerator<NcpEndpointEvent>;
     /**
@@ -67,6 +74,7 @@ declare class DefaultNcpAgentRuntime implements NcpAgentRuntime {
      * The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
      */
     private runLoop;
+    private tapStream;
 }
 
 export { DefaultNcpAgentRuntime, type DefaultNcpAgentRuntimeConfig, DefaultNcpContextBuilder, DefaultNcpRoundBuffer, DefaultNcpStreamEncoder, DefaultNcpToolRegistry, EchoNcpLLMApi };

package/dist/index.js

@@ -1,4 +1,35 @@
 // src/context-builder.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function mergeMessageAndRequestMetadata(input) {
+  const messageMetadata = input.messages.slice().reverse().find((message) => isRecord(message.metadata))?.metadata;
+  return {
+    ...isRecord(messageMetadata) ? messageMetadata : {},
+    ...isRecord(input.metadata) ? input.metadata : {}
+  };
+}
+function readRequestedToolNames(metadata) {
+  const raw = metadata.requested_tools ?? metadata.requestedTools ?? metadata.requested_skills ?? metadata.requestedSkills;
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const deduped = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const value = readOptionalString(item);
+    if (value) {
+      deduped.add(value);
+    }
+  }
+  return [...deduped];
+}
 function messageToOpenAI(msg) {
   const role = msg.role;
   const parts = msg.parts ?? [];
@@ -8,8 +39,12 @@ function messageToOpenAI(msg) {
   }
   if (role === "assistant") {
     const texts = [];
+    const reasonings = [];
     const toolInvocations = [];
     for (const p of parts) {
+      if (p.type === "reasoning") {
+        reasonings.push(p.text);
+      }
       if (p.type === "text") {
         texts.push(p.text);
       }
@@ -23,11 +58,13 @@ function messageToOpenAI(msg) {
       }
     }
     const text = texts.join("");
+    const reasoning = reasonings.join("");
     const out = [];
     if (toolInvocations.length > 0) {
       out.push({
         role: "assistant",
         content: text || null,
+        ...reasoning ? { reasoning_content: reasoning } : {},
         tool_calls: toolInvocations.map((t) => ({
           id: t.toolCallId,
           type: "function",
@@ -45,7 +82,11 @@ function messageToOpenAI(msg) {
         });
       }
     } else {
-      out.push({ role: "assistant", content: text });
+      out.push({
+        role: "assistant",
+        content: text,
+        ...reasoning ? { reasoning_content: reasoning } : {}
+      });
     }
     return out;
   }
@@ -59,6 +100,8 @@ var DefaultNcpContextBuilder = class {
     const maxMessages = options?.maxMessages ?? 50;
     const sessionMessages = options?.sessionMessages ?? [];
     const systemPrompt = options?.systemPrompt;
+    const requestMetadata = mergeMessageAndRequestMetadata(input);
+    const requestedToolNames = readRequestedToolNames(requestMetadata);
     const messages = [];
     if (systemPrompt) {
       messages.push({ role: "system", content: systemPrompt });
@@ -69,17 +112,21 @@ var DefaultNcpContextBuilder = class {
     for (const msg of input.messages) {
       messages.push(...messageToOpenAI(msg));
     }
-    const tools = this.toolRegistry ? this.toolRegistry.getToolDefinitions().map((d) => ({
+    const toolDefinitions = this.toolRegistry?.getToolDefinitions() ?? [];
+    const filteredToolDefinitions = requestedToolNames.length > 0 ? toolDefinitions.filter((definition) => requestedToolNames.includes(definition.name)) : toolDefinitions;
+    const tools = filteredToolDefinitions.map((definition) => ({
       type: "function",
       function: {
-        name: d.name,
-        description: d.description,
-        parameters: d.parameters
+        name: definition.name,
+        description: definition.description,
+        parameters: definition.parameters
       }
-    })) : void 0;
+    }));
     return {
       messages,
-      tools: tools && tools.length > 0 ? tools : void 0
+      tools: tools && tools.length > 0 ? tools : void 0,
+      model: readOptionalString(requestMetadata.model) ?? readOptionalString(requestMetadata.llm_model) ?? readOptionalString(requestMetadata.agent_model) ?? void 0,
+      thinkingLevel: readOptionalString(requestMetadata.thinking) ?? readOptionalString(requestMetadata.thinking_level) ?? readOptionalString(requestMetadata.thinkingLevel) ?? readOptionalString(requestMetadata.thinking_effort) ?? readOptionalString(requestMetadata.thinkingEffort) ?? null
     };
   };
 };
@@ -125,6 +172,9 @@ import {
 } from "@nextclaw/ncp";
 
 // src/stream-encoder.utils.ts
+import {
+  NcpAssistantTextStreamNormalizer
+} from "@nextclaw/ncp";
 import { NcpEventType } from "@nextclaw/ncp";
 function getToolCallIndex(toolDelta, fallback) {
   const idx = toolDelta.index;
@@ -149,14 +199,68 @@ function applyToolDelta(current, toolDelta) {
 function* emitTextDeltas(delta, ctx, state) {
   const content = delta.content;
   if (typeof content !== "string" || content.length === 0) return state;
+  if (state.normalizer) {
+    let textStarted = state.textStarted;
+    for (const segment of state.normalizer.push(content)) {
+      if (segment.type === "reasoning") {
+        yield {
+          type: NcpEventType.MessageReasoningDelta,
+          payload: { ...ctx, delta: segment.text }
+        };
+        continue;
+      }
+      if (!textStarted) {
+        yield { type: NcpEventType.MessageTextStart, payload: ctx };
+        textStarted = true;
+      }
+      yield {
+        type: NcpEventType.MessageTextDelta,
+        payload: { ...ctx, delta: segment.text }
+      };
+    }
+    return {
+      ...state,
+      textStarted
+    };
+  }
   if (!state.textStarted) {
     yield { type: NcpEventType.MessageTextStart, payload: ctx };
     yield { type: NcpEventType.MessageTextDelta, payload: { ...ctx, delta: content } };
-    return { textStarted: true };
+    return {
+      ...state,
+      textStarted: true
+    };
   }
   yield { type: NcpEventType.MessageTextDelta, payload: { ...ctx, delta: content } };
   return state;
 }
+function* flushTextDeltas(ctx, state) {
+  if (!state.normalizer) {
+    return state;
+  }
+  let textStarted = state.textStarted;
+  for (const segment of state.normalizer.finish()) {
+    if (segment.type === "reasoning") {
+      yield {
+        type: NcpEventType.MessageReasoningDelta,
+        payload: { ...ctx, delta: segment.text }
+      };
+      continue;
+    }
+    if (!textStarted) {
+      yield { type: NcpEventType.MessageTextStart, payload: ctx };
+      textStarted = true;
+    }
+    yield {
+      type: NcpEventType.MessageTextDelta,
+      payload: { ...ctx, delta: segment.text }
+    };
+  }
+  return {
+    ...state,
+    textStarted
+  };
+}
 function* emitReasoningDelta(delta, ctx) {
   const reasoning = delta.reasoning_content ?? delta.reasoning;
   if (typeof reasoning !== "string" || !reasoning) return;
@@ -194,32 +298,43 @@ function* flushToolCalls(buffers, ctx) {
     };
   }
 }
+function createStreamContentState(reasoningNormalizationMode) {
+  return {
+    textStarted: false,
+    normalizer: reasoningNormalizationMode === "think-tags" ? new NcpAssistantTextStreamNormalizer(reasoningNormalizationMode) : null
+  };
+}
 
 // src/stream-encoder.ts
 var DefaultNcpStreamEncoder = class {
-  encode = async function* (stream, context) {
+  reasoningNormalizationMode;
+  constructor(config = {}) {
+    this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
+  }
+  async *encode(stream, context) {
     const { sessionId, messageId } = context;
-    let state = { textStarted: false };
+    let state = createStreamContentState(this.reasoningNormalizationMode);
     const toolCallBuffers = /* @__PURE__ */ new Map();
     for await (const chunk of stream) {
       const choice = chunk.choices?.[0];
       if (!choice) continue;
       const delta = choice.delta;
       if (delta) {
+        yield* emitReasoningDelta(delta, { sessionId, messageId });
         const nextState = yield* emitTextDeltas(delta, { sessionId, messageId }, state);
         state = nextState;
-        yield* emitReasoningDelta(delta, { sessionId, messageId });
         yield* emitToolCallDeltas(delta, toolCallBuffers, { sessionId, messageId });
       }
       const finishReason = choice.finish_reason;
       if (typeof finishReason === "string" && finishReason.trim().length > 0) {
+        state = yield* flushTextDeltas({ sessionId, messageId }, state);
         yield* flushToolCalls(toolCallBuffers, { sessionId, messageId });
         if (state.textStarted) {
           yield { type: NcpEventType2.MessageTextEnd, payload: { sessionId, messageId } };
         }
       }
     }
-  };
+  }
 };
 
 // src/tool-registry.ts
@@ -296,26 +411,162 @@ import {
 function genId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
 }
-function parseToolArgs(args) {
+function stringifyRawArgs(args) {
   if (typeof args === "string") {
+    return args;
+  }
+  if (args && typeof args === "object" && !Array.isArray(args)) {
     try {
-      return JSON.parse(args);
+      return JSON.stringify(args);
     } catch {
-      return args;
+      return "[unserializable-object]";
     }
   }
-  return args;
+  return String(args ?? "");
 }
-function appendToolRoundToInput(input, text, toolResults) {
+function parseToolArgs(args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    return {
+      ok: true,
+      rawText: stringifyRawArgs(args),
+      value: args
+    };
+  }
+  const rawText = stringifyRawArgs(args);
+  if (typeof args !== "string") {
+    return {
+      ok: false,
+      rawText,
+      issues: ["Tool arguments must be a JSON object string."]
+    };
+  }
+  const trimmed = args.trim();
+  if (!trimmed) {
+    return {
+      ok: false,
+      rawText,
+      issues: ["Tool arguments are empty."]
+    };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        ok: false,
+        rawText,
+        issues: ["Tool arguments JSON must decode to an object."]
+      };
+    }
+    return {
+      ok: true,
+      rawText,
+      value: parsed
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      rawText,
+      issues: [error instanceof Error ? error.message : "Failed to parse tool arguments JSON."]
+    };
+  }
+}
+function validateToolArgs(args, schema) {
+  if (!schema) {
+    return [];
+  }
+  return validateToolValue(args, schema, "");
+}
+function validateToolValue(value, schema, path) {
+  const label = path || "parameter";
+  const type = typeof schema.type === "string" ? schema.type : void 0;
+  if (type && !matchesSchemaType(value, type)) {
+    return [`${label} should be ${type}`];
+  }
+  const errors = [];
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push(`${label} must be one of ${JSON.stringify(schema.enum)}`);
+  }
+  if (typeof value === "number") {
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      errors.push(`${label} must be >= ${schema.minimum}`);
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      errors.push(`${label} must be <= ${schema.maximum}`);
+    }
+  }
+  if (typeof value === "string") {
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      errors.push(`${label} must be at least ${schema.minLength} chars`);
+    }
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+      errors.push(`${label} must be at most ${schema.maxLength} chars`);
+    }
+  }
+  if (type === "object") {
+    const objectValue = value;
+    for (const key of schema.required ?? []) {
+      if (!(key in objectValue)) {
+        errors.push(`missing required ${path ? `${path}.${key}` : key}`);
+      }
+    }
+    const properties = schema.properties ?? {};
+    for (const [key, childValue] of Object.entries(objectValue)) {
+      const childSchema = properties[key];
+      if (!childSchema) {
+        continue;
+      }
+      errors.push(...validateToolValue(childValue, childSchema, path ? `${path}.${key}` : key));
+    }
+  }
+  if (type === "array" && schema.items && Array.isArray(value)) {
+    value.forEach((item, index) => {
+      errors.push(...validateToolValue(item, schema.items, `${label}[${index}]`));
+    });
+  }
+  return errors;
+}
+function matchesSchemaType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "number":
+      return typeof value === "number";
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function createInvalidToolArgumentsResult(params) {
+  return {
+    ok: false,
+    error: {
+      code: "invalid_tool_arguments",
+      message: "Tool arguments are invalid.",
+      toolCallId: params.toolCallId,
+      toolName: params.toolName,
+      rawArgumentsText: params.rawArgumentsText,
+      issues: params.issues
+    }
+  };
+}
+function appendToolRoundToInput(input, reasoning, text, toolResults) {
   const assistantMsg = {
     role: "assistant",
     content: text || null,
+    ...reasoning ? { reasoning_content: reasoning } : {},
     tool_calls: toolResults.map((tr) => ({
       id: tr.toolCallId,
       type: "function",
       function: {
         name: tr.toolName,
-        arguments: typeof tr.args === "string" ? tr.args : JSON.stringify(tr.args ?? {})
+        arguments: tr.rawArgsText
       }
     }))
   };
@@ -330,6 +581,81 @@ function appendToolRoundToInput(input, text, toolResults) {
   };
 }
 
+// src/round-collector.ts
+import {
+  normalizeAssistantText
+} from "@nextclaw/ncp";
+var DefaultNcpRoundCollector = class {
+  constructor(reasoningNormalizationMode = "off") {
+    this.reasoningNormalizationMode = reasoningNormalizationMode;
+  }
+  rawText = "";
+  explicitReasoning = "";
+  toolCallBuffers = /* @__PURE__ */ new Map();
+  clear() {
+    this.rawText = "";
+    this.explicitReasoning = "";
+    this.toolCallBuffers.clear();
+  }
+  consumeChunk(chunk) {
+    const choice = chunk.choices?.[0];
+    if (!choice) {
+      return;
+    }
+    const delta = choice.delta;
+    if (!delta) {
+      return;
+    }
+    if (typeof delta.content === "string" && delta.content.length > 0) {
+      this.rawText += delta.content;
+    }
+    const reasoning = delta.reasoning_content ?? delta.reasoning;
+    if (typeof reasoning === "string" && reasoning.length > 0) {
+      this.explicitReasoning += reasoning;
+    }
+    const toolDeltas = delta.tool_calls;
+    if (!Array.isArray(toolDeltas)) {
+      return;
+    }
+    for (const toolDelta of toolDeltas) {
+      const index = getToolCallIndex(toolDelta, this.toolCallBuffers.size);
+      const previous = this.toolCallBuffers.get(index) ?? { argumentsText: "" };
+      const current = applyToolDelta(previous, toolDelta);
+      this.toolCallBuffers.set(index, current);
+    }
+  }
+  getText() {
+    if (this.reasoningNormalizationMode !== "think-tags") {
+      return this.rawText;
+    }
+    return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).text;
+  }
+  getReasoning() {
+    if (this.explicitReasoning.length > 0) {
+      return this.explicitReasoning;
+    }
+    if (this.reasoningNormalizationMode !== "think-tags") {
+      return "";
+    }
+    return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).reasoning;
+  }
+  getToolCalls() {
+    const orderedEntries = Array.from(this.toolCallBuffers.entries()).sort(([left], [right]) => left - right);
+    const toolCalls = [];
+    for (const [, buffer] of orderedEntries) {
+      if (!buffer.id || !buffer.name) {
+        continue;
+      }
+      toolCalls.push({
+        toolCallId: buffer.id,
+        toolName: buffer.name,
+        args: buffer.argumentsText
+      });
+    }
+    return toolCalls;
+  }
+};
+
 // src/runtime.ts
 var DefaultNcpAgentRuntime = class {
   contextBuilder;
@@ -337,12 +663,16 @@ var DefaultNcpAgentRuntime = class {
   toolRegistry;
   stateManager;
   streamEncoder;
+  reasoningNormalizationMode;
   constructor(config) {
     this.contextBuilder = config.contextBuilder;
     this.llmApi = config.llmApi;
     this.toolRegistry = config.toolRegistry;
     this.stateManager = config.stateManager;
-    this.streamEncoder = config.streamEncoder ?? new DefaultNcpStreamEncoder();
+    this.reasoningNormalizationMode = config.reasoningNormalizationMode ?? "off";
+    this.streamEncoder = config.streamEncoder ?? new DefaultNcpStreamEncoder({
+      reasoningNormalizationMode: this.reasoningNormalizationMode
+    });
   }
   run = async function* (input, options) {
     const ctx = {
@@ -379,55 +709,63 @@ var DefaultNcpAgentRuntime = class {
    * The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
    */
   async *runLoop(llmInput, ctx, options) {
-    const roundBuffer = new DefaultNcpRoundBuffer();
+    const roundCollector = new DefaultNcpRoundCollector(this.reasoningNormalizationMode);
     let currentInput = llmInput;
     let done = false;
     while (!done && !options?.signal?.aborted) {
-      roundBuffer.clear();
+      roundCollector.clear();
       const stream = this.llmApi.generate(currentInput, { signal: options?.signal });
-      for await (const event of this.streamEncoder.encode(stream, ctx)) {
+      const tappedStream = this.tapStream(stream, (chunk) => roundCollector.consumeChunk(chunk));
+      for await (const event of this.streamEncoder.encode(tappedStream, ctx)) {
         yield event;
-        switch (event.type) {
-          case NcpEventType3.MessageToolCallStart:
-            roundBuffer.startToolCall(event.payload.toolCallId, event.payload.toolName);
-            break;
-          case NcpEventType3.MessageToolCallArgs:
-            roundBuffer.appendToolCallArgs(event.payload.args);
-            break;
-          case NcpEventType3.MessageToolCallEnd: {
-            const pending = roundBuffer.consumePendingToolCall();
-            if (pending) {
-              const parsedArgs = parseToolArgs(pending.args);
-              const result = await this.toolRegistry.execute(
-                pending.toolCallId,
-                pending.toolName,
-                parsedArgs
-              );
-              roundBuffer.appendToolCall({
-                toolCallId: pending.toolCallId,
-                toolName: pending.toolName,
-                args: parsedArgs,
-                result
-              });
-              yield {
-                type: NcpEventType3.MessageToolCallResult,
-                payload: {
-                  sessionId: ctx.sessionId,
-                  toolCallId: pending.toolCallId,
-                  content: result
-                }
-              };
-            }
-            break;
+      }
+      const toolResults = [];
+      for (const toolCall of roundCollector.getToolCalls()) {
+        const tool = this.toolRegistry.getTool(toolCall.toolName);
+        const parsedArgs = parseToolArgs(toolCall.args);
+        let result;
+        let args = null;
+        if (!parsedArgs.ok) {
+          result = createInvalidToolArgumentsResult({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            rawArgumentsText: parsedArgs.rawText,
+            issues: parsedArgs.issues
+          });
+        } else {
+          const schemaIssues = validateToolArgs(parsedArgs.value, tool?.parameters);
+          if (schemaIssues.length > 0) {
+            result = createInvalidToolArgumentsResult({
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              rawArgumentsText: parsedArgs.rawText,
+              issues: schemaIssues
+            });
+          } else {
+            args = parsedArgs.value;
+            result = await this.toolRegistry.execute(
+              toolCall.toolCallId,
+              toolCall.toolName,
+              parsedArgs.value
+            );
           }
-          case NcpEventType3.MessageTextDelta:
-            roundBuffer.appendText(event.payload.delta);
-            break;
-          default:
-            break;
         }
+        toolResults.push({
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          args,
+          rawArgsText: parsedArgs.rawText,
+          result
+        });
+        yield {
+          type: NcpEventType3.MessageToolCallResult,
+          payload: {
+            sessionId: ctx.sessionId,
+            toolCallId: toolCall.toolCallId,
+            content: result
+          }
+        };
       }
-      const toolResults = roundBuffer.getToolCalls();
       if (toolResults.length === 0) {
         yield {
           type: NcpEventType3.RunFinished,
@@ -438,11 +776,18 @@ var DefaultNcpAgentRuntime = class {
       }
       currentInput = appendToolRoundToInput(
         currentInput,
-        roundBuffer.getText(),
+        roundCollector.getReasoning(),
+        roundCollector.getText(),
         toolResults
       );
     }
   }
+  async *tapStream(stream, onChunk) {
+    for await (const chunk of stream) {
+      onChunk(chunk);
+      yield chunk;
+    }
+  }
 };
 export {
   DefaultNcpAgentRuntime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-agent-runtime",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "private": false,
   "description": "Default agent runtime implementation built on NCP interfaces.",
   "type": "module",
@@ -15,7 +15,7 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/ncp": "0.2.0"
+    "@nextclaw/ncp": "0.3.1"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",