@vybestack/llxprt-code-core 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/config/liveTrustTransitionLifecycle.ts

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { DebugLogger } from '../debug/DebugLogger.js';
+import { getErrorMessage } from '../utils/errors.js';
+
+const HOOK_INITIALIZATION_TIMEOUT_MS = 30_000;
+
+export interface LiveTrustTransitionDependencies {
+  downgradeApprovalMode(): void;
+  removeTrustedPolicyRules(): void;
+  updateTrustPolicy(trusted: boolean): void;
+  transitionMcp(trusted: boolean): Promise<void> | undefined;
+  initializeHooks(signal: AbortSignal): Promise<void> | undefined;
+  emitTrustChanged(trusted: boolean): void;
+}
+
+interface TransitionFailure {
+  readonly sequence: number;
+  readonly error: unknown;
+}
+
+export class LiveTrustTransitionLifecycle {
+  private static readonly logger = new DebugLogger(
+    'llxprt:config:live-trust-transition',
+  );
+
+  private transitionChain: Promise<void> = Promise.resolve();
+  private failures: readonly TransitionFailure[] = [];
+  private readonly settlementReports = new Map<number, Promise<void>>();
+  private transitionSequence = 0;
+  private readonly abortController = new AbortController();
+  private disposing = false;
+
+  constructor(private readonly dependencies: LiveTrustTransitionDependencies) {}
+
+  apply(trusted: boolean): Promise<void> {
+    if (this.disposing) {
+      return Promise.resolve();
+    }
+    const sequence = ++this.transitionSequence;
+    if (!trusted) {
+      this.runSynchronousStep(
+        () => this.dependencies.downgradeApprovalMode(),
+        sequence,
+      );
+    }
+    this.runSynchronousStep(
+      () => this.dependencies.removeTrustedPolicyRules(),
+      sequence,
+    );
+    this.runSynchronousStep(
+      () => this.dependencies.updateTrustPolicy(trusted),
+      sequence,
+    );
+    this.enqueue(trusted, sequence);
+    this.runSynchronousStep(
+      () => this.dependencies.emitTrustChanged(trusted),
+      sequence,
+    );
+    const settlement = this.reportTransition(sequence, this.transitionChain);
+    void settlement.catch(() => undefined);
+    return settlement;
+  }
+
+  private runSynchronousStep(step: () => void, sequence: number): void {
+    try {
+      step();
+    } catch (error) {
+      LiveTrustTransitionLifecycle.logger.error(
+        `Trust step failed: ${getErrorMessage(error)}`,
+      );
+      this.retainFailures([error], sequence);
+    }
+  }
+
+  private enqueue(trusted: boolean, sequence: number): void {
+    if (this.disposing) {
+      return;
+    }
+    this.transitionChain = this.transitionChain
+      .catch((error: unknown) => {
+        LiveTrustTransitionLifecycle.logger.error(
+          `Unexpected trust transition chain failure: ${getErrorMessage(error)}`,
+        );
+        this.retainFailures([error], sequence);
+      })
+      .then(() => this.runTransition(trusted, sequence));
+  }
+
+  private async runTransition(
+    trusted: boolean,
+    sequence: number,
+  ): Promise<void> {
+    if (this.disposing) {
+      return;
+    }
+    const failures: unknown[] = [];
+    await this.collectMcpFailure(trusted, failures);
+    await this.collectHookFailure(failures);
+    this.retainFailures(failures, sequence);
+  }
+
+  private async collectMcpFailure(
+    trusted: boolean,
+    failures: unknown[],
+  ): Promise<void> {
+    try {
+      await this.dependencies.transitionMcp(trusted);
+    } catch (error) {
+      LiveTrustTransitionLifecycle.logger.error(
+        `Error during trust transition side-effects: ${getErrorMessage(error)}`,
+      );
+      failures.push(error);
+    }
+  }
+
+  private async collectHookFailure(failures: unknown[]): Promise<void> {
+    if (this.disposing) {
+      return;
+    }
+    try {
+      await waitForHookInitialization(
+        (signal) => this.dependencies.initializeHooks(signal),
+        this.abortController.signal,
+      );
+    } catch (error) {
+      const initializationWasCancelled =
+        this.abortController.signal.aborted &&
+        error instanceof DOMException &&
+        error.name === 'AbortError';
+      if (initializationWasCancelled) {
+        return;
+      }
+      LiveTrustTransitionLifecycle.logger.error(
+        `Error re-initializing hooks during trust transition: ${getErrorMessage(error)}`,
+      );
+      failures.push(error);
+    }
+  }
+
+  private retainFailures(failures: readonly unknown[], sequence: number): void {
+    this.failures = [
+      ...this.failures,
+      ...failures.map((error) => ({ sequence, error })),
+    ];
+  }
+
+  private async reportTransition(
+    sequence: number,
+    transition: Promise<void>,
+  ): Promise<void> {
+    await transition;
+    const failures = this.failures
+      .filter((failure) => failure.sequence === sequence)
+      .map((failure) => failure.error);
+    if (failures.length === 1) {
+      throw failures[0];
+    }
+    if (failures.length > 1) {
+      throw new AggregateError(failures, 'Trust transition failed');
+    }
+  }
+
+  async whenSettled(): Promise<void> {
+    const snapshot = this.transitionSequence;
+    const existingReport = this.settlementReports.get(snapshot);
+    if (existingReport !== undefined) {
+      await existingReport;
+      return;
+    }
+    const report = this.reportSnapshot(snapshot, this.transitionChain);
+    this.settlementReports.set(snapshot, report);
+    try {
+      await report;
+    } finally {
+      if (this.settlementReports.get(snapshot) === report) {
+        this.settlementReports.delete(snapshot);
+      }
+    }
+  }
+
+  private async reportSnapshot(
+    snapshot: number,
+    transition: Promise<void>,
+  ): Promise<void> {
+    await transition;
+    const failures = this.failures
+      .filter((failure) => failure.sequence <= snapshot)
+      .map((failure) => failure.error);
+    this.failures = this.failures.filter(
+      (failure) => failure.sequence > snapshot,
+    );
+    if (failures.length === 1) {
+      throw failures[0];
+    }
+    if (failures.length > 1) {
+      throw new AggregateError(failures, 'Trust transition failed');
+    }
+  }
+
+  beginDisposal(): void {
+    this.disposing = true;
+    this.abortController.abort();
+  }
+}
+
+function abortError(message: string): DOMException {
+  return new DOMException(message, 'AbortError');
+}
+
+function waitForHookInitialization(
+  initialize: (signal: AbortSignal) => Promise<void> | undefined,
+  lifecycleSignal: AbortSignal,
+): Promise<void> {
+  if (lifecycleSignal.aborted) {
+    return Promise.reject(abortError('Hook initialization was cancelled'));
+  }
+  const operationController = new AbortController();
+  return new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const finish = (settle: () => void): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeoutId);
+      lifecycleSignal.removeEventListener('abort', onAbort);
+      settle();
+    };
+    const onAbort = () => {
+      operationController.abort();
+      finish(() => reject(abortError('Hook initialization was cancelled')));
+    };
+    const timeoutId = setTimeout(() => {
+      operationController.abort();
+      finish(() => reject(new Error('Hook initialization timed out')));
+    }, HOOK_INITIALIZATION_TIMEOUT_MS);
+    lifecycleSignal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve()
+      .then(() => initialize(operationController.signal))
+      .then(
+        () => finish(resolve),
+        (error: unknown) => finish(() => reject(error)),
+      );
+  });
+}

package/src/config/schedulerSingleton.ts

@@ -18,16 +18,13 @@ import type {
 import type { MessageBus } from '../confirmation-bus/message-bus.js';
 import type { ToolRegistry } from '@vybestack/llxprt-code-tools';
 import type { EditorType } from '../utils/editor.js';
-import type { AnsiOutput } from '../utils/terminalSerializer.js';
+import type { LiveOutputUpdate } from '../utils/terminalSerializer.js';
 import { DebugLogger } from '../debug/DebugLogger.js';
 
 const debugLog = new DebugLogger('llxprt:schedulerSingleton');
 
 export interface SchedulerCallbacks {
-  outputUpdateHandler?: (
-    toolCallId: string,
-    outputChunk: string | AnsiOutput,
-  ) => void;
+  outputUpdateHandler?: (toolCallId: string, update: LiveOutputUpdate) => void;
   onAllToolCallsComplete?: (
     completedToolCalls: CompletedToolCall[],
   ) => Promise<void>;

package/src/core/compression/types.ts

@@ -9,6 +9,7 @@
  * @plan PLAN-20260211-HIGHDENSITY.P03
  * @plan PLAN-20260211-HIGHDENSITY.P05
  * @plan PLAN-20260218-COMPRESSION-RETRY.P01
+ * @plan PLAN-20260727-ISSUE2602
  * @requirement REQ-CS-001.1, REQ-CS-001.4, REQ-CS-001.5, REQ-CS-001.6, REQ-CS-010.3
  * @requirement REQ-HD-001.1, REQ-HD-001.2, REQ-HD-001.5, REQ-HD-001.8, REQ-HD-001.9, REQ-HD-004.1
  * @requirement REQ-CR-001, REQ-CR-002
@@ -167,6 +168,50 @@ export interface CompressionContext {
   readonly config?: Config;
 }
 
+/**
+ * Well-known reason codes for a structural compression no-op.
+ *
+ * A structural no-op occurs when the strategy's splitting logic
+ * determines it cannot produce a valid compressed candidate without
+ * violating its own invariants (e.g. a four-message minimum middle, or
+ * tool-call boundary integrity). This is distinct from a transient
+ * LLM/provider failure (which is retryable) and from an empty summary
+ * (which is a permanent error).
+ *
+ * @plan PLAN-20260727-ISSUE2602
+ */
+export const STRUCTURAL_NOOP_REASONS = [
+  /**
+   * The middle/compressible region had fewer than the strategy's minimum
+   * compressible messages after the initial split. E.g. MiddleOutStrategy
+   * when `toCompress.length < MINIMUM_MIDDLE_MESSAGES`, OneShotStrategy
+   * when `toCompress.length < MINIMUM_COMPRESS_MESSAGES`.
+   */
+  'too-few-compressible',
+  /**
+   * The compressible region was shrunk below the strategy's minimum by a
+   * later preservation step (last-user-prompt preservation, tool-boundary
+   * adjustment, or density pruning), so the split no longer has enough
+   * messages to summarize safely.
+   */
+  'shrunk-below-minimum',
+  /** The input history was empty. */
+  'empty-history',
+  /**
+   * The input was already at or below the target size, so no truncation
+   * or summarization is structurally possible (used by TopDownTruncation).
+   */
+  'already-under-target',
+  /**
+   * A density-optimization or tail-covering pass determined the whole
+   * history is covered by the preserved tail / no removable unit remains
+   * (used by HighDensity / tail-cover paths).
+   */
+  'tail-covers-all',
+] as const;
+
+export type StructuralNoopReason = (typeof STRUCTURAL_NOOP_REASONS)[number];
+
 /**
  * @plan PLAN-20260211-HIGHDENSITY.P03
  * @requirement REQ-HD-001.1, REQ-HD-001.2
@@ -176,10 +221,19 @@ export interface CompressionStrategy {
   readonly name: CompressionStrategyName;
   readonly requiresLLM: boolean;
   readonly trigger: StrategyTrigger;
-  compress(context: CompressionContext): Promise<CompressionResult>;
+  compress(context: CompressionContext): Promise<StrategyCompressionResult>;
   optimize?(history: readonly IContent[], config: DensityConfig): DensityResult;
 }
 
+/**
+ * @deprecated Superseded by {@link StrategyCompressionResult}.
+ * CompressionStrategy.compress now returns the discriminated union; this
+ * interface is retained only as the shape of the 'applied' variant's payload
+ * and for backward-compatible consumers. New code should use
+ * StrategyCompressionResult.
+ *
+ * @plan PLAN-20260727-ISSUE2602
+ */
 export interface CompressionResult {
   newHistory: IContent[];
   metadata: CompressionResultMetadata;
@@ -197,6 +251,32 @@ export interface CompressionResultMetadata {
   usage?: UsageStats;
 }
 
+/**
+ * Discriminated outcome returned by {@link CompressionStrategy.compress}.
+ *
+ * @plan PLAN-20260727-ISSUE2602
+ *
+ * - `applied`: the strategy produced a real compressed candidate. `newHistory`
+ *   may legitimately differ from the input by only a small amount, but it is
+ *   a genuine compression result, not an unchanged pass-through.
+ * - `noop`: the strategy made a *structural* determination that it could not
+ *   produce a valid compressed candidate and returned the history unchanged.
+ *   Callers must NOT treat this as a successful compression; it is the basis
+ *   for {@link PerformCompressionResult.NOOP} and for middle-out→one-shot
+ *   routing.
+ */
+export type StrategyCompressionResult =
+  | {
+      kind: 'applied';
+      newHistory: IContent[];
+      metadata: CompressionResultMetadata;
+    }
+  | {
+      kind: 'noop';
+      reason: StructuralNoopReason;
+      metadata: CompressionResultMetadata;
+    };
+
 // ---------------------------------------------------------------------------
 // Errors
 // ---------------------------------------------------------------------------

package/src/core/legacy-model-limits.expected.txt

@@ -0,0 +1,96 @@
+{
+  "defaultLimit": 200000,
+  "exactLimits": {
+    "glm-5.2": 200000,
+    "glm-5.1": 200000,
+    "glm-5": 200000,
+    "glm-4.6": 128000,
+    "glm-4.5": 128000,
+    "glm-4": 128000,
+    "gemini-1.5-pro": 2097152,
+    "gemini-1.5-flash": 1048576,
+    "gemini-2.5-pro-preview-05-06": 1048576,
+    "gemini-2.5-pro-preview-06-05": 1048576,
+    "gemini-2.5-pro": 1048576,
+    "gemini-2.5-flash-preview-05-20": 1048576,
+    "gemini-2.5-flash": 1048576,
+    "gemini-2.5-flash-lite": 1048576,
+    "gemini-2.0-flash": 1048576,
+    "gemini-2.0-flash-preview-image-generation": 32000,
+    "claude-opus-5": 200000,
+    "claude-opus-5-latest": 200000,
+    "claude-opus-4-8": 200000,
+    "claude-opus-4-7": 200000,
+    "claude-opus-4-6": 200000,
+    "claude-opus-4-latest": 200000,
+    "claude-sonnet-4-6": 200000,
+    "claude-sonnet-4-latest": 400000,
+    "claude-sonnet-5": 200000,
+    "claude-sonnet-5-latest": 200000,
+    "claude-fable-5": 200000,
+    "claude-fable-5-latest": 200000,
+    "claude-3-7-opus-20250115": 300000,
+    "claude-3-7-sonnet-20250115": 300000,
+    "claude-3-opus-20240229": 200000,
+    "claude-3-sonnet-20240229": 200000,
+    "claude-3-haiku-20240307": 200000,
+    "claude-3.5-sonnet-20240620": 200000,
+    "claude-3.5-sonnet-20241022": 200000,
+    "claude-3.5-haiku-20241022": 200000,
+    "claude-3-5-sonnet-20241022": 200000,
+    "claude-3-5-haiku-20241022": 200000
+  },
+  "prefixLimits": [
+    { "prefix": "gpt-4.1", "limit": 1000000 },
+    { "prefix": "gpt-3.5-turbo", "limit": 16385 },
+    { "prefix": "gemini-2.5-pro", "limit": 1048576 },
+    { "prefix": "gemini-2.5-flash", "limit": 1048576 },
+    { "prefix": "gemini-2.0-flash", "limit": 1048576 },
+    { "prefix": "glm-5", "limit": 200000 },
+    { "prefix": "glm-4", "limit": 128000 }
+  ],
+  "orderedRules": [
+    {
+      "type": "substring",
+      "substring": "codex-spark",
+      "limit": 131072
+    },
+    {
+      "type": "substringOrProviderPrefix",
+      "substring": "codex",
+      "providerPrefix": "codex",
+      "limit": 262144
+    },
+    {
+      "type": "prefixGroup",
+      "prefixes": ["o3-pro", "o3-mini", "o1-mini", "o3", "o1"],
+      "limit": 200000
+    },
+    {
+      "type": "prefixGroup",
+      "prefixes": [
+        "o4-mini",
+        "gpt-4o-mini",
+        "gpt-4o-realtime",
+        "gpt-4o",
+        "gpt-4-turbo"
+      ],
+      "limit": 128000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-sonnet-5",
+      "limit": 200000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-opus-5",
+      "limit": 200000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-fable-5",
+      "limit": 200000
+    }
+  ]
+}

package/src/core/model-limits.json

@@ -0,0 +1,96 @@
+{
+  "defaultLimit": 200000,
+  "exactLimits": {
+    "glm-5.2": 200000,
+    "glm-5.1": 200000,
+    "glm-5": 200000,
+    "glm-4.6": 128000,
+    "glm-4.5": 128000,
+    "glm-4": 128000,
+    "gemini-1.5-pro": 2097152,
+    "gemini-1.5-flash": 1048576,
+    "gemini-2.5-pro-preview-05-06": 1048576,
+    "gemini-2.5-pro-preview-06-05": 1048576,
+    "gemini-2.5-pro": 1048576,
+    "gemini-2.5-flash-preview-05-20": 1048576,
+    "gemini-2.5-flash": 1048576,
+    "gemini-2.5-flash-lite": 1048576,
+    "gemini-2.0-flash": 1048576,
+    "gemini-2.0-flash-preview-image-generation": 32000,
+    "claude-opus-5": 200000,
+    "claude-opus-5-latest": 200000,
+    "claude-opus-4-8": 200000,
+    "claude-opus-4-7": 200000,
+    "claude-opus-4-6": 200000,
+    "claude-opus-4-latest": 200000,
+    "claude-sonnet-4-6": 200000,
+    "claude-sonnet-4-latest": 400000,
+    "claude-sonnet-5": 200000,
+    "claude-sonnet-5-latest": 200000,
+    "claude-fable-5": 200000,
+    "claude-fable-5-latest": 200000,
+    "claude-3-7-opus-20250115": 300000,
+    "claude-3-7-sonnet-20250115": 300000,
+    "claude-3-opus-20240229": 200000,
+    "claude-3-sonnet-20240229": 200000,
+    "claude-3-haiku-20240307": 200000,
+    "claude-3.5-sonnet-20240620": 200000,
+    "claude-3.5-sonnet-20241022": 200000,
+    "claude-3.5-haiku-20241022": 200000,
+    "claude-3-5-sonnet-20241022": 200000,
+    "claude-3-5-haiku-20241022": 200000
+  },
+  "prefixLimits": [
+    { "prefix": "gpt-4.1", "limit": 1000000 },
+    { "prefix": "gpt-3.5-turbo", "limit": 16385 },
+    { "prefix": "gemini-2.5-pro", "limit": 1048576 },
+    { "prefix": "gemini-2.5-flash", "limit": 1048576 },
+    { "prefix": "gemini-2.0-flash", "limit": 1048576 },
+    { "prefix": "glm-5", "limit": 200000 },
+    { "prefix": "glm-4", "limit": 128000 }
+  ],
+  "orderedRules": [
+    {
+      "type": "substring",
+      "substring": "codex-spark",
+      "limit": 131072
+    },
+    {
+      "type": "substringOrProviderPrefix",
+      "substring": "codex",
+      "providerPrefix": "codex",
+      "limit": 262144
+    },
+    {
+      "type": "prefixGroup",
+      "prefixes": ["o3-pro", "o3-mini", "o1-mini", "o3", "o1"],
+      "limit": 200000
+    },
+    {
+      "type": "prefixGroup",
+      "prefixes": [
+        "o4-mini",
+        "gpt-4o-mini",
+        "gpt-4o-realtime",
+        "gpt-4o",
+        "gpt-4-turbo"
+      ],
+      "limit": 128000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-sonnet-5",
+      "limit": 200000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-opus-5",
+      "limit": 200000
+    },
+    {
+      "type": "substringCaseInsensitive",
+      "substring": "claude-fable-5",
+      "limit": 200000
+    }
+  ]
+}

package/src/core/model-limits.schema.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { z } from 'zod';
+
+/**
+ * Zod schema for the data-driven model-limits catalog, validated once at
+ * module init. See model-limits.json for the data.
+ *
+ * Hardening guarantees enforced here:
+ * - All match strings (substrings, provider prefixes, prefix-group entries)
+ *   must be non-empty so a malformed entry can never silently match every
+ *   model.
+ * - Prefix groups must contain at least one entry.
+ * - Every limit is a positive integer.
+ * - The catalog is a strict object: unknown top-level keys are rejected so
+ *   typos like "orderedRule" vs "orderedRules" surface immediately.
+ */
+
+const PositiveLimit = z.number().int().positive();
+
+/** Non-empty string without leading or trailing whitespace. */
+const NonEmptyString = z
+  .string()
+  .refine((value) => value.length > 0 && value === value.trim());
+
+const SubstringRuleSchema = z
+  .object({
+    type: z.literal('substring'),
+    substring: NonEmptyString,
+    limit: PositiveLimit,
+  })
+  .strict();
+
+const SubstringOrProviderPrefixRuleSchema = z
+  .object({
+    type: z.literal('substringOrProviderPrefix'),
+    substring: NonEmptyString,
+    providerPrefix: NonEmptyString,
+    limit: PositiveLimit,
+  })
+  .strict();
+
+const PrefixGroupRuleSchema = z
+  .object({
+    type: z.literal('prefixGroup'),
+    prefixes: z.array(NonEmptyString).min(1),
+    limit: PositiveLimit,
+  })
+  .strict();
+
+/** Case-insensitive substring rule; runtime comparison normalizes both sides. */
+const SubstringCaseInsensitiveRuleSchema = z
+  .object({
+    type: z.literal('substringCaseInsensitive'),
+    substring: NonEmptyString,
+    limit: PositiveLimit,
+  })
+  .strict();
+
+const OrderedRuleSchema = z.discriminatedUnion('type', [
+  SubstringRuleSchema,
+  SubstringOrProviderPrefixRuleSchema,
+  PrefixGroupRuleSchema,
+  SubstringCaseInsensitiveRuleSchema,
+]);
+
+const PrefixLimitSchema = z
+  .object({
+    prefix: NonEmptyString,
+    limit: PositiveLimit,
+  })
+  .strict();
+
+export const ModelLimitsCatalogSchema = z
+  .object({
+    defaultLimit: PositiveLimit,
+    exactLimits: z.record(NonEmptyString, PositiveLimit),
+    prefixLimits: z.array(PrefixLimitSchema),
+    orderedRules: z.array(OrderedRuleSchema),
+  })
+  .strict();
+
+export type ModelLimitsCatalog = z.infer<typeof ModelLimitsCatalogSchema>;