proxied-server provider %T does not offer the stored-edge su

Error message

proxied-server provider %T does not offer the stored-edge surface

What it means

In direct-storage mode, dependency commands that need stored edges call proxiedEdgeReader, which type-asserts the global uowProvider to the uow.EdgeReaderSource capability interface. If the provider was initialized as something that does not implement EdgeReader (no EdgeReader() accessor), the assertion fails and this error is returned. It signals a provider/backend wiring problem: the active provider implementation lacks the stored-edge capability surface required by bd dep list.

Source

Thrown at cmd/bd/dep_proxied_server.go:61

	if uowProvider == nil {
		return nil, errors.New("proxied-server UOW provider not initialized")
	}
	src, ok := uowProvider.(uow.RelationsSource)
	if !ok {
		return nil, fmt.Errorf("proxied-server provider %T does not offer the neighbor-query surface", uowProvider)
	}
	return src.IssueRelations()
}

// proxiedEdgeReader hands back the guarded stored-edge surface for the
// proxied-server provider, through the provider's own capability accessor.
func proxiedEdgeReader() (issueops.EdgeReader, error) {
	if uowProvider == nil {
		return nil, errors.New("proxied-server UOW provider not initialized")
	}
	src, ok := uowProvider.(uow.EdgeReaderSource)
	if !ok {
		return nil, fmt.Errorf("proxied-server provider %T does not offer the stored-edge surface", uowProvider)
	}
	return src.EdgeReader()
}

// addDependencyEdgesProxied asserts edges through the DependencyEditor role.
//
// skipPerEdgeCycleCheck is a separate argument from the --no-cycle-check flag
// on purpose. That flag has never turned the per-edge probe off for a single
// edge on either route — it turns off the whole-graph sweep this command
// prints warnings from. Only the bulk path trades the per-edge probe away, and
// only because it always has.
func addDependencyEdgesProxied(ctx context.Context, edges []issueops.DependencyEdge, skipPerEdgeCycleCheck bool) error {
	editor, err := proxiedDependencyEditor()
	if err != nil {
		return err
	}
	_, err = editor.AddDependencies(ctx, issueops.AddDependenciesRequest{
		Actor:                 actor,

View on GitHub (pinned to 71377f2769)

Solutions

Check the concrete type printed in the error (%T) and confirm it implements uow.EdgeReaderSource with an EdgeReader() method.
Rebuild bd from current source so the standard Dolt-backed provider (which implements all capability sources) is used.
If a custom/stub provider is intentionally injected, add an EdgeReader() accessor that satisfies uow.EdgeReaderSource.
Verify uowProvider is initialized by the normal startup path, not overridden by test scaffolding or an env/config override.

Example fix

// before: stub provider missing the edge surface
type stubProvider struct{}
// after: add the capability accessor
func (p *stubProvider) EdgeReader() (issueops.EdgeReader, error) { return p.store, nil }
var _ uow.EdgeReaderSource = (*stubProvider)(nil)

Defensive patterns

Strategy: type-guard

Validate before calling

if uowProvider == nil { return errors.New("UOW provider not initialized") }
if _, ok := uowProvider.(uow.EdgeReaderSource); !ok {
    return fmt.Errorf("provider %T lacks EdgeReaderSource", uowProvider)
}

Type guard

func hasEdgeReader(p uow.Provider) bool { _, ok := p.(uow.EdgeReaderSource); return ok }

Try / catch

reader, err := proxiedEdgeReader()
if err != nil {
    return fmt.Errorf("stored-edge surface unavailable: %w", err)
}

Prevention

Assert compile-time interface conformance: var _ uow.EdgeReaderSource = (*myProvider)(nil).
Use the standard Dolt-backed provider instead of hand-rolled stubs in production paths.
When adding a capability source, update all test fakes to implement it.
Log the provider's concrete type at startup to catch wiring regressions early.

When it happens

Trigger: Running a proxied-server-route command (runDepListProxiedServer or runDepListRecordsProxiedServer) when uowProvider is non-nil but does not implement uow.EdgeReaderSource; e.g. a custom or older provider implementation injected before the EdgeReaderSource surface was added, or a test/stub provider missing EdgeReader().

Common situations: A stale or hand-built bd binary whose provider wiring predates the EdgeReaderSource interface; unit-test fakes for uowProvider that implement only part of the capability set; plugin or embedded use of bd where a minimal provider type is substituted for the real Dolt-backed provider.

Related errors

AI-assisted analysis of gastownhall/beads@71377f2769 (2026-08-30). Data as JSON: /api/errors/2bb1ac02b942140e. Report an issue: GitHub.