flavor-code 1.4.0-beta.1 → 1.4.0-beta.10

package/dist/{chunk-URUVFECH.js → chunk-EXOSMO57.js}

@@ -37,9 +37,10 @@ var ProviderConfigSchema = z.object({
   // Defaults to DEFAULT_THINKING_BUDGET; set to 0 to disable the request
   // parameter. Provider thinking deltas are forwarded whenever they arrive.
   thinkingBudget: z.number().int().min(0).optional(),
-  // Reasoning effort requested from the OpenAI Responses protocol. Omitted by
-  // default so strict compatible gateways never see an unknown parameter.
-  thinkingEffort: z.enum(["low", "medium", "high"]).optional(),
+  // Reasoning effort requested from the OpenAI Responses protocol (sent as
+  // reasoning.effort). Omitted by default so strict compatible gateways never
+  // see an unknown parameter and the endpoint uses its server-side default.
+  thinkingEffort: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
   // Send the Claude Code client fingerprint (User-Agent/x-app) with Anthropic requests,
   // for gateways that restrict the Anthropic protocol to Claude clients.
   claudeClient: z.boolean().optional(),
@@ -117,16 +118,20 @@ var FlavorConfigSchema = z.object({
     evaluationTimeoutMs: z.number().int().min(100).max(3e4).default(2e3)
   }).prefault({}),
   maxIterations: z.object({
-    main: z.number().int().min(10).max(500).default(80),
-    subagent: z.number().int().min(10).max(200).default(40),
+    main: z.number().int().min(10).max(500).default(300),
+    subagent: z.number().int().min(10).max(200).default(100),
     softLimitFactor: z.number().min(0.5).max(1).default(0.8),
-    extendBy: z.number().int().min(5).max(100).default(20)
+    extendBy: z.number().int().min(5).max(100).default(50)
   }).prefault({}),
   loop: z.object({
-    maxCycles: z.number().int().positive().max(1e4).default(20),
+    maxCycles: z.number().int().positive().max(1e4).default(100),
     maxTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(5e5),
     isolation: z.literal("auto").default("auto")
   }).prefault({}),
+  goal: z.object({
+    maxRounds: z.number().int().positive().max(1e4).default(100),
+    maxStallStreak: z.number().int().positive().max(100).default(3)
+  }).prefault({}),
   context: z.object({
     windowTokens: z.number().int().positive().default(2e5),
     reservedOutputTokens: z.number().int().nonnegative().default(2e4),

package/dist/chunk-N5MXHJKD.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// src/utils/memory-restart.ts
+import { join } from "path";
+var MEMORY_RESTART_EXIT_CODE = 75;
+var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
+var MEMORY_RESTART_MAX_ATTEMPTS = 24;
+var MEMORY_RESTART_WINDOW_MS = 60 * 60 * 1e3;
+var MEMORY_RESTART_MIN_GAP_MS = 5 * 60 * 1e3;
+var MEMORY_RESTART_CONTINUATION_TTL_MS = 24 * 60 * 60 * 1e3;
+var SESSION_ID_PATTERN = /^session-[A-Za-z0-9_-]+$/u;
+var rotationActive = false;
+function markMemoryRotation() {
+  rotationActive = true;
+}
+function memoryRotationActive() {
+  return rotationActive;
+}
+function memoryRestartMarkerPath(workspace) {
+  return join(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+}
+function nextMemoryRestartMarker(previous, sessionId, now, continuation) {
+  const previousWindowStart = previous?.windowStartedAt ?? previous?.requestedAt;
+  const reusable = previous !== void 0 && previous.sessionId === sessionId && previousWindowStart !== void 0 && now.getTime() - Date.parse(previousWindowStart) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
+  return {
+    sessionId,
+    windowStartedAt: reusable ? previousWindowStart : now.toISOString(),
+    requestedAt: now.toISOString(),
+    attempts: reusable ? previous.attempts + 1 : 1,
+    ...continuation === void 0 ? {} : { continuation }
+  };
+}
+function consumedMemoryRestartMarker(marker) {
+  return {
+    sessionId: marker.sessionId,
+    ...marker.windowStartedAt === void 0 ? {} : { windowStartedAt: marker.windowStartedAt },
+    requestedAt: marker.requestedAt,
+    attempts: marker.attempts
+  };
+}
+function rotationCooldownActive(marker, sessionId, now) {
+  return marker !== void 0 && marker.sessionId === sessionId && now.getTime() - Date.parse(marker.requestedAt) < MEMORY_RESTART_MIN_GAP_MS;
+}
+function pendingContinuation(marker, sessionId, now) {
+  if (marker === void 0 || marker.sessionId !== sessionId) return void 0;
+  if (now.getTime() - Date.parse(marker.requestedAt) > MEMORY_RESTART_CONTINUATION_TTL_MS) return void 0;
+  const continuation = marker.continuation;
+  if (continuation === void 0) return void 0;
+  if (continuation.kind !== "loop" && continuation.kind !== "goal") return void 0;
+  if (typeof continuation.id !== "string" || continuation.id.length === 0) return void 0;
+  return continuation;
+}
+function shouldRelaunchForMemoryRestart(marker) {
+  return marker !== void 0 && SESSION_ID_PATTERN.test(marker.sessionId) && Number.isInteger(marker.attempts) && marker.attempts >= 1 && marker.attempts <= MEMORY_RESTART_MAX_ATTEMPTS;
+}
+function memoryRestartArgs(argv, marker) {
+  if (!shouldRelaunchForMemoryRestart(marker)) return void 0;
+  const stripped = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--resume") {
+      if (index + 1 < argv.length && !argv[index + 1].startsWith("-")) index += 1;
+      continue;
+    }
+    if (argument.startsWith("--resume=")) continue;
+    if (argument === "--memory-restart") continue;
+    stripped.push(argument);
+  }
+  return [...stripped, "--resume", marker.sessionId, "--memory-restart"];
+}
+function parseMemoryRestartMarker(json) {
+  try {
+    const value = JSON.parse(json);
+    if (typeof value.sessionId !== "string" || typeof value.requestedAt !== "string" || typeof value.attempts !== "number") {
+      return void 0;
+    }
+    const continuation = value.continuation;
+    if (continuation !== void 0 && (typeof continuation !== "object" || continuation === null || continuation.kind !== "loop" && continuation.kind !== "goal" || typeof continuation.id !== "string")) {
+      return void 0;
+    }
+    const windowStartedAt = value.windowStartedAt;
+    if (windowStartedAt !== void 0 && typeof windowStartedAt !== "string") return void 0;
+    return {
+      sessionId: value.sessionId,
+      ...windowStartedAt === void 0 ? {} : { windowStartedAt },
+      requestedAt: value.requestedAt,
+      attempts: value.attempts,
+      ...continuation === void 0 ? {} : { continuation }
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  MEMORY_RESTART_EXIT_CODE,
+  markMemoryRotation,
+  memoryRotationActive,
+  memoryRestartMarkerPath,
+  nextMemoryRestartMarker,
+  consumedMemoryRestartMarker,
+  rotationCooldownActive,
+  pendingContinuation,
+  memoryRestartArgs,
+  parseMemoryRestartMarker
+};

package/dist/{chunk-2BF7CVWZ.js → chunk-RAYH6K2H.js}

@@ -28,13 +28,13 @@ function statusPresentation(block, elapsedMs, interactive) {
   if (block.state === "running" && block.activity === "model") {
     return interactive ? {
       glyph: activityFrame(elapsedMs),
-      text: "Flavoring",
+      text: block.text,
       color: "#81c8f2",
       metaLabel: formatElapsed(elapsedMs),
       metaColor: "ansi:blackBright"
     } : {
       glyph: "\xB7",
-      text: "Flavoring",
+      text: block.text,
       color: "#81c8f2"
     };
   }

package/dist/{chunk-FOTMP4ZS.js → chunk-UO4DLWU5.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-6MNOZ2TX.js";
+} from "./chunk-BYHO2CA5.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";
@@ -44,7 +44,13 @@ var FlavorRpcServer = class {
     this.#runtime = await this.#options.createRuntime({
       workspace: this.#options.workspace,
       output: (event) => {
-        void this.#emit({ type: "event", sessionId: this.#runtime?.sessionId, event }, "output");
+        const emitted = this.#emit({ type: "event", sessionId: this.#runtime?.sessionId, event }, "output");
+        if (event.type === "exit") {
+          void emitted.finally(() => {
+            this.#closing = true;
+            this.#lines?.close();
+          });
+        }
       }
     });
     await this.#runtime.session.start();