flavor-code 1.3.10 → 1.3.12

package/dist/models/openai.d.ts

@@ -13,11 +13,14 @@ export interface OpenAIModelAdapterOptions {
     client?: OpenAIClient;
     /** Mirror the per-request cache breakdown to stderr. Defaults to FLAVOR_DEBUG_USAGE=1. File logging to usage.jsonl is always on. */
     debugUsage?: boolean;
+    /** Reasoning effort requested from the Responses API; omitted when undefined. */
+    thinkingEffort?: "low" | "medium" | "high";
 }
 export declare class OpenAIModelAdapter implements ModelAdapter {
     #private;
     private readonly client;
     private readonly debugUsage;
+    private readonly thinkingEffort;
     constructor(options: OpenAIModelAdapterOptions);
     stream(request: ModelRequest): AsyncIterable<ModelEvent>;
 }

package/dist/models/structured.d.ts

@@ -11,6 +11,10 @@ export interface StructuredOutputOptions<T> {
     name: string;
     description: string;
     schema: z.ZodType<T>;
+    /** Provider-facing schema when runtime validation was derived from another source (for example MCP). */
+    modelInputSchema?: Record<string, unknown>;
+    /** Preserve the original tool's provider strictness during argument repair. */
+    modelStrict?: boolean;
     retry?: StructuredOutputRetryPolicy;
     beforeAttempt?(attempt: StructuredOutputAttempt): void | Promise<void>;
     afterAttempt?(attempt: StructuredOutputAttemptResult): void | Promise<void>;
@@ -72,6 +76,10 @@ export declare class StructuredOutputError extends Error {
 }
 export declare function withStructuredOutput<T>(options: StructuredOutputOptions<T>): StructuredModel<T>;
 export declare function strictJsonSchema(schema: z.ZodType<unknown>): Record<string, unknown>;
+/** Runtime-facing JSON Schema before provider strictness rewrites optional fields. */
+export declare function jsonSchemaFromZod(schema: z.ZodType<unknown>): Record<string, unknown>;
+/** Recursively adapts an existing JSON Schema for providers that require strict function tools. */
+export declare function strictJsonSchemaObject(schema: Record<string, unknown>): Record<string, unknown>;
 /**
  * Extract the first JSON object or array from free-form model text (plain JSON,
  * fenced ```json blocks, or JSON embedded in prose). Returns undefined when no
@@ -80,10 +88,11 @@ export declare function strictJsonSchema(schema: z.ZodType<unknown>): Record<str
 export declare function extractJsonObject(text: string): unknown;
 /**
  * Best-effort type coercion guided by a JSON schema. Some providers serialize
- * typed fields as strings (`"10"` for an integer). This rewrites string→number /
- * string→boolean where the schema demands those types, recursing into object
- * properties and anyOf branches. Values already matching the schema are
- * returned unchanged, so a valid payload is a no-op.
+ * typed fields as strings (`"10"` for an integer) or collapse a single-item
+ * array to its item (`"main"` instead of `["main"]`). This rewrites those
+ * provider representations where the schema demands another type, recursing
+ * into object properties and anyOf branches. Values already matching the
+ * schema are returned unchanged, so a valid payload is a no-op.
  */
 export declare function coerceByJsonSchema(value: unknown, schema: unknown): unknown;
 export declare function modelToolFromZod(name: string, description: string, schema: z.ZodType<unknown>): ModelTool;

package/dist/models/types.d.ts

@@ -22,12 +22,18 @@ interface ModelMessageMetadata {
     /** Provider-neutral marker for the end of a byte-stable reusable prompt prefix. */
     cacheBreakpoint?: boolean;
 }
+export interface ModelThinkingBlock {
+    text: string;
+    /** Provider-signed integrity token; Anthropic requires it echoed back verbatim. */
+    signature?: string;
+}
 export type ModelMessage = (ModelMessageMetadata & {
     role: "user";
     content: ModelContent;
 }) | (ModelMessageMetadata & {
     role: "system" | "assistant" | "tool";
     content: string;
+    thinkingBlocks?: ModelThinkingBlock[];
 });
 export declare function modelContentText(content: ModelContent): string;
 export declare function modelContentTranscriptText(content: ModelContent): string;
@@ -57,6 +63,19 @@ export interface ProviderError {
 export type ModelEvent = {
     type: "text";
     text: string;
+} | {
+    type: "thinking";
+    text: string;
+}
+/**
+ * Sealed thinking block emitted once per provider thinking block. Carries the
+ * provider signature that must be echoed back verbatim on the next request
+ * when extended thinking is combined with tool use.
+ */
+ | {
+    type: "thinking-block";
+    text: string;
+    signature?: string;
 } | {
     type: "tool-call";
     id: string;

package/dist/production.d.ts

@@ -23,6 +23,8 @@ export interface ProductionRuntimeOptions {
     environment?: NodeJS.ProcessEnv;
     output(event: SessionOutput): void;
     onApprovalChange?(): void;
+    /** Called whenever the active registerTool-managed command set changes. */
+    onToolsChange?(): void;
     /** Non-interactive callers must deny requests instead of waiting for input. */
     approvalPolicy?: "prompt" | "deny";
     /** Allow a protocol host to resolve tool approvals without enabling other interactive UI bridges. */

package/dist/sdk/index.js

@@ -4,7 +4,7 @@ import {
   FlavorRpcServer,
   TraceRecordSchema,
   TraceRecorder
-} from "../chunk-T2ARW6CZ.js";
+} from "../chunk-EZNIDHFZ.js";
 import {
   AgentMessageQueue,
   DockerExecutionEnvironment,
@@ -13,8 +13,8 @@ import {
   WorkspaceCheckpointStore,
   buildDockerInvocation,
   createProductionRuntime
-} from "../chunk-Y3DPUAEJ.js";
-import "../chunk-IG4Z23CL.js";
+} from "../chunk-QC5OYQTB.js";
+import "../chunk-JFKRX2KG.js";
 import "../chunk-RQTYHUMK.js";
 import "../chunk-S32JRDZK.js";
 

package/dist/tools/runtime.d.ts

@@ -61,5 +61,10 @@ export declare class ToolRuntime {
     label(call: ToolCall): string | undefined;
     hint(call: ToolCall): string | undefined;
     execute(call: ToolCall, context: ToolContext): Promise<ToolResult>;
+    /**
+     * Validates a call and applies the same conservative provider-argument
+     * normalization used by the agent loop before falling back to repair.
+     */
+    normalize(call: ToolCall): ToolInputValidation;
     callPresentation(call: ToolCall): import("./types.js").ToolPresentation | undefined;
 }

package/dist/ui/char-width.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Return the display width of a Unicode code point in a fixed-width terminal.
+ *
+ * - 2 for CJK ideographs, fullwidth forms, Hangul, Kana, and most emoji.
+ * - 0 for combining marks, zero-width joiners, and other invisible characters.
+ * - 1 for everything else (ASCII, Latin, Cyrillic, etc.).
+ *
+ * This is a heuristic based on Unicode East Asian Width conventions. It covers
+ * the most common ranges and is intentionally zero-dependency so it stays fast
+ * and reviewable.
+ */
+export declare function charWidth(codePoint: number): number;

package/dist/ui/commands.d.ts

@@ -1,4 +1,4 @@
-export declare const MVP_COMMANDS: readonly ["model", "init", "config", "login", "logout", "permissions", "skills", "plugins", "hooks", "tasks", "finish", "compact", "clear", "help", "exit", "audit", "usage", "loop", "goal", "evolve", "mcp", "commit", "review", "ide", "memory", "remember", "forget", "forget-cold", "checkpoint", "tree", "rewind", "unrevert", "fork", "pals", "chat", "co-work"];
+export declare const MVP_COMMANDS: readonly ["model", "init", "config", "login", "logout", "permissions", "skills", "plugins", "hooks", "tasks", "finish", "compact", "clear", "help", "exit", "audit", "usage", "loop", "goal", "evolve", "mcp", "commit", "review", "ide", "memory", "remember", "forget", "forget-cold", "checkpoint", "tree", "rewind", "unrevert", "fork", "pals", "chat", "co-work", "tool"];
 export declare const COMMAND_DESCRIPTIONS: Record<(typeof MVP_COMMANDS)[number], string>;
 export type PermissionCommandMode = PermissionMode;
 export type ModelRole = "main" | "subagent";
@@ -57,6 +57,10 @@ export type SlashCommand = {
     name: "skill";
     skill: string;
     prompt: string;
+} | {
+    name: "managed-tool";
+    tool: string;
+    input: string;
 } | {
     name: "loop";
     goal: string;
@@ -87,7 +91,7 @@ export type SlashCommand = {
     target: string;
     goal: string;
 } | CoWorkSlashCommand | {
-    name: Exclude<(typeof MVP_COMMANDS)[number], "model" | "permissions" | "audit" | "loop" | "goal" | "evolve" | "commit" | "review" | "mcp" | "remember" | "forget" | "checkpoint" | "rewind" | "fork" | "pals" | "chat" | "co-work">;
+    name: Exclude<(typeof MVP_COMMANDS)[number], "model" | "permissions" | "audit" | "loop" | "goal" | "evolve" | "commit" | "review" | "mcp" | "remember" | "forget" | "checkpoint" | "rewind" | "fork" | "pals" | "chat" | "co-work" | "tool">;
 } | {
     name: "audit";
     toolFilter?: string | undefined;
@@ -103,6 +107,6 @@ export type SlashCommand = {
     command: string;
     message: string;
 };
-export declare function parseSlashCommand(input: string, dynamicCommands?: readonly string[], skillCommands?: readonly string[]): SlashCommand | null;
+export declare function parseSlashCommand(input: string, dynamicCommands?: readonly string[], skillCommands?: readonly string[], managedTools?: readonly string[]): SlashCommand | null;
 import { type PermissionMode } from "../config/schema.js";
 import { type MemoryType } from "../memory/types.js";

package/dist/ui/session.d.ts

@@ -153,6 +153,11 @@ export interface SessionServices {
         description?: string;
     }[];
     runPluginCommand(name: string, args: readonly string[], signal: AbortSignal): Promise<unknown>;
+    managedToolCommands(): readonly {
+        name: string;
+        description?: string;
+    }[];
+    runManagedTool(name: string, input: string, signal: AbortSignal): Promise<unknown>;
     output(event: SessionOutput): void;
     questions: QuestionBridge;
     login(): Promise<string>;

package/dist/ui/thinking-line.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Display model for the streamed thinking line.
+ *
+ * The line occupies a fixed cell width. Text is revealed like a typewriter:
+ * while it fits, the whole text is shown. Once it overflows, the viewport
+ * chases the newest tail — content visibly pushes left. The chase eases so a
+ * burst of tokens does not jerk the line, and it always converges on the tail
+ * so the freshest reasoning stays readable.
+ */
+export declare const THINKING_SCROLL_CELLS_PER_SEC = 16;
+/** Exponential catch-up factor applied to the remaining lag each update. */
+export declare const THINKING_EASE = 0.18;
+/** Caps one update's elapsed time so a paused clock cannot jump the scroll. */
+export declare const THINKING_MAX_STEP_MS = 250;
+/** Cap for stored thinking text per model activity (characters). */
+export declare const THINKING_MAX_STORED_CHARS = 4000;
+export interface ThinkingWindowOptions {
+    /** Visible width in terminal cells. */
+    width: number;
+    /** Milliseconds since the previous update. */
+    dtMs: number;
+    cellsPerSecond?: number;
+    ease?: number;
+}
+export interface ThinkingWindowState {
+    /** The slice to render in the fixed-width slot. */
+    text: string;
+    /** Scroll offset in cells; feed back as `previousStart` next update. */
+    start: number;
+}
+export declare function normalizeThinkingText(text: string): string;
+export declare function thinkingDisplayWidth(text: string): number;
+/** Slice a display-width window out of text; wide chars straddling an edge are kept whole. */
+export declare function sliceThinkingByWidth(text: string, startCell: number, cellCount: number): string;
+/**
+ * Advance the fixed-width viewport toward the newest tail by one update.
+ * `previousStart` carries the scroll position from the last frame so the
+ * movement is rate-limited rather than an instant jump.
+ */
+export declare function thinkingWindow(text: string, previousStart: number, options: ThinkingWindowOptions): ThinkingWindowState;
+/** Append a thinking delta, keeping only the tail of the accumulated text. */
+export declare function appendThinkingText(previous: string | undefined, delta: string): string;

package/dist/ui/transcript.d.ts

@@ -55,6 +55,8 @@ export type TranscriptBlock = {
         role: "main" | "subagent";
     };
     activity?: "model";
+    /** Accumulated streamed thinking text while a model activity is running. */
+    thinkingText?: string;
     presentation?: ToolPresentation;
     tool?: TranscriptToolDetails;
     details?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flavor-code",
-  "version": "1.3.10",
+  "version": "1.3.12",
   "author": "YachuanWzh",
   "type": "module",
   "publishConfig": {