feat(moonshot): explicit context caching for moonshot-v1 via /v1/caching API by Elarwei001 · Pull Request #25104 · openclaw/openclaw

Elarwei001 · 2026-02-24T05:53:32Z

Summary

Adds explicit context caching support for moonshot-v1-* models via Moonshot's /v1/caching API.

Note: This PR depends on #25436 (K2 cache stats fix) for the usage.ts changes.

Background

Moonshot has two caching mechanisms:

Model Family	Caching Mechanism	This PR
`moonshot-v1-*`	Explicit `/v1/caching` API	✅ Adds wrapper
`kimi-k2.*`	Automatic prefix caching	N/A (handled by #25436)

Changes

New Files

src/agents/moonshot-cache.ts (~280 lines): Cache wrapper with:
- Session-based cache storage with content hash invalidation
- Async IIFE pattern to resolve cache before streaming
- FIFO eviction (max 1000 entries) to prevent memory leak
- Inflight promise coalescing to avoid duplicate cache creation
src/agents/moonshot-cache.test.ts: 17 unit tests
test/moonshot-cache.e2e.test.ts: E2E tests (requires API key)

Modified Files

src/agents/pi-embedded-runner/extra-params.ts: Integration point
src/agents/pi-embedded-runner/run/attempt.ts: Pass sessionKey

Configuration

agents:
  defaults:
    models:
      moonshot/moonshot-v1-32k:
        params:
          contextCache:
            enabled: true
            ttl: 3600

Token Savings

Component	Without Cache	With Cache
System prompt	~2000 tokens	Cached
Tool definitions	~3000 tokens	Cached
Per-request savings		~80%

Design Doc

https://github.com/Elarwei001/research_openclaw/blob/main/proposals/kimi-context-cache.md

Implements lazy context caching for Moonshot/Kimi models using the /v1/caching API. Features: - Cache system prompts and tool definitions to reduce token usage - Automatic cache invalidation when content hash changes - Inflight promise coalescing to prevent duplicate cache creation - TTL auto-renewal via reset_ttl on each request Configuration: ```yaml agents: defaults: models: moonshot/kimi-k2-turbo: params: contextCache: enabled: true ttl: 3600 resetTtl: 3600 ``` Closes openclaw#7073 Co-authored-by: Elar Wei <[email protected]>

greptile-apps

_{3 files reviewed, 3 comments}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-24T05:58:19Z

src/agents/pi-embedded-runner/extra-params.ts

+      onPayload: async (payload) => {
+        if (payload && typeof payload === "object") {
+          const payloadObj = payload as Record<string, unknown>;
+          const payloadMessages = payloadObj.messages;
+
+          if (Array.isArray(payloadMessages)) {
+            try {
+              const cacheId = await getOrCreateCache({
+                sessionKey,
+                apiKey,
+                baseUrl,
+                model: modelId,
+                system: systemContent,
+                tools,
+                ttl,
+              });
+
+              // Replace messages with cache-injected version
+              payloadObj.messages = injectCacheRole(
+                payloadMessages as Array<{ role: string; content: unknown }>,
+                cacheId,
+                resetTtl,
+              );
+
+              log.debug(`[moonshot-cache] Injected cache ${cacheId} for session ${sessionKey}`);
+            } catch (err) {
+              // On cache error, fall back to normal request
+              log.warn(`[moonshot-cache] Cache error, falling back: ${String(err)}`);
+            }
+          }
+        }
+        originalOnPayload?.(payload);
+      },
+    });


Async onPayload will not work — cache injection is a no-op

onPayload is called synchronously by pi-ai and every existing caller in this codebase (options?.onPayload?.(payload) — no await). Making onPayload async means the await getOrCreateCache(...) runs in a detached microtask. By the time the cache ID is retrieved and payloadObj.messages is mutated, the request body has already been serialized and sent to the API.

This effectively makes the entire caching feature a no-op in production — the message array will never contain the cache role when the HTTP request is dispatched.

Every other onPayload wrapper in this file (createOpenAIResponsesStoreWrapper, createOpenRouterWrapper, createZaiToolStreamWrapper, createOpenRouterSystemCacheWrapper) is synchronous for exactly this reason.

To fix this, the cache should be resolved before calling the underlying streamFn, and the cache role should be injected into context.messages synchronously — not inside onPayload. The wrapper's outer function should be async, resolve the cache up front, mutate the context messages, and then call the underlying stream function with the modified context. This would require verifying that pi-ai supports an async StreamFn return type.

Prompt To Fix With AI

This is a comment left during a code review. Path: src/agents/pi-embedded-runner/extra-params.ts Line: 589-622 Comment: **Async `onPayload` will not work — cache injection is a no-op** `onPayload` is called synchronously by pi-ai and every existing caller in this codebase (`options?.onPayload?.(payload)` — no `await`). Making `onPayload` `async` means the `await getOrCreateCache(...)` runs in a detached microtask. By the time the cache ID is retrieved and `payloadObj.messages` is mutated, the request body has already been serialized and sent to the API. This effectively makes the entire caching feature a no-op in production — the message array will never contain the cache role when the HTTP request is dispatched. Every other `onPayload` wrapper in this file (`createOpenAIResponsesStoreWrapper`, `createOpenRouterWrapper`, `createZaiToolStreamWrapper`, `createOpenRouterSystemCacheWrapper`) is synchronous for exactly this reason. To fix this, the cache should be resolved *before* calling the underlying `streamFn`, and the cache role should be injected into `context.messages` synchronously — not inside `onPayload`. The wrapper's outer function should be `async`, resolve the cache up front, mutate the context messages, and then call the underlying stream function with the modified context. This would require verifying that pi-ai supports an async `StreamFn` return type. How can I resolve this? If you propose a fix, please make it concise.

src/agents/moonshot-cache.ts

SamuelHinestrosa

Revisión automática: Cambios revisados. Por favor asegurar que los tests pasan.

- Fix async onPayload race condition by resolving cache BEFORE streaming - Add MAX_CACHE_SIZE (1000) with FIFO eviction to prevent memory leaks - Clear local cache entry immediately after remote deletion to prevent stale entries

- Use async IIFE instead of async generator (StreamFn supports Promise return) - Cast modified messages to context.messages type to avoid pi-ai Message mismatch

The caching API requires base model names (e.g., 'moonshot-v1') without context-length suffixes. Add toCacheModelName() to handle the mapping.

Moonshot/Kimi returns 'cached_tokens' instead of 'cache_read_input_tokens'. This ensures OpenClaw's cacheRead field is properly populated when using Moonshot context caching.

… invasion Reduces extra-params.ts changes from ~135 lines to ~20 lines. All Moonshot-specific logic is now isolated in moonshot-cache.ts.

- Remove unused clearSessionCache function - Simplify comments and remove section dividers - Inline simple functions - Reduce verbosity while maintaining functionality

Elarwei001 · 2026-02-24T07:44:51Z

@greptile-apps please re-review - code has been refactored to address previous feedback:

Fixed async onPayload race condition (now resolves cache before streaming)
Added MAX_CACHE_SIZE with FIFO eviction
Clear local entry before remote deletion to prevent stale entries
Moved wrapper to moonshot-cache.ts to reduce extra-params.ts invasion (135 → 20 lines)
Simplified code (434 → 325 lines)

Elarwei001 · 2026-02-24T07:49:22Z

AI-Assisted Testing Results

Tested with a real Moonshot API account to verify the caching mechanism works correctly.

Test 1: Baseline (without cache)

POST /v1/chat/completions
{
  "model": "moonshot-v1-32k",
  "messages": [
    {"role": "system", "content": "<system prompt>"},
    {"role": "user", "content": "What is 2+2?"}
  ]
}

Response usage:

{
  "prompt_tokens": 48,
  "completion_tokens": 8,
  "total_tokens": 56
}

Test 2: With cache

# Step 1: Create cache
POST /v1/caching
{
  "model": "moonshot-v1",
  "messages": [{"role": "system", "content": "<system prompt>"}],
  "ttl": 300
}
# Returns: {"id": "cache-xxx", "tokens": 19, "status": "pending"}

# Step 2: Query with cache
POST /v1/chat/completions
{
  "model": "moonshot-v1-32k",
  "messages": [
    {"role": "cache", "content": "cache_id=cache-xxx;reset_ttl=300"},
    {"role": "user", "content": "What is 2+2?"}
  ]
}

Response usage:

{
  "prompt_tokens": 30,
  "completion_tokens": 9,
  "total_tokens": 39,
  "cached_tokens": 19,
  "prompt_tokens_details": {
    "cached_tokens": 19
  }
}

Key Findings

Metric	Without Cache	With Cache
prompt_tokens	48	30
cached_tokens	-	19 ✅

Cache creation works: API returns cache ID and token count
Cache injection works: role: "cache" is accepted by the API
Usage reflects caching: cached_tokens field shows cache hit count
Token savings confirmed: prompt_tokens reduced when using cache

Model Name Mapping

Discovered that the caching API requires base model names:

moonshot-v1-32k → moonshot-v1 (for cache creation)
Query can still use moonshot-v1-32k

This is handled by toCacheModelName() in the implementation.

greptile-apps

_{6 files reviewed, 2 comments}

_{Edit Code Review Agent Settings | Greptile}

src/agents/moonshot-cache.ts

greptile-apps · 2026-02-24T07:52:35Z

src/agents/moonshot-cache.ts

+    return (async () => {
+      let modifiedContext = context;
+
+      try {
+        const cacheId = await getOrCreateCache({
+          sessionKey,
+          apiKey,
+          baseUrl,
+          model: modelId,
+          system: systemContent,
+          tools,
+          ttl,
+        });
+
+        // Inject cache role into messages, replacing system message.
+        // Cast to context.messages type to avoid pi-ai's stricter Message type.
+        const modifiedMessages = injectCacheRole(
+          messages,
+          cacheId,
+          resetTtl,
+        ) as unknown as typeof context.messages;
+
+        modifiedContext = {
+          ...context,
+          messages: modifiedMessages,
+        };
+
+        log.debug(`[moonshot-cache] Injected cache ${cacheId} for session ${sessionKey}`);
+      } catch (err) {
+        // On cache error, fall back to normal request with original context
+        log.warn(`[moonshot-cache] Cache error, falling back: ${String(err)}`);
+      }
+
+      // Delegate to underlying stream with (possibly modified) context
+      return baseStreamFn(model, modifiedContext, options);
+    })();


Async IIFE returns Promise — incompatible with downstream wrappers

This returns Promise<EventStream> instead of EventStream. Every other StreamFn wrapper in the codebase (createOpenRouterWrapper, createBedrockNoCacheWrapper, createOpenAIResponsesStoreWrapper, etc.) returns the stream synchronously.

After createMoonshotCacheWrapper, createOpenAIResponsesStoreWrapper is applied at extra-params.ts:598. That wrapper calls underlying(model, context, options) and may attempt to use the return value as an EventStream rather than awaiting a Promise. Additionally, the wrappers installed in attempt.ts (lines 760, 786) pass through inner(model, context, options) without await, propagating the Promise up to pi-ai's agent loop.

Whether this actually causes a runtime failure depends on how @mariozechner/pi-ai consumes the streamFn return value internally. If it awaits or handles thenables, this works. If it expects a synchronous EventStream (like createOllamaStreamFn returns via createAssistantMessageEventStream()), this will fail at runtime.

The safer pattern used by createOllamaStreamFn is to create the event stream synchronously, queue the async work via queueMicrotask, and return the stream immediately.

Prompt To Fix With AI

This is a comment left during a code review. Path: src/agents/moonshot-cache.ts Line: 296-331 Comment: **Async IIFE returns `Promise` — incompatible with downstream wrappers** This returns `Promise<EventStream>` instead of `EventStream`. Every other `StreamFn` wrapper in the codebase (`createOpenRouterWrapper`, `createBedrockNoCacheWrapper`, `createOpenAIResponsesStoreWrapper`, etc.) returns the stream synchronously. After `createMoonshotCacheWrapper`, `createOpenAIResponsesStoreWrapper` is applied at `extra-params.ts:598`. That wrapper calls `underlying(model, context, options)` and may attempt to use the return value as an `EventStream` rather than awaiting a `Promise`. Additionally, the wrappers installed in `attempt.ts` (lines 760, 786) pass through `inner(model, context, options)` without `await`, propagating the `Promise` up to pi-ai's agent loop. Whether this actually causes a runtime failure depends on how `@mariozechner/pi-ai` consumes the `streamFn` return value internally. If it awaits or handles thenables, this works. If it expects a synchronous `EventStream` (like `createOllamaStreamFn` returns via `createAssistantMessageEventStream()`), this will fail at runtime. The safer pattern used by `createOllamaStreamFn` is to create the event stream synchronously, queue the async work via `queueMicrotask`, and return the stream immediately. How can I resolve this? If you propose a fix, please make it concise.

sessionKey is not part of SimpleStreamOptions from pi-ai, so it was always undefined when read from options. Now sessionKey is passed as a parameter to createMoonshotCacheWrapper and captured via closure. Fixes Greptile review comment about caching always being skipped.

Tests verify: - Cache role is injected when sessionKey is provided via closure - Caching is skipped when apiKey is missing - Graceful fallback on cache creation error This ensures the OpenClaw integration path works correctly, not just direct API calls.

Tests require MOONSHOT_API_KEY env var and make real API calls: - creates cache and returns cache_id - returns same cache_id for same content (cache hit) - creates new cache when content changes (cache invalidation) - chat completion with cache shows reduced prompt_tokens - wrapper integration modifies context correctly Tests are skipped in CI when API key is not available. Run locally with: MOONSHOT_API_KEY=sk-xxx pnpm vitest run --config vitest.e2e.config.ts test/agents/moonshot-cache.e2e.test.ts

Elarwei001 · 2026-02-24T08:37:05Z

@greptile-apps please re-review - all previous issues have been addressed:

✅ Async onPayload race condition - Fixed by using async IIFE that resolves cache before streaming
✅ Unbounded maps memory leak - Added MAX_CACHE_SIZE (1000) with FIFO eviction
✅ Stale cacheStore entry - Clear local entry before remote deletion
✅ sessionKey not in options - Now passed via closure at wrapper creation time
✅ Async IIFE Promise return - StreamFn type allows Promise<stream>, verified working

Additional improvements:

Added real e2e tests (run with MOONSHOT_API_KEY=xxx)
Reduced code invasion: extra-params.ts only +20 lines
All CI checks passing

greptile-apps

_{8 files reviewed, 4 comments}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-24T08:40:40Z

src/agents/moonshot-cache.ts

+      // Delete old cache if exists and clear local entry immediately
+      // This prevents stale entries if createCache fails after deletion
+      if (existing) {
+        cacheStore.delete(params.sessionKey);


Fixed stale cache issue by deleting local entry immediately after invalidation detection, before attempting remote deletion and recreation

Prompt To Fix With AI

This is a comment left during a code review. Path: src/agents/moonshot-cache.ts Line: 161 Comment: Fixed stale cache issue by deleting local entry immediately after invalidation detection, before attempting remote deletion and recreation How can I resolve this? If you propose a fix, please make it concise.

greptile-apps · 2026-02-24T08:40:41Z

src/agents/moonshot-cache.ts

+    return (async () => {
+      let modifiedContext = context;
+
+      try {
+        const cacheId = await getOrCreateCache({
+          sessionKey,
+          apiKey,
+          baseUrl,
+          model: modelId,
+          system: systemContent,
+          tools,
+          ttl,
+        });
+
+        // Inject cache role into messages, replacing system message.
+        // Cast to context.messages type to avoid pi-ai's stricter Message type.
+        const modifiedMessages = injectCacheRole(
+          messages,
+          cacheId,
+          resetTtl,
+        ) as unknown as typeof context.messages;
+
+        modifiedContext = {
+          ...context,
+          messages: modifiedMessages,
+        };
+
+        log.debug(`[moonshot-cache] Injected cache ${cacheId} for session ${sessionKey}`);
+      } catch (err) {
+        // On cache error, fall back to normal request with original context
+        log.warn(`[moonshot-cache] Cache error, falling back: ${String(err)}`);
+      }
+
+      // Delegate to underlying stream with (possibly modified) context
+      return baseStreamFn(model, modifiedContext, options);
+    })();


Resolved cache asynchronously before calling baseStreamFn to avoid the async onPayload race condition from the previous implementation. The async IIFE returns Promise<EventStream>, which differs from other synchronous wrappers in extra-params.ts (createOpenRouterWrapper, createBedrockNoCacheWrapper). Verify this pattern is supported by @mariozechner/pi-ai in production - the e2e tests pass but this should be validated in real gateway scenarios.

Prompt To Fix With AI

This is a comment left during a code review. Path: src/agents/moonshot-cache.ts Line: 294-329 Comment: Resolved cache asynchronously before calling `baseStreamFn` to avoid the async `onPayload` race condition from the previous implementation. The async IIFE returns `Promise<EventStream>`, which differs from other synchronous wrappers in `extra-params.ts` (`createOpenRouterWrapper`, `createBedrockNoCacheWrapper`). Verify this pattern is supported by `@mariozechner/pi-ai` in production - the e2e tests pass but this should be validated in real gateway scenarios. How can I resolve this? If you propose a fix, please make it concise.

The async IIFE returning Promise is supported by the StreamFn type definition in @mariozechner/pi-agent-core:

export type StreamFn = (...) => ReturnType<typeof streamSimple> | Promise<ReturnType<typeof streamSimple>>;

This pattern is explicitly designed for async config lookup scenarios like our cache resolution, so it should be fine.

greptile-apps · 2026-02-24T08:40:42Z

src/agents/pi-embedded-runner/extra-params.ts

+      agent.streamFn = createMoonshotCacheWrapper(
+        agent.streamFn ?? streamSimple,
+        moonshotCacheConfig!,
+        modelId,
+        sessionKey,
+      );


Fixed previous issue where sessionKey was unavailable - now passed via closure to createMoonshotCacheWrapper from attempt.ts:744 instead of being extracted from options at call time

Prompt To Fix With AI

This is a comment left during a code review. Path: src/agents/pi-embedded-runner/extra-params.ts Line: 588-593 Comment: Fixed previous issue where `sessionKey` was unavailable - now passed via closure to `createMoonshotCacheWrapper` from `attempt.ts:744` instead of being extracted from `options` at call time How can I resolve this? If you propose a fix, please make it concise.

greptile-apps · 2026-02-24T08:40:48Z

Additional Comments (1)

src/agents/usage.ts
Added Moonshot/Kimi's cached_tokens field to normalize cache read counts alongside the standard OpenAI cache_read_input_tokens

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/agents/usage.ts
Line: 969-971

Comment:
Added Moonshot/Kimi's `cached_tokens` field to normalize cache read counts alongside the standard OpenAI `cache_read_input_tokens`

How can I resolve this? If you propose a fix, please make it concise.

- Handle moonshot-v1-* → moonshot-v1 - Handle kimi-k2-* → kimi-k2 - Pass through kimi-k2.5, kimi-latest as-is - Add toCacheModelName tests

Tested with real API - kimi-k2.5, kimi-k2, kimi-latest all return 400 'model family is invalid'. Only moonshot-v1 supports caching. - toCacheModelName returns undefined for unsupported models - Wrapper skips caching entirely for unsupported models - Updated tests to reflect actual API behavior

Kimi K2 models use automatic prefix caching (like Anthropic) and return cached_tokens in prompt_tokens_details field. This differs from moonshot-v1 which requires explicit /v1/caching API. - Add prompt_tokens_details.cached_tokens to UsageLike type - Update normalizeUsage to extract nested cached_tokens - Add test for K2 usage format

Better reflects the function's purpose: checking if a model requires explicit /v1/caching API calls vs automatic prefix caching (K2).

- Hide model name implementation detail (MOONSHOT_V1_CACHE_MODEL is internal) - Cleaner API: returns true/false instead of string/undefined

Elarwei001 · 2026-02-24T15:01:16Z

Closing this PR for now since moonshot-v1 is a legacy model (released Oct 2023) and most users should prefer the newer K2 series which has automatic prefix caching built-in.

If anyone has a specific need for explicit caching on moonshot-v1, feel free to cherry-pick from this branch or request to reopen this PR.

See the analysis in issue #7073 for details on the two different caching mechanisms.

openclaw-barnacle bot added agents Agent runtime and tooling size: L labels Feb 24, 2026

greptile-apps bot reviewed Feb 24, 2026

View reviewed changes

SamuelHinestrosa suggested changes Feb 24, 2026

View reviewed changes

fix: address Greptile review feedback

e58bed6

- Fix async onPayload race condition by resolving cache BEFORE streaming - Add MAX_CACHE_SIZE (1000) with FIFO eviction to prevent memory leaks - Clear local cache entry immediately after remote deletion to prevent stale entries

openclaw-barnacle bot added the scripts Repository scripts label Feb 24, 2026

Elarwei001 added 5 commits February 24, 2026 14:22

fix: correct type issues in moonshot cache wrapper

6f30b22

- Use async IIFE instead of async generator (StreamFn supports Promise return) - Cast modified messages to context.messages type to avoid pi-ai Message mismatch

fix: map model names for caching API compatibility

46a60a8

The caching API requires base model names (e.g., 'moonshot-v1') without context-length suffixes. Add toCacheModelName() to handle the mapping.

feat: add support for Moonshot cached_tokens in usage parsing

c02698c

Moonshot/Kimi returns 'cached_tokens' instead of 'cache_read_input_tokens'. This ensures OpenClaw's cacheRead field is properly populated when using Moonshot context caching.

refactor: move wrapper to moonshot-cache.ts to reduce extra-params.ts…

3e9ae7d

… invasion Reduces extra-params.ts changes from ~135 lines to ~20 lines. All Moonshot-specific logic is now isolated in moonshot-cache.ts.

refactor: simplify moonshot-cache.ts (434 -> 325 lines)

76dac6c

- Remove unused clearSessionCache function - Simplify comments and remove section dividers - Inline simple functions - Reduce verbosity while maintaining functionality

greptile-apps bot reviewed Feb 24, 2026

View reviewed changes

Elarwei001 added 3 commits February 24, 2026 15:57

openclaw-barnacle bot added size: XL and removed size: L labels Feb 24, 2026

Elarwei001 added 2 commits February 24, 2026 16:21

fix: cast model objects in tests to satisfy StreamFn type

95bb11d

fix: cast context via unknown to satisfy strict types

6b38008

greptile-apps bot reviewed Feb 24, 2026

View reviewed changes

Elarwei001 mentioned this pull request Feb 24, 2026

[Feature]: Support Kimi K2.5 Cache #7073

Closed

Elarwei001 added 2 commits February 24, 2026 18:39

fix: move e2e test to test/ root (match existing pattern)

804c370

chore: remove manual test script (not needed in PR)

04d2027

openclaw-barnacle bot removed scripts Repository scripts size: XL labels Feb 24, 2026

openclaw-barnacle bot added the size: L label Feb 24, 2026

Elarwei001 mentioned this pull request Feb 24, 2026

Refactor: Provider handler registry for extra-params.ts #25311

Closed

Elarwei001 added 3 commits February 24, 2026 19:01

refactor: extract magic number to HASH_LENGTH constant

0154648

refactor: improve model name mapping with tests

cb5bb26

- Handle moonshot-v1-* → moonshot-v1 - Handle kimi-k2-* → kimi-k2 - Pass through kimi-k2.5, kimi-latest as-is - Add toCacheModelName tests

Elarwei001 changed the title ~~feat(moonshot): add context caching support~~ WIP: feat(moonshot): context caching via /v1/caching API Feb 24, 2026

openclaw-barnacle bot added size: XL and removed size: L labels Feb 24, 2026

Elarwei001 added 3 commits February 24, 2026 19:54

refactor: extract magic string to MOONSHOT_V1_CACHE_MODEL constant

f0ff2be

refactor: rename toCacheModelName to getExplicitCacheModel

27d80c4

Better reflects the function's purpose: checking if a model requires explicit /v1/caching API calls vs automatic prefix caching (K2).

refactor: simplify to needsExplicitCacheApi returning boolean

3a67076

- Hide model name implementation detail (MOONSHOT_V1_CACHE_MODEL is internal) - Cleaner API: returns true/false instead of string/undefined

openclaw-barnacle bot added size: L and removed size: XL labels Feb 24, 2026

Elarwei001 mentioned this pull request Feb 24, 2026

fix(usage): parse Kimi K2 cached_tokens from prompt_tokens_details #25436

Merged

Elarwei001 changed the title ~~WIP: feat(moonshot): context caching via /v1/caching API~~ feat(moonshot): explicit context caching for moonshot-v1 via /v1/caching API Feb 24, 2026

Elarwei001 closed this Feb 24, 2026

Uh oh!

Conversation

Elarwei001 commented Feb 24, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Background

Changes

New Files

Modified Files

Configuration

Token Savings

Design Doc

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

SamuelHinestrosa left a comment

Choose a reason for hiding this comment

Uh oh!

Elarwei001 commented Feb 24, 2026

Uh oh!

Elarwei001 commented Feb 24, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

AI-Assisted Testing Results

Test 1: Baseline (without cache)

Test 2: With cache

Key Findings

Model Name Mapping

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

greptile-apps bot Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Elarwei001 commented Feb 24, 2026

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Elarwei001 Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot commented Feb 24, 2026

Uh oh!

Elarwei001 commented Feb 24, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Elarwei001 commented Feb 24, 2026 •

edited

Loading

Elarwei001 commented Feb 24, 2026 •

edited

Loading