@punica/editor 1.26.0 → 1.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "Punica Editor",
   "private": false,
   "type": "module",
@@ -56,8 +56,8 @@
   "dependencies": {
     "@punica/common": "^1.0.2",
     "highlight.js": "^11.11.1",
-    "markdown-it": "^14.2.0",
-    "yaml": "^2.4.5"
+    "yaml": "^2.4.5",
+    "markdown-it": "^14.2.0"
   },
   "devDependencies": {
     "@eslint/config-array": "^0.17.0",

package/types/punica.module.kernel.llm.d.ts

@@ -23,6 +23,16 @@ declare module 'punica' {
         maxTokens?: number;
         /** Response format: 'json_object' for structured output, 'text' for free-form */
         responseFormat?: 'json_object' | 'text';
+        /**
+         * How much of `maxTokens` this class may spend on reasoning.
+         *
+         * Absent means `none`, which is what twelve of the fleet's fifteen
+         * classes want: `maxTokens` reaches a local server as `num_predict`
+         * and caps thinking and answer together, so a formatting job that
+         * declares 400 tokens against a reasoning core returns nothing.
+         * Declare `auto` to keep the pre-1.27.0 wire and let the model think.
+         */
+        reasoning?: runtime.LlmReasoningMode;
         /**
          * Preferred model identifier for this instruction class (e.g. 'llama-3.2-8b-instruct-q4_k_m').
          * Used by expert routing to select a single expert model.
@@ -106,6 +116,8 @@ declare module 'punica' {
         options?: {
           temperature?: number;
           maxTokens?: number;
+          /** Per-call override of the class's reasoning mode. */
+          reasoning?: runtime.LlmReasoningMode;
           timeoutMs?: number;
           /** Skip cache lookup (force fresh response) */
           skipCache?: boolean;

package/types/punica.module.runtime.llm.d.ts

@@ -10,6 +10,31 @@ declare module 'punica' {
 
     export type LlmRoutePreference = 'auto' | 'local' | 'remote';
 
+    /**
+     * How much of the output budget a reasoning model may spend on thinking.
+     *
+     * `maxTokens` reaches a local server as `num_predict`, which caps thinking
+     * and answer TOGETHER — so a class that declares a small budget against a
+     * reasoning core spends all of it thinking and returns nothing. Measured
+     * 2026-09-01: a 125-character tutor hint costs 2,138 output tokens on
+     * `qwen3.5:9b`, against a class that declares 400.
+     *
+     * - `none`  — ask the provider not to think. This is the DEFAULT for an
+     *   instruction class that declares nothing, because twelve of the fleet's
+     *   fifteen classes are formatting or extraction jobs.
+     * - `auto`  — send nothing and let the provider decide, which is the wire
+     *   exactly as it was before this field existed.
+     *
+     * There is deliberately no `extended`: no class asks for it today, and a
+     * value that cannot be measured is a claim rather than a capability. It
+     * arrives with the measurement that needs it.
+     *
+     * Only the local route and the `ollama` vendor put anything on the wire
+     * for `none`; for the others "off" is already the default and an
+     * unrecognised argument is an error, so nothing is sent.
+     */
+    export type LlmReasoningMode = 'none' | 'auto';
+
     export interface LlmMessage {
       role: LlmRole;
       content: string;
@@ -136,6 +161,12 @@ declare module 'punica' {
        * loop); translated to vendor syntax host-side.
        */
       cacheHints?: LlmCacheHints;
+      /**
+       * How much of `maxTokens` the provider may spend on reasoning. Absent is
+       * read as `none` by the LLM capability perimeter; a provider adapter
+       * that receives `undefined` sends nothing.
+       */
+      reasoning?: LlmReasoningMode;
     }
 
     export interface LlmUsage {