@agjs/tsforge 0.1.18 → 0.1.19

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "license": "MIT",
   "description": "TypeScript coding harness with a deterministic gate, stack-aware guardrails, and stream-level correction.",
   "repository": {

package/src/browser/oracle.ts

@@ -1,5 +1,18 @@
 import { resolve, dirname, basename, join } from "node:path";
-import { chromium, type Page } from "playwright";
+// `playwright` is an OPTIONAL peer: bundling it (+ a browser binary) into every
+// install is too heavy, so the import is dynamic and the render-check skips when
+// it's absent. The type-only import is erased at runtime, so it can't crash a
+// playwright-less install.
+import type { Page, chromium as Chromium } from "playwright";
+
+/** Load playwright's chromium lazily; null when it isn't installed. */
+async function loadChromium(): Promise<typeof Chromium | null> {
+  try {
+    return (await import("playwright")).chromium;
+  } catch {
+    return null;
+  }
+}
 
 /**
  * The browser oracle — renders a built web page in headless chromium and reports
@@ -50,12 +63,27 @@ export interface IRenderResult {
   ok: boolean;
   /** Human-readable failures (console errors, page errors, missing content). */
   errors: string[];
+  /** True when the check was skipped because playwright isn't installed. */
+  skipped?: boolean;
 }
 
 export async function renderCheck(
   opts: IRenderOptions
 ): Promise<IRenderResult> {
   const errors: string[] = [];
+  const chromium = await loadChromium();
+
+  // No playwright → skip the render check rather than fail the gate. The build
+  // still ran tsc/eslint/build/stub-check; the browser smoke is an enhancement.
+  if (chromium === null) {
+    process.stderr.write(
+      "browser render-check skipped: playwright not installed " +
+        "(run `bunx playwright install chromium` to enable it)\n"
+    );
+
+    return { ok: true, errors: [], skipped: true };
+  }
+
   const browser = await chromium.launch({ args: ["--no-sandbox"] });
 
   try {

package/src/inference/inference.types.ts

@@ -8,6 +8,10 @@ export interface IChatMessage {
   toolCalls?: IToolCall[];
   /** Tool messages only: the id of the call this message is the result of. */
   toolCallId?: string;
+  /** Assistant only: the model's chain-of-thought. DeepSeek's thinking mode
+   *  REQUIRES the prior turn's `reasoning_content` to be replayed, so it's kept
+   *  on the message and re-sent (for the deepseek reasoning style). */
+  reasoningContent?: string;
 }
 
 /** A parsed tool call from the model (name + decoded JSON arguments). */
@@ -29,6 +33,10 @@ export interface ITokenUsage {
 export interface IModelResponse {
   content: string;
   toolCalls: IToolCall[];
+  /** The model's chain-of-thought (`reasoning`/`reasoning_content`), when it
+   *  produced any. Stored on the assistant message for providers (DeepSeek) that
+   *  require it replayed on the next turn. */
+  reasoning?: string;
   /** Server-reported token usage for this call, when available. `promptTokens`
    *  is the full context the model just saw — what auto-compaction will watch. */
   usage?: ITokenUsage;

package/src/inference/request.ts

@@ -99,9 +99,13 @@ export function buildRequestBody(
   const omitTemperature =
     style(cfg) === "openai" || opts.temperature === undefined;
 
+  // DeepSeek's thinking mode requires each prior assistant turn's
+  // `reasoning_content` replayed; other providers don't want it.
+  const includeReasoning = style(cfg) === "deepseek";
+
   return {
     model: cfg.model,
-    messages: messages.map(toWire),
+    messages: messages.map((m) => toWire(m, includeReasoning)),
     ...tokenCapField(cfg),
     ...(omitTemperature ? {} : { temperature: opts.temperature }),
     ...(cfg.repetitionPenalty === undefined

package/src/inference/stream.ts

@@ -35,6 +35,7 @@ export async function streamResponse(
     calls: new Map(),
     guard: new StreamGuard(),
     content: "",
+    reasoning: "",
     ttsr: ttsrManager,
     ttsrFired: null,
   };
@@ -88,6 +89,7 @@ interface IStreamAcc {
   calls: Map<number, IStreamingCall>;
   guard: StreamGuard;
   content: string;
+  reasoning: string;
   usage?: ITokenUsage;
   ttsr?: ITtsrWatcher;
   ttsrFired: { readonly name: string; readonly guidance: string } | null;
@@ -137,6 +139,7 @@ function consumeLines(
     // less, not by hiding it from the log.)
     if (delta.reasoning !== undefined && delta.reasoning.length > 0) {
       onToken(delta.reasoning, "reasoning");
+      acc.reasoning += delta.reasoning;
 
       if (acc.guard.observe(delta.reasoning, "reasoning")) {
         return true;
@@ -163,6 +166,8 @@ function consumeLines(
 
 function assemble(acc: IStreamAcc, degenerated: boolean): IModelResponse {
   const usage = acc.usage === undefined ? {} : { usage: acc.usage };
+  const reasoning =
+    acc.reasoning.length > 0 ? { reasoning: acc.reasoning } : {};
   const toolCalls: IToolCall[] = [...acc.calls.values()].map((c) => ({
     id: c.id,
     name: c.name,
@@ -181,8 +186,21 @@ function assemble(acc: IStreamAcc, degenerated: boolean): IModelResponse {
 
   if (toolCalls.length > 0) {
     return degenerated
-      ? { content: acc.content, toolCalls, degenerated, ...ttsrFired, ...usage }
-      : { content: acc.content, toolCalls, ...ttsrFired, ...usage };
+      ? {
+          content: acc.content,
+          toolCalls,
+          degenerated,
+          ...reasoning,
+          ...ttsrFired,
+          ...usage,
+        }
+      : {
+          content: acc.content,
+          toolCalls,
+          ...reasoning,
+          ...ttsrFired,
+          ...usage,
+        };
   }
 
   const salvaged = salvageToolCalls(acc.content);
@@ -192,6 +210,7 @@ function assemble(acc: IStreamAcc, degenerated: boolean): IModelResponse {
     toolCalls: salvaged,
     salvaged: salvaged.length,
     ...(degenerated ? { degenerated } : {}),
+    ...reasoning,
     ...ttsrFired,
     ...usage,
   };

package/src/loop/run.ts

@@ -366,6 +366,9 @@ export async function runTask(
       role: "assistant",
       content: res.content,
       toolCalls: res.toolCalls,
+      ...(res.reasoning === undefined
+        ? {}
+        : { reasoningContent: res.reasoning }),
     });
 
     // Every model call advances cooldown accounting — including interrupted

package/src/loop/session.ts

@@ -144,6 +144,17 @@ export interface ISendOptions {
 
 const SESSION_ID = "session";
 
+/** Build the assistant history message, carrying `reasoningContent` when the
+ *  model produced it (DeepSeek's thinking mode requires it replayed). */
+function assistantMessage(res: IModelResponse): IChatMessage {
+  return {
+    role: "assistant",
+    content: res.content,
+    toolCalls: res.toolCalls,
+    ...(res.reasoning === undefined ? {} : { reasoningContent: res.reasoning }),
+  };
+}
+
 /** Default share of the context window that triggers auto-compaction. */
 const AUTO_COMPACT_AT = 0.8;
 
@@ -1054,11 +1065,7 @@ export class Session {
       });
     }
 
-    ctx.messages.push({
-      role: "assistant",
-      content: res.content,
-      toolCalls: res.toolCalls,
-    });
+    ctx.messages.push(assistantMessage(res));
 
     if (res.salvaged !== undefined && res.salvaged > 0) {
       report({