Remove legacy raw pipeline contracts

internal/modules/dnd/extract/spells/extractor.go

@@ -39,18 +39,6 @@ type Extractor struct {
 	llm contracts.StructuredLLMClient
 }
 
-type rawAdapter struct {
-	extractor *Extractor
-	codec     RawAdapterCodec
-}
-
-type RawAdapterCodec interface {
-	contracts.ArtifactCodec[dnd.SpellList]
-	EncodeCandidate(dnd.SpellList) ([]byte, error)
-}
-
-var _ contracts.LegacyRawExtractor = (*rawAdapter)(nil)
-
 func New(llmClient contracts.StructuredLLMClient, _ Options) (*Extractor, error) {
 	if llmClient == nil {
 		return nil, extractorErrorf("LLM client must not be nil")
@@ -169,66 +157,6 @@ func Register(registry *pipeline.ExtractorRegistry) error {
 	})
 }
 
-// RegisterWithRawAdapter keeps existing raw downstream implementations usable
-// while the extractor itself produces the canonical typed artifact.
-func RegisterWithRawAdapter(registry *pipeline.ExtractorRegistry, codec RawAdapterCodec) error {
-	if codec == nil {
-		return extractorErrorf("artifact codec must not be nil")
-	}
-	build := func(request pipeline.BuildRequest) (*Extractor, error) {
-		options, err := DecodeOptions(request.Options)
-		if err != nil {
-			return nil, err
-		}
-		return New(request.Dependencies.LLM, options)
-	}
-	return pipeline.RegisterExtractorBuilderWithRawAdapter(registry, ModuleSpec(), validateOptions,
-		func(request pipeline.BuildRequest) (contracts.Extractor[dnd.SpellList], error) {
-			return build(request)
-		},
-		func(request pipeline.BuildRequest) (contracts.LegacyRawExtractor, error) {
-			extractor, err := build(request)
-			if err != nil {
-				return nil, err
-			}
-			return &rawAdapter{extractor: extractor, codec: codec}, nil
-		},
-	)
-}
-
-func (adapter *rawAdapter) Key() string { return Key }
-
-func (adapter *rawAdapter) ReferenceSlots() []contracts.ReferenceSlot {
-	return adapter.extractor.ReferenceSlots()
-}
-
-func (adapter *rawAdapter) ManifestMetadata() map[string]any {
-	return adapter.extractor.ManifestMetadata()
-}
-
-func (adapter *rawAdapter) Extract(ctx context.Context, req contracts.ExtractionRequest) (contracts.ExtractionResult, error) {
-	result, err := adapter.extractor.Extract(ctx, contracts.TypedExtractionRequest{
-		Source: req.Source, Chunk: req.Chunk, AmbientContext: req.AmbientContext,
-		SourceInput: req.SourceInput, SessionID: req.SessionID, References: req.References,
-		LLMProfile: req.LLMProfile, Metadata: req.Metadata,
-	})
-	if err != nil {
-		return contracts.ExtractionResult{}, err
-	}
-	content, err := adapter.codec.EncodeCandidate(result.Value)
-	if err != nil {
-		return contracts.ExtractionResult{}, extractorErrorf("encode canonical output: %w", err)
-	}
-	schema := adapter.codec.Schema()
-	return contracts.ExtractionResult{
-		Output: contracts.ExtractOutput{
-			Schema:  contracts.ResponseSchema{ID: schema.ID, Name: schema.Name, Version: schema.Version, JSONSchema: append([]byte(nil), schema.JSONSchema...)},
-			Payload: contracts.RawPayload{Content: content, MediaType: adapter.codec.MediaType(), Metadata: map[string]any{"spell_cast_count": len(result.Value.SpellCasts)}},
-		},
-		Warnings: result.Warnings,
-	}, nil
-}
-
 func validateOptions(options map[string]any) error {
 	_, err := DecodeOptions(options)
 	return err

internal/modules/dnd/extract/spells/registry_test.go

@@ -76,9 +76,6 @@ func TestRegisterMakesExtractorBuildable(t *testing.T) {
 		t.Fatalf("Register() error = %v, want nil", err)
 	}
 
-	if _, err := registry.BuildLegacyRaw(Key); err == nil || !strings.Contains(err.Error(), "legacy raw") {
-		t.Fatalf("BuildLegacyRaw() error = %v, want typed registration error", err)
-	}
 	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil || !strings.Contains(err.Error(), "unknown option") {
 		t.Fatalf("DecodeOptions() error = %v, want unknown option error", err)
 	}