From ec6a40b39a529d92aa1bf90970e657a1d9c08149 Mon Sep 17 00:00:00 2001 From: Opencode Agent Date: Mon, 14 Sep 2026 22:08:14 -0700 Subject: [PATCH 1/2] fix(sdk): cap SSE retry loop to prevent context flooding --- packages/sdk/js/script/build.ts | 15 +++++++++++++++ .../sdk/js/src/gen/core/serverSentEvents.gen.ts | 4 +++- .../js/src/v2/gen/core/serverSentEvents.gen.ts | 4 +++- 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/packages/sdk/js/script/build.ts b/packages/sdk/js/script/build.ts index 79e0879c9e14..bf3ed15c3e30 100755 --- a/packages/sdk/js/script/build.ts +++ b/packages/sdk/js/script/build.ts @@ -112,6 +112,21 @@ if (sseTypesPatched === sseTypesSource) { } await Bun.write(sseTypesPath, sseTypesPatched) +// Patch the SSE retry guard so an unset sseMaxRetryAttempts still caps the +// retry loop instead of retrying forever and flooding the context window. +const sseServerEventsPath = "./src/v2/gen/core/serverSentEvents.gen.ts" +const sseServerEventsFile = Bun.file(sseServerEventsPath) +const sseServerEventsSource = await sseServerEventsFile.text() +const maxAttemptsGuard = "const maxRetryAttempts = sseMaxRetryAttempts ?? 5\n\n if (attempt >= maxRetryAttempts) {" +const sseServerEventsPatched = sseServerEventsSource.replace( + "if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {", + maxAttemptsGuard, +) +if (sseServerEventsPatched === sseServerEventsSource) { + throw new Error(`SSE retry guard patch did not apply (${sseServerEventsPath})`) +} +await Bun.write(sseServerEventsPath, sseServerEventsPatched) + await $`bun prettier --write src/gen` await $`bun prettier --write src/v2` await $`rm -rf dist` diff --git a/packages/sdk/js/src/gen/core/serverSentEvents.gen.ts b/packages/sdk/js/src/gen/core/serverSentEvents.gen.ts index ffc4f16dc1f3..0325685368e4 100644 --- a/packages/sdk/js/src/gen/core/serverSentEvents.gen.ts +++ b/packages/sdk/js/src/gen/core/serverSentEvents.gen.ts @@ -193,7 +193,9 @@ export const createSseClient = ({ // connection failed or aborted; retry after delay onSseError?.(error) - if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) { + const maxRetryAttempts = sseMaxRetryAttempts ?? 5 + + if (attempt >= maxRetryAttempts) { break // stop after firing error } diff --git a/packages/sdk/js/src/v2/gen/core/serverSentEvents.gen.ts b/packages/sdk/js/src/v2/gen/core/serverSentEvents.gen.ts index 056a81259322..b6da5ac5e346 100644 --- a/packages/sdk/js/src/v2/gen/core/serverSentEvents.gen.ts +++ b/packages/sdk/js/src/v2/gen/core/serverSentEvents.gen.ts @@ -222,7 +222,9 @@ export const createSseClient = ({ // connection failed or aborted; retry after delay onSseError?.(error) - if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) { + const maxRetryAttempts = sseMaxRetryAttempts ?? 5 + + if (attempt >= maxRetryAttempts) { break // stop after firing error } From bae965c7611c8f20d14574a38eacf9ec6edf3646 Mon Sep 17 00:00:00 2001 From: the3kingleo Date: Wed, 16 Sep 2026 20:30:49 -0700 Subject: [PATCH 2/2] fix: fail fast with a clear error on undefined LayerNode dependencies Fixes #48811, #48645, #48803, #49158. An undefined entry in a node's deps array (typically from a circular import leaving another module's node export uninitialized) was only caught deep inside walk()'s resolve callback, where it surfaces as 'undefined is not an object (evaluating node.name)' with no indication of which node or import caused it. Validate deps in make()/group() and guard walk()'s recur so the error names the offending node immediately. --- packages/core/src/effect/layer-node.ts | 28 +++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/packages/core/src/effect/layer-node.ts b/packages/core/src/effect/layer-node.ts index 9dbc3d51607b..4bc9dbfa8f99 100644 --- a/packages/core/src/effect/layer-node.ts +++ b/packages/core/src/effect/layer-node.ts @@ -85,9 +85,11 @@ export function make< >( input: MakeInput, ): Node, Layer.Error | Error, T> { + const name = input.service !== undefined ? input.service.key : input.name + assertDependencies(name, input.deps) return { kind: "layer", - name: input.service !== undefined ? input.service.key : input.name, + name, service: input.service, implementation: input.layer, dependencies: input.deps, @@ -95,6 +97,23 @@ export function make< } } +// Guards against a common failure mode: a `deps: [...]` array referencing another +// module's top-level `node` export before that module has finished initializing +// (an ESM circular-import ordering issue). Without this check, an undefined entry +// silently rides along in `dependencies` until `walk()` calls `node.name` on it deep +// inside `hoist`/`compile`, producing a cryptic "undefined is not an object" crash +// far from the actual cause. Failing fast here, at the node that declared the bad +// dependency, points directly at the module import order to fix. +function assertDependencies(name: string, deps: readonly (AnyNode | undefined)[]): asserts deps is readonly AnyNode[] { + const index = deps.findIndex((dependency) => dependency === undefined) + if (index !== -1) { + throw new Error( + `LayerNode "${name}" has an undefined dependency at index ${index}. ` + + `This usually means a circular import caused the referenced node's module to not be initialized yet.`, + ) + } +} + export function unbound(service: Context.Key, tag: T): Node { return { kind: "unbound", @@ -108,6 +127,7 @@ export function unbound(service: Context.Key( dependencies: Items, ): Node, Error, NodeTag> { + assertDependencies("group", dependencies) return { kind: "group", name: "group", dependencies } } @@ -182,6 +202,12 @@ function walk( const stack: AnyNode[] = [] const recur = (node: AnyNode): Result => { + if (node === undefined) { + throw new Error( + "LayerNode.walk encountered an undefined node in a dependencies array — " + + "likely a circular import that left a referenced node's module uninitialized.", + ) + } const target = options.resolve?.(node) ?? node const cached = cache.get(target) if (cached !== undefined || cache.has(target)) return cached!