From 963715344b6cd3ea0249b105ea4757752d377f2a Mon Sep 17 00:00:00 2001 From: Turtle Date: Wed, 30 Sep 2026 13:12:01 +0800 Subject: [PATCH] test: cover paths previously exercised only by invariant companions Delete the now-unused llm-retry history helper, drop the unreachable credentials-local refresh rejection handler, and add direct tests for the gateway SRC skip of unprovided Services and llm-retry projection dedupe. --- .../api/gateway/tests/gateway.host.spec.ts | 17 ++++++++++ .../credentials-local/src/index.ts | 10 ++---- packages/llm/llm-retry/README.i18n.yaml | 4 +-- packages/llm/llm-retry/README.md | 1 - packages/llm/llm-retry/README.zh.md | 1 - packages/llm/llm-retry/src/history.ts | 33 ------------------- packages/llm/llm-retry/tests/retry.spec.ts | 24 ++++++++++++++ 7 files changed, 45 insertions(+), 45 deletions(-) delete mode 100644 packages/llm/llm-retry/src/history.ts diff --git a/packages/api/gateway/tests/gateway.host.spec.ts b/packages/api/gateway/tests/gateway.host.spec.ts index 24522ce846..e0fcbec649 100644 --- a/packages/api/gateway/tests/gateway.host.spec.ts +++ b/packages/api/gateway/tests/gateway.host.spec.ts @@ -454,6 +454,23 @@ describe('TypertGatewayService', () => { expect(service.lastSignal).toBe(abort.signal) }) + it('skips declared Services without an active provider during SRC resolution', async () => { + const { ctx } = await setup() + const unbound = ctx.plugin(class UnboundService extends Service { + constructor(ctx: Context) { super(ctx, 'unboundFixture') } + }) + await unbound + await unbound.dispose() + registerAgentLookup(ctx, { id: 'agent-1' }) + + await expect(ctx.extend({ fixtureScope: 'unbound' }).typertGateway.invoke({ + namespace: 'goals', + method: 'create', + args: { agentId: 'agent-1', request: { title: 'ship' } }, + signal: new AbortController().signal, + })).resolves.toEqual({ agentId: 'agent-1', title: 'ship', scope: 'unbound' }) + }) + it('does not downgrade an observed SRC lookup after its provider unloads', async () => { const { ctx, service } = await setup() const dispose = registerAgentLookup(ctx, { id: 'agent-1' }) diff --git a/packages/credentials/credentials-local/src/index.ts b/packages/credentials/credentials-local/src/index.ts index f00e31d00b..d033fa32fc 100644 --- a/packages/credentials/credentials-local/src/index.ts +++ b/packages/credentials/credentials-local/src/index.ts @@ -724,15 +724,9 @@ export class LocalCredentialProvider extends CredentialProvider { return task } - /** Queue a reload; only an invariant violation escaping the fan-out can reject it. */ + /** Queue a reload; `refresh()` contains its own failures, so the queued task never rejects. */ private queueRefresh(): void { - void this.enqueue(() => this.refresh()).catch((error: unknown) => { - // Only an invariant violation escaping the update fan-out can reject a - // refresh; keep the operation queue alive and surface it as an error so - // one poisoned commit cannot silently end hot reloading forever. - this.ctx.logger.error('credentials-local: reload commit failed at %s', this.spec.filename) - this.ctx.logger.error(error) - }) + void this.enqueue(() => this.refresh()) } /** Queue one line edit; entry checks reject early, the queue re-judges them at run time. */ diff --git a/packages/llm/llm-retry/README.i18n.yaml b/packages/llm/llm-retry/README.i18n.yaml index 1f0dc625c6..6dbc01a710 100644 --- a/packages/llm/llm-retry/README.i18n.yaml +++ b/packages/llm/llm-retry/README.i18n.yaml @@ -36,8 +36,8 @@ en: fc4f15a14435698c zh: 3c6d83f5ba04ec0e /deepseek-ai-dsh-llm-retry/understand-the-implementation/source-map: - en: f34b551859b68c88 - zh: 813ffa32497b1d9a + en: 9b79cdd6597930e0 + zh: 0838f3efbc1e83ac /deepseek-ai-dsh-llm-retry/understand-the-implementation/recovery-flow: en: 85bace285b029101 zh: 6e0237450ca6ccc0 diff --git a/packages/llm/llm-retry/README.md b/packages/llm/llm-retry/README.md index 7e699c8f4b..2393ffbfea 100644 --- a/packages/llm/llm-retry/README.md +++ b/packages/llm/llm-retry/README.md @@ -76,7 +76,6 @@ The executor is built on one rule: **durable before wait, open-step boundaries.* | File | Role | |---|---| | [`src/index.ts`](src/index.ts) | The function plugin: waterfall listener, policy lookup, backoff, durable event appends | -| [`src/history.ts`](src/history.ts) | Durable retry-history lookup from the session log | | [`src/types.ts`](src/types.ts) | Browser-safe `llm/retry` and `llm/retry-started` event payload types | | [`src/brand.ts`](src/brand.ts) | The `RetryId` brand shared by the event payloads | diff --git a/packages/llm/llm-retry/README.zh.md b/packages/llm/llm-retry/README.zh.md index c32972426d..eef7a17aae 100644 --- a/packages/llm/llm-retry/README.zh.md +++ b/packages/llm/llm-retry/README.zh.md @@ -76,7 +76,6 @@ kind: "package-reference" | 文件 | 职责 | |---|---| | [`src/index.ts`](src/index.ts) | 函数插件：waterfall 监听器、策略查找、退避、持久事件追加 | -| [`src/history.ts`](src/history.ts) | 从会话日志查找持久重试历史 | | [`src/types.ts`](src/types.ts) | 浏览器安全的 `llm/retry` 与 `llm/retry-started` 事件载荷类型 | | [`src/brand.ts`](src/brand.ts) | 事件载荷共享的 `RetryId` 品牌 | diff --git a/packages/llm/llm-retry/src/history.ts b/packages/llm/llm-retry/src/history.ts deleted file mode 100644 index 4dd352e8c8..0000000000 --- a/packages/llm/llm-retry/src/history.ts +++ /dev/null @@ -1,33 +0,0 @@ -/** Durable request-route lookup for one open model step. @module @deepseek-ai/dsh-llm-retry/history */ - -import type { SessionEvent } from '@deepseek-ai/dsh-session' - -/** - * Find the provider in force for one currently open step. - * Request headers remain effective across turn boundaries until a newer full - * snapshot changes them; every provider change requires a newer full snapshot. - * @param events - session events ending inside the open step. - * @param turn - turn that owns the failed step. - * @param step - failed step whose provider is required. - * @returns the provider from the request header in force for the step. - */ -export function providerForOpenStep( - events: readonly SessionEvent[], - turn: number, - step: number, -): string | undefined { - const stepStartIndex = events.findLastIndex(event => - event.type === 'step/start' - && event.data.turn === turn - && event.data.step === step, - ) - if (stepStartIndex < 0 || events.slice(stepStartIndex + 1).some(event => - event.type === 'step/end' || event.type === 'turn/end')) return undefined - for (let index = events.length - 1; index >= 0; index -= 1) { - // The loop bounds prove this indexed read exists. - // oxlint-disable-next-line typescript/no-non-null-assertion - const event = events[index]! - if (event.type === 'request/header') return event.data.header.config.provider - } - return undefined -} diff --git a/packages/llm/llm-retry/tests/retry.spec.ts b/packages/llm/llm-retry/tests/retry.spec.ts index e7f0ededb2..3adb88de05 100644 --- a/packages/llm/llm-retry/tests/retry.spec.ts +++ b/packages/llm/llm-retry/tests/retry.spec.ts @@ -174,6 +174,30 @@ afterEach(async () => { context = undefined }) +describe('retry projection', () => { + it('keeps the same state when a recorded retry is applied again', async () => { + type Definition = { key: string; apply(state: object, event: SessionEvent): object } + const definitions: Definition[] = [] + const { ctx } = await harness(new ScriptedAdapter([]), undefined, (inner) => { + const projections = inner.sessionProjections + const register = projections.register.bind(projections) + projections.register = (spec: Definition) => { + definitions.push(spec) + return register(spec as never) + } + }) + const definition = definitions.find(spec => spec.key === 'llmRetry')! + const event: SessionEvent = { + type: 'llm/retry', + data: { provider: 'mock', policyKey: 'policy', retry: 1, retryId: 'retry-1' }, + } as never + const state = definition.apply({}, event) + + expect(definition.apply(state, event)).toBe(state) + await ctx.fiber.dispose() + }) +}) + describe('provider-routed retry policy', () => { it('records the scheduled delay before retrying the request', async () => { vi.useFakeTimers()