@nextclaw/ncp-agent-runtime 0.2.0 → 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>;
     /**

package/dist/index.js

@@ -172,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;
@@ -196,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;
@@ -241,12 +298,22 @@ 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];
@@ -260,13 +327,14 @@ var DefaultNcpStreamEncoder = class {
       }
       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
@@ -514,13 +582,19 @@ function appendToolRoundToInput(input, reasoning, text, toolResults) {
 }
 
 // src/round-collector.ts
+import {
+  normalizeAssistantText
+} from "@nextclaw/ncp";
 var DefaultNcpRoundCollector = class {
-  text = "";
-  reasoning = "";
+  constructor(reasoningNormalizationMode = "off") {
+    this.reasoningNormalizationMode = reasoningNormalizationMode;
+  }
+  rawText = "";
+  explicitReasoning = "";
   toolCallBuffers = /* @__PURE__ */ new Map();
   clear() {
-    this.text = "";
-    this.reasoning = "";
+    this.rawText = "";
+    this.explicitReasoning = "";
     this.toolCallBuffers.clear();
   }
   consumeChunk(chunk) {
@@ -533,11 +607,11 @@ var DefaultNcpRoundCollector = class {
       return;
     }
     if (typeof delta.content === "string" && delta.content.length > 0) {
-      this.text += delta.content;
+      this.rawText += delta.content;
     }
     const reasoning = delta.reasoning_content ?? delta.reasoning;
     if (typeof reasoning === "string" && reasoning.length > 0) {
-      this.reasoning += reasoning;
+      this.explicitReasoning += reasoning;
     }
     const toolDeltas = delta.tool_calls;
     if (!Array.isArray(toolDeltas)) {
@@ -551,10 +625,19 @@ var DefaultNcpRoundCollector = class {
     }
   }
   getText() {
-    return this.text;
+    if (this.reasoningNormalizationMode !== "think-tags") {
+      return this.rawText;
+    }
+    return normalizeAssistantText(this.rawText, this.reasoningNormalizationMode).text;
   }
   getReasoning() {
-    return this.reasoning;
+    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);
@@ -580,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 = {
@@ -622,7 +709,7 @@ var DefaultNcpAgentRuntime = class {
    * The stream encoder does not emit RunFinished; it only converts chunks to NCP events.
    */
   async *runLoop(llmInput, ctx, options) {
-    const roundCollector = new DefaultNcpRoundCollector();
+    const roundCollector = new DefaultNcpRoundCollector(this.reasoningNormalizationMode);
     let currentInput = llmInput;
     let done = false;
     while (!done && !options?.signal?.aborted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-agent-runtime",
-  "version": "0.2.0",
+  "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.3.0"
+    "@nextclaw/ncp": "0.3.1"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",