chore(deps): update Go version to 1.26 in Dockerfile and go.mod

Signed-off-by: Deluan <deluan@navidrome.org>

.devcontainer/devcontainer.json

@@ -4,7 +4,7 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.25",
+			"VARIANT": "1.26",
 			// Options
 			"INSTALL_NODE": "true",
 			"NODE_VERSION": "v24",

Dockerfile

@@ -63,7 +63,7 @@ COPY --from=ui /build /build
 
 ########################################################################################################################
 ### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-trixie AS base
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.26-trixie AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace

conf/configuration.go

@@ -155,7 +155,6 @@ type scannerOptions struct {
 
 type subsonicOptions struct {
 	AppendSubtitle        bool
-	AppendAlbumVersion    bool
 	ArtistParticipations  bool
 	DefaultReportRealPath bool
 	EnableAverageRating   bool
@@ -690,7 +689,6 @@ func setViperDefaults() {
 	viper.SetDefault("scanner.followsymlinks", true)
 	viper.SetDefault("scanner.purgemissing", consts.PurgeMissingNever)
 	viper.SetDefault("subsonic.appendsubtitle", true)
-	viper.SetDefault("subsonic.appendalbumversion", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
 	viper.SetDefault("subsonic.enableaveragerating", true)

db/migrations/20260228020813_add_plugin_allow_write_access.sql

@@ -1,5 +0,0 @@
--- +goose Up
-ALTER TABLE plugin ADD COLUMN allow_write_access BOOL NOT NULL DEFAULT false;
-
--- +goose Down
-ALTER TABLE plugin DROP COLUMN allow_write_access;

go.mod

@@ -1,6 +1,6 @@
 module github.com/navidrome/navidrome
 
-go 1.25.0
+go 1.26
 
 replace (
 	// Fork to fix https://github.com/navidrome/navidrome/issues/3254

model/album.go

@@ -1,14 +1,11 @@
 package model
 
 import (
-	"fmt"
 	"iter"
 	"math"
 	"sync"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
-
 	"github.com/gohugoio/hashstructure"
 )
 
@@ -73,13 +70,6 @@ func (a Album) CoverArtID() ArtworkID {
 	return artworkIDFromAlbum(a)
 }
 
-func (a Album) FullName() string {
-	if conf.Server.Subsonic.AppendAlbumVersion && len(a.Tags[TagAlbumVersion]) > 0 {
-		return fmt.Sprintf("%s (%s)", a.Name, a.Tags[TagAlbumVersion][0])
-	}
-	return a.Name
-}
-
 // Equals compares two Album structs, ignoring calculated fields
 func (a Album) Equals(other Album) bool {
 	// Normalize float32 values to avoid false negatives

model/album_test.go

@@ -3,30 +3,11 @@ package model_test
 import (
 	"encoding/json"
 
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
 	. "github.com/navidrome/navidrome/model"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("Album", func() {
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-	})
-	DescribeTable("FullName",
-		func(enabled bool, tags Tags, expected string) {
-			conf.Server.Subsonic.AppendAlbumVersion = enabled
-			a := Album{Name: "Album", Tags: tags}
-			Expect(a.FullName()).To(Equal(expected))
-		},
-		Entry("appends version when enabled and tag is present", true, Tags{TagAlbumVersion: []string{"Remastered"}}, "Album (Remastered)"),
-		Entry("returns just name when disabled", false, Tags{TagAlbumVersion: []string{"Remastered"}}, "Album"),
-		Entry("returns just name when tag is absent", true, Tags{}, "Album"),
-		Entry("returns just name when tag is an empty slice", true, Tags{TagAlbumVersion: []string{}}, "Album"),
-	)
-})
-
 var _ = Describe("Albums", func() {
 	var albums Albums
 

model/mediafile.go

@@ -95,19 +95,12 @@ type MediaFile struct {
 }
 
 func (mf MediaFile) FullTitle() string {
-	if conf.Server.Subsonic.AppendSubtitle && len(mf.Tags[TagSubtitle]) > 0 {
+	if conf.Server.Subsonic.AppendSubtitle && mf.Tags[TagSubtitle] != nil {
 		return fmt.Sprintf("%s (%s)", mf.Title, mf.Tags[TagSubtitle][0])
 	}
 	return mf.Title
 }
 
-func (mf MediaFile) FullAlbumName() string {
-	if conf.Server.Subsonic.AppendAlbumVersion && len(mf.Tags[TagAlbumVersion]) > 0 {
-		return fmt.Sprintf("%s (%s)", mf.Album, mf.Tags[TagAlbumVersion][0])
-	}
-	return mf.Album
-}
-
 func (mf MediaFile) ContentType() string {
 	return mime.TypeByExtension("." + mf.Suffix)
 }

model/mediafile_test.go

@@ -475,29 +475,7 @@ var _ = Describe("MediaFile", func() {
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.EnableMediaFileCoverArt = true
 	})
-	DescribeTable("FullTitle",
-		func(enabled bool, tags Tags, expected string) {
-			conf.Server.Subsonic.AppendSubtitle = enabled
-			mf := MediaFile{Title: "Song", Tags: tags}
-			Expect(mf.FullTitle()).To(Equal(expected))
-		},
-		Entry("appends subtitle when enabled and tag is present", true, Tags{TagSubtitle: []string{"Live"}}, "Song (Live)"),
-		Entry("returns just title when disabled", false, Tags{TagSubtitle: []string{"Live"}}, "Song"),
-		Entry("returns just title when tag is absent", true, Tags{}, "Song"),
-		Entry("returns just title when tag is an empty slice", true, Tags{TagSubtitle: []string{}}, "Song"),
-	)
-	DescribeTable("FullAlbumName",
-		func(enabled bool, tags Tags, expected string) {
-			conf.Server.Subsonic.AppendAlbumVersion = enabled
-			mf := MediaFile{Album: "Album", Tags: tags}
-			Expect(mf.FullAlbumName()).To(Equal(expected))
-		},
-		Entry("appends version when enabled and tag is present", true, Tags{TagAlbumVersion: []string{"Deluxe Edition"}}, "Album (Deluxe Edition)"),
-		Entry("returns just album name when disabled", false, Tags{TagAlbumVersion: []string{"Deluxe Edition"}}, "Album"),
-		Entry("returns just album name when tag is absent", true, Tags{}, "Album"),
-		Entry("returns just album name when tag is an empty slice", true, Tags{TagAlbumVersion: []string{}}, "Album"),
-	)
-	Describe("CoverArtId()", func() {
+	Describe(".CoverArtId()", func() {
 		It("returns its own id if it HasCoverArt", func() {
 			mf := MediaFile{ID: "111", AlbumID: "1", HasCoverArt: true}
 			id := mf.CoverArtID()

model/plugin.go

@@ -3,20 +3,19 @@ package model
 import "time"
 
 type Plugin struct {
-	ID               string    `structs:"id"                 json:"id"`
-	Path             string    `structs:"path"               json:"path"`
-	Manifest         string    `structs:"manifest"           json:"manifest"`
-	Config           string    `structs:"config"             json:"config,omitempty"`
-	Users            string    `structs:"users"              json:"users,omitempty"`
-	AllUsers         bool      `structs:"all_users"          json:"allUsers,omitempty"`
-	Libraries        string    `structs:"libraries"          json:"libraries,omitempty"`
-	AllLibraries     bool      `structs:"all_libraries"      json:"allLibraries,omitempty"`
-	AllowWriteAccess bool      `structs:"allow_write_access" json:"allowWriteAccess,omitempty"`
-	Enabled          bool      `structs:"enabled"            json:"enabled"`
-	LastError        string    `structs:"last_error"         json:"lastError,omitempty"`
-	SHA256           string    `structs:"sha256"             json:"sha256"`
-	CreatedAt        time.Time `structs:"created_at"         json:"createdAt"`
-	UpdatedAt        time.Time `structs:"updated_at"         json:"updatedAt"`
+	ID           string    `structs:"id"            json:"id"`
+	Path         string    `structs:"path"          json:"path"`
+	Manifest     string    `structs:"manifest"      json:"manifest"`
+	Config       string    `structs:"config"        json:"config,omitempty"`
+	Users        string    `structs:"users"         json:"users,omitempty"`
+	AllUsers     bool      `structs:"all_users"     json:"allUsers,omitempty"`
+	Libraries    string    `structs:"libraries"     json:"libraries,omitempty"`
+	AllLibraries bool      `structs:"all_libraries" json:"allLibraries,omitempty"`
+	Enabled      bool      `structs:"enabled"       json:"enabled"`
+	LastError    string    `structs:"last_error"    json:"lastError,omitempty"`
+	SHA256       string    `structs:"sha256"        json:"sha256"`
+	CreatedAt    time.Time `structs:"created_at"    json:"createdAt"`
+	UpdatedAt    time.Time `structs:"updated_at"    json:"updatedAt"`
 }
 
 type Plugins []Plugin

persistence/plugin_repository.go

@@ -79,8 +79,8 @@ func (r *pluginRepository) Put(plugin *model.Plugin) error {
 
 	// Upsert using INSERT ... ON CONFLICT for atomic operation
 	_, err := r.db.NewQuery(`
-		INSERT INTO plugin (id, path, manifest, config, users, all_users, libraries, all_libraries, allow_write_access, enabled, last_error, sha256, created_at, updated_at)
-		VALUES ({:id}, {:path}, {:manifest}, {:config}, {:users}, {:all_users}, {:libraries}, {:all_libraries}, {:allow_write_access}, {:enabled}, {:last_error}, {:sha256}, {:created_at}, {:updated_at})
+		INSERT INTO plugin (id, path, manifest, config, users, all_users, libraries, all_libraries, enabled, last_error, sha256, created_at, updated_at)
+		VALUES ({:id}, {:path}, {:manifest}, {:config}, {:users}, {:all_users}, {:libraries}, {:all_libraries}, {:enabled}, {:last_error}, {:sha256}, {:created_at}, {:updated_at})
 		ON CONFLICT(id) DO UPDATE SET
 			path = excluded.path,
 			manifest = excluded.manifest,
@@ -89,26 +89,24 @@ func (r *pluginRepository) Put(plugin *model.Plugin) error {
 			all_users = excluded.all_users,
 			libraries = excluded.libraries,
 			all_libraries = excluded.all_libraries,
-			allow_write_access = excluded.allow_write_access,
 			enabled = excluded.enabled,
 			last_error = excluded.last_error,
 			sha256 = excluded.sha256,
 			updated_at = excluded.updated_at
 	`).Bind(dbx.Params{
-		"id":                 plugin.ID,
-		"path":               plugin.Path,
-		"manifest":           plugin.Manifest,
-		"config":             plugin.Config,
-		"users":              plugin.Users,
-		"all_users":          plugin.AllUsers,
-		"libraries":          plugin.Libraries,
-		"all_libraries":      plugin.AllLibraries,
-		"allow_write_access": plugin.AllowWriteAccess,
-		"enabled":            plugin.Enabled,
-		"last_error":         plugin.LastError,
-		"sha256":             plugin.SHA256,
-		"created_at":         time.Now(),
-		"updated_at":         plugin.UpdatedAt,
+		"id":            plugin.ID,
+		"path":          plugin.Path,
+		"manifest":      plugin.Manifest,
+		"config":        plugin.Config,
+		"users":         plugin.Users,
+		"all_users":     plugin.AllUsers,
+		"libraries":     plugin.Libraries,
+		"all_libraries": plugin.AllLibraries,
+		"enabled":       plugin.Enabled,
+		"last_error":    plugin.LastError,
+		"sha256":        plugin.SHA256,
+		"created_at":    time.Now(),
+		"updated_at":    plugin.UpdatedAt,
 	}).Execute()
 	return err
 }

plugins/cmd/ndpgen/go.mod

@@ -1,6 +1,6 @@
 module github.com/navidrome/navidrome/plugins/cmd/ndpgen
 
-go 1.25
+go 1.26
 
 require (
 	github.com/extism/go-pdk v1.1.3

plugins/cmd/ndpgen/integration_test.go

@@ -282,6 +282,9 @@ type ServiceB interface {
 
 			Entry("option pattern (value, exists bool)",
 				"config_service.go.txt", "config_client_expected.go.txt", "config_client_expected.py", "config_client_expected.rs"),
+
+			Entry("raw=true binary response",
+				"raw_service.go.txt", "raw_client_expected.go.txt", "raw_client_expected.py", "raw_client_expected.rs"),
 		)
 
 		It("generates compilable client code for comprehensive service", func() {

plugins/cmd/ndpgen/internal/generator.go

@@ -256,15 +256,6 @@ func GenerateClientRust(svc Service) ([]byte, error) {
 		return nil, fmt.Errorf("parsing template: %w", err)
 	}
 
-	partialContent, err := templatesFS.ReadFile("templates/base64_bytes.rs.tmpl")
-	if err != nil {
-		return nil, fmt.Errorf("reading base64_bytes partial: %w", err)
-	}
-	tmpl, err = tmpl.Parse(string(partialContent))
-	if err != nil {
-		return nil, fmt.Errorf("parsing base64_bytes partial: %w", err)
-	}
-
 	data := templateData{
 		Service: svc,
 	}
@@ -631,15 +622,6 @@ func GenerateCapabilityRust(cap Capability) ([]byte, error) {
 		return nil, fmt.Errorf("parsing template: %w", err)
 	}
 
-	partialContent, err := templatesFS.ReadFile("templates/base64_bytes.rs.tmpl")
-	if err != nil {
-		return nil, fmt.Errorf("reading base64_bytes partial: %w", err)
-	}
-	tmpl, err = tmpl.Parse(string(partialContent))
-	if err != nil {
-		return nil, fmt.Errorf("parsing base64_bytes partial: %w", err)
-	}
-
 	data := capabilityTemplateData{
 		Package:    cap.Name,
 		Capability: cap,

plugins/cmd/ndpgen/internal/generator_test.go

@@ -264,6 +264,96 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`extism "github.com/extism/go-sdk"`))
 		})
 
+		It("should generate binary framing for raw=true methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateHost(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = format.Source(code)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should include encoding/binary import for raw methods
+			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
+
+			// Should NOT generate a response type for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("type StreamGetStreamResponse struct"))
+
+			// Should generate request type (request is still JSON)
+			Expect(codeStr).To(ContainSubstring("type StreamGetStreamRequest struct"))
+
+			// Should build binary frame [0x00][4-byte CT len][CT][data]
+			Expect(codeStr).To(ContainSubstring("frame[0] = 0x00"))
+			Expect(codeStr).To(ContainSubstring("binary.BigEndian.PutUint32"))
+
+			// Should have writeRawError helper
+			Expect(codeStr).To(ContainSubstring("streamWriteRawError"))
+
+			// Should use writeRawError instead of writeError for raw methods
+			Expect(codeStr).To(ContainSubstring("streamWriteRawError(p, stack"))
+		})
+
+		It("should generate both writeError and writeRawError for mixed services", func() {
+			svc := Service{
+				Name:       "API",
+				Permission: "api",
+				Interface:  "APIService",
+				Methods: []Method{
+					{
+						Name:     "Call",
+						HasError: true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns:  []Param{NewParam("response", "string")},
+					},
+					{
+						Name:     "CallRaw",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateHost(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = format.Source(code)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should have both helpers
+			Expect(codeStr).To(ContainSubstring("apiWriteResponse"))
+			Expect(codeStr).To(ContainSubstring("apiWriteError"))
+			Expect(codeStr).To(ContainSubstring("apiWriteRawError"))
+
+			// Should generate response type for non-raw method only
+			Expect(codeStr).To(ContainSubstring("type APICallResponse struct"))
+			Expect(codeStr).NotTo(ContainSubstring("type APICallRawResponse struct"))
+		})
+
 		It("should always include json import for JSON protocol", func() {
 			// All services use JSON protocol, so json import is always needed
 			svc := Service{
@@ -627,7 +717,49 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`response.get("boolVal", False)`))
 		})
 
-		It("should not import base64 for non-byte services", func() {
+		It("should generate binary frame parsing for raw methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+						Doc: "GetStream returns raw binary stream data.",
+					},
+				},
+			}
+
+			code, err := GenerateClientPython(svc)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should import Tuple and struct for raw methods
+			Expect(codeStr).To(ContainSubstring("from typing import Any, Tuple"))
+			Expect(codeStr).To(ContainSubstring("import struct"))
+
+			// Should return Tuple[str, bytes]
+			Expect(codeStr).To(ContainSubstring("-> Tuple[str, bytes]:"))
+
+			// Should parse binary frame instead of JSON
+			Expect(codeStr).To(ContainSubstring("response_bytes = response_mem.bytes()"))
+			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("struct.unpack"))
+			Expect(codeStr).To(ContainSubstring("return content_type, data"))
+
+			// Should NOT use json.loads for response
+			Expect(codeStr).NotTo(ContainSubstring("json.loads(extism.memory.string(response_mem))"))
+		})
+
+		It("should not import Tuple or struct for non-raw services", func() {
 			svc := Service{
 				Name:       "Test",
 				Permission: "test",
@@ -647,37 +779,8 @@ var _ = Describe("Generator", func() {
 
 			codeStr := string(code)
 
-			Expect(codeStr).NotTo(ContainSubstring("import base64"))
-		})
-
-		It("should generate base64 encoding/decoding for byte fields", func() {
-			svc := Service{
-				Name:       "Codec",
-				Permission: "codec",
-				Interface:  "CodecService",
-				Methods: []Method{
-					{
-						Name:     "Encode",
-						HasError: true,
-						Params:   []Param{NewParam("data", "[]byte")},
-						Returns:  []Param{NewParam("result", "[]byte")},
-					},
-				},
-			}
-
-			code, err := GenerateClientPython(svc)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should import base64
-			Expect(codeStr).To(ContainSubstring("import base64"))
-
-			// Should base64-encode byte params in request
-			Expect(codeStr).To(ContainSubstring(`base64.b64encode(data).decode("ascii")`))
-
-			// Should base64-decode byte returns in response
-			Expect(codeStr).To(ContainSubstring(`base64.b64decode(response.get("result", ""))`))
+			Expect(codeStr).NotTo(ContainSubstring("Tuple"))
+			Expect(codeStr).NotTo(ContainSubstring("import struct"))
 		})
 	})
 
@@ -836,6 +939,46 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring("github.com/navidrome/navidrome/plugins/pdk/go/pdk"))
 		})
 
+		It("should include encoding/binary import for raw methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateClientGo(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should include encoding/binary for raw binary frame parsing
+			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
+
+			// Should NOT generate response type struct for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("streamGetStreamResponse struct"))
+
+			// Should still generate request type
+			Expect(codeStr).To(ContainSubstring("streamGetStreamRequest struct"))
+
+			// Should parse binary frame
+			Expect(codeStr).To(ContainSubstring("responseBytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("binary.BigEndian.Uint32"))
+
+			// Should return (string, []byte, error)
+			Expect(codeStr).To(ContainSubstring("func StreamGetStream(uri string) (string, []byte, error)"))
+		})
 	})
 
 	Describe("GenerateClientGoStub", func() {
@@ -1605,45 +1748,22 @@ var _ = Describe("Rust Generation", func() {
 			Expect(codeStr).NotTo(ContainSubstring("Option<bool>"))
 		})
 
-		It("should generate base64 serde for Vec<u8> fields", func() {
+		It("should generate raw extern C import and binary frame parsing for raw methods", func() {
 			svc := Service{
-				Name:       "Codec",
-				Permission: "codec",
-				Interface:  "CodecService",
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
 				Methods: []Method{
 					{
-						Name:     "Encode",
-						HasError: true,
-						Params:   []Param{NewParam("data", "[]byte")},
-						Returns:  []Param{NewParam("result", "[]byte")},
-					},
-				},
-			}
-
-			code, err := GenerateClientRust(svc)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should generate base64_bytes serde module
-			Expect(codeStr).To(ContainSubstring("mod base64_bytes"))
-			Expect(codeStr).To(ContainSubstring("use base64::Engine as _"))
-
-			// Should add serde(with = "base64_bytes") on Vec<u8> fields
-			Expect(codeStr).To(ContainSubstring(`#[serde(with = "base64_bytes")]`))
-		})
-
-		It("should not generate base64 module when no byte fields", func() {
-			svc := Service{
-				Name:       "Test",
-				Permission: "test",
-				Interface:  "TestService",
-				Methods: []Method{
-					{
-						Name:     "Call",
+						Name:     "GetStream",
 						HasError: true,
+						Raw:      true,
 						Params:   []Param{NewParam("uri", "string")},
-						Returns:  []Param{NewParam("response", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+						Doc: "GetStream returns raw binary stream data.",
 					},
 				},
 			}
@@ -1653,8 +1773,24 @@ var _ = Describe("Rust Generation", func() {
 
 			codeStr := string(code)
 
-			Expect(codeStr).NotTo(ContainSubstring("mod base64_bytes"))
-			Expect(codeStr).NotTo(ContainSubstring("use base64"))
+			// Should use extern "C" with wasm_import_module for raw methods, not #[host_fn] extern "ExtismHost"
+			Expect(codeStr).To(ContainSubstring(`#[link(wasm_import_module = "extism:host/user")]`))
+			Expect(codeStr).To(ContainSubstring(`extern "C"`))
+			Expect(codeStr).To(ContainSubstring("fn stream_getstream(offset: u64) -> u64"))
+
+			// Should NOT generate response type for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("StreamGetStreamResponse"))
+
+			// Should generate request type (request is still JSON)
+			Expect(codeStr).To(ContainSubstring("struct StreamGetStreamRequest"))
+
+			// Should return Result<(String, Vec<u8>), Error>
+			Expect(codeStr).To(ContainSubstring("Result<(String, Vec<u8>), Error>"))
+
+			// Should parse binary frame
+			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("u32::from_be_bytes"))
+			Expect(codeStr).To(ContainSubstring("String::from_utf8_lossy"))
 		})
 	})
 })

plugins/cmd/ndpgen/internal/parser.go

@@ -761,6 +761,7 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 	m := Method{
 		Name:       name,
 		ExportName: annotation["name"],
+		Raw:        annotation["raw"] == "true",
 		Doc:        doc,
 	}
 
@@ -799,6 +800,13 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 		}
 	}
 
+	// Validate raw=true methods: must return exactly (string, []byte, error)
+	if m.Raw {
+		if !m.HasError || len(m.Returns) != 2 || m.Returns[0].Type != "string" || m.Returns[1].Type != "[]byte" {
+			return m, fmt.Errorf("raw=true method %s must return (string, []byte, error) — content-type, data, error", name)
+		}
+	}
+
 	return m, nil
 }
 

plugins/cmd/ndpgen/internal/parser_test.go

@@ -122,6 +122,119 @@ type TestService interface {
 			Expect(services[0].Methods[0].Name).To(Equal("Exported"))
 		})
 
+		It("should parse raw=true annotation", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Stream permission=stream
+type StreamService interface {
+	//nd:hostfunc raw=true
+	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "stream.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services).To(HaveLen(1))
+
+			m := services[0].Methods[0]
+			Expect(m.Name).To(Equal("GetStream"))
+			Expect(m.Raw).To(BeTrue())
+			Expect(m.HasError).To(BeTrue())
+			Expect(m.Returns).To(HaveLen(2))
+			Expect(m.Returns[0].Name).To(Equal("contentType"))
+			Expect(m.Returns[0].Type).To(Equal("string"))
+			Expect(m.Returns[1].Name).To(Equal("data"))
+			Expect(m.Returns[1].Type).To(Equal("[]byte"))
+		})
+
+		It("should set Raw=false when raw annotation is absent", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc
+	Call(ctx context.Context, uri string) (response string, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services[0].Methods[0].Raw).To(BeFalse())
+		})
+
+		It("should reject raw=true with invalid return signature", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc raw=true
+	BadRaw(ctx context.Context, uri string) (result string, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = ParseDirectory(tmpDir)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("raw=true"))
+			Expect(err.Error()).To(ContainSubstring("must return (string, []byte, error)"))
+		})
+
+		It("should reject raw=true without error return", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc raw=true
+	BadRaw(ctx context.Context, uri string) (contentType string, data []byte)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = ParseDirectory(tmpDir)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("raw=true"))
+		})
+
+		It("should parse mixed raw and non-raw methods", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=API permission=api
+type APIService interface {
+	//nd:hostfunc
+	Call(ctx context.Context, uri string) (responseJSON string, err error)
+
+	//nd:hostfunc raw=true
+	CallRaw(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "api.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services).To(HaveLen(1))
+			Expect(services[0].Methods).To(HaveLen(2))
+			Expect(services[0].Methods[0].Raw).To(BeFalse())
+			Expect(services[0].Methods[1].Raw).To(BeTrue())
+			Expect(services[0].HasRawMethods()).To(BeTrue())
+		})
+
 		It("should handle custom export name", func() {
 			src := `package host
 

plugins/cmd/ndpgen/internal/templates/base64_bytes.rs.tmpl

@@ -1,25 +0,0 @@
-{{define "base64_bytes_module"}}
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
-{{- end}}

plugins/cmd/ndpgen/internal/templates/capability.rs.tmpl

@@ -7,7 +7,6 @@ use serde::{Deserialize, Serialize};
 {{- if hasHashMap .Capability}}
 use std::collections::HashMap;
 {{- end}}
-{{- if .Capability.HasByteFields}}{{template "base64_bytes_module" .}}{{- end}}
 
 // Helper functions for skip_serializing_if with numeric types
 #[allow(dead_code)]
@@ -71,9 +70,6 @@ pub struct {{.Name}} {
     #[serde(default, skip_serializing_if = "{{skipSerializingFunc .Type}}")]
 {{- else}}
     #[serde(default)]
-{{- end}}
-{{- if .IsByteSlice}}
-    #[serde(with = "base64_bytes")]
 {{- end}}
     pub {{rustFieldName .Name}}: {{fieldRustType .}},
 {{- end}}

plugins/cmd/ndpgen/internal/templates/client.go.tmpl

@@ -8,6 +8,9 @@
 package {{.Package}}
 
 import (
+{{- if .Service.HasRawMethods}}
+	"encoding/binary"
+{{- end}}
 	"encoding/json"
 {{- if .Service.HasErrors}}
 	"errors"
@@ -49,7 +52,7 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
-{{- if not .IsErrorOnly}}
+{{- if and (not .IsErrorOnly) (not .Raw)}}
 
 type {{responseType .}} struct {
 {{- range .Returns}}
@@ -95,7 +98,27 @@ func {{$.Service.Name}}{{.Name}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{
 	// Read the response from memory
 	responseMem := pdk.FindMemory(responsePtr)
 	responseBytes := responseMem.ReadBytes()
-{{- if .IsErrorOnly}}
+{{- if .Raw}}
+
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
+	}
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
+	}
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
+{{- else if .IsErrorOnly}}
 
 	// Parse error-only response
 	var response struct {

plugins/cmd/ndpgen/internal/templates/client.py.tmpl

@@ -8,12 +8,12 @@
 # main __init__.py file. Copy the needed functions from this file into your plugin.
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any{{- if .Service.HasRawMethods}}, Tuple{{end}}
 
 import extism
 import json
-{{- if .Service.HasByteFields}}
-import base64
+{{- if .Service.HasRawMethods}}
+import struct
 {{- end}}
 
 
@@ -32,7 +32,7 @@ def _{{exportName .}}(offset: int) -> int:
 {{- end}}
 {{- /* Generate dataclasses for multi-value returns */ -}}
 {{range .Service.Methods}}
-{{- if .NeedsResultClass}}
+{{- if and .NeedsResultClass (not .Raw)}}
 
 
 @dataclass
@@ -47,7 +47,7 @@ class {{pythonResultType .}}:
 {{range .Service.Methods}}
 
 
-def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
+def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .Raw}} -> Tuple[str, bytes]{{else if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
     """{{if .Doc}}{{.Doc}}{{else}}Call the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
 
@@ -56,7 +56,11 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
         {{.PythonName}}: {{.PythonType}} parameter.
 {{- end}}
 {{- end}}
-{{- if .HasReturns}}
+{{- if .Raw}}
+
+    Returns:
+        Tuple of (content_type, data) with the raw binary response.
+{{- else if .HasReturns}}
 
     Returns:
 {{- if .NeedsResultClass}}
@@ -72,11 +76,7 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
 {{- if .HasParams}}
     request = {
 {{- range .Params}}
-{{- if .IsByteSlice}}
-        "{{.JSONName}}": base64.b64encode({{.PythonName}}).decode("ascii"),
-{{- else}}
         "{{.JSONName}}": {{.PythonName}},
-{{- end}}
 {{- end}}
     }
     request_bytes = json.dumps(request).encode("utf-8")
@@ -86,6 +86,24 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
     request_mem = extism.memory.alloc(request_bytes)
     response_offset = _{{exportName .}}(request_mem.offset)
     response_mem = extism.memory.find(response_offset)
+{{- if .Raw}}
+    response_bytes = response_mem.bytes()
+
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data
+{{- else}}
     response = json.loads(extism.memory.string(response_mem))
 {{if .HasError}}
     if response.get("error"):
@@ -94,17 +112,10 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
 {{- if .NeedsResultClass}}
     return {{pythonResultType .}}(
 {{- range .Returns}}
-{{- if .IsByteSlice}}
-        {{.PythonName}}=base64.b64decode(response.get("{{.JSONName}}", "")),
-{{- else}}
         {{.PythonName}}=response.get("{{.JSONName}}"{{pythonDefault .}}),
-{{- end}}
 {{- end}}
     )
 {{- else if .HasReturns}}
-{{- if (index .Returns 0).IsByteSlice}}
-    return base64.b64decode(response.get("{{(index .Returns 0).JSONName}}", ""))
-{{- else}}
     return response.get("{{(index .Returns 0).JSONName}}"{{pythonDefault (index .Returns 0)}})
 {{- end}}
 {{- end}}

plugins/cmd/ndpgen/internal/templates/client.rs.tmpl

@@ -5,7 +5,6 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-{{- if .Service.HasByteFields}}{{template "base64_bytes_module" .}}{{- end}}
 {{- /* Generate struct definitions */ -}}
 {{- range .Service.Structs}}
 {{if .Doc}}
@@ -17,9 +16,6 @@ pub struct {{.Name}} {
 {{- range .Fields}}
 {{- if .NeedsDefault}}
     #[serde(default)]
-{{- end}}
-{{- if .IsByteSlice}}
-    #[serde(with = "base64_bytes")]
 {{- end}}
     pub {{.RustName}}: {{fieldRustType .}},
 {{- end}}
@@ -33,22 +29,17 @@ pub struct {{.Name}} {
 #[serde(rename_all = "camelCase")]
 struct {{requestType .}} {
 {{- range .Params}}
-{{- if .IsByteSlice}}
-    #[serde(with = "base64_bytes")]
-{{- end}}
     {{.RustName}}: {{rustType .}},
 {{- end}}
 }
 {{- end}}
+{{- if not .Raw}}
 
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct {{responseType .}} {
 {{- range .Returns}}
     #[serde(default)]
-{{- if .IsByteSlice}}
-    #[serde(with = "base64_bytes")]
-{{- end}}
     {{.RustName}}: {{rustType .}},
 {{- end}}
 {{- if .HasError}}
@@ -57,16 +48,92 @@ struct {{responseType .}} {
 {{- end}}
 }
 {{- end}}
+{{- end}}
 
 #[host_fn]
 extern "ExtismHost" {
 {{- range .Service.Methods}}
+{{- if not .Raw}}
     fn {{exportName .}}(input: Json<{{if .HasParams}}{{requestType .}}{{else}}serde_json::Value{{end}}>) -> Json<{{responseType .}}>;
 {{- end}}
+{{- end}}
 }
+{{- /* Declare raw extern "C" imports for raw methods */ -}}
+{{- range .Service.Methods}}
+{{- if .Raw}}
+
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn {{exportName .}}(offset: u64) -> u64;
+}
+{{- end}}
+{{- end}}
 
 {{- /* Generate wrapper functions */ -}}
 {{range .Service.Methods}}
+{{- if .Raw}}
+
+{{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
+{{- if .HasParams}}
+///
+/// # Arguments
+{{- range .Params}}
+/// * `{{.RustName}}` - {{rustType .}} parameter.
+{{- end}}
+{{- end}}
+///
+/// # Returns
+/// A tuple of (content_type, data) with the raw binary response.
+///
+/// # Errors
+/// Returns an error if the host function call fails.
+pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName}}: {{rustParamType $p}}{{end}}) -> Result<(String, Vec<u8>), Error> {
+{{- if .HasParams}}
+    let req = {{requestType .}} {
+{{- range .Params}}
+        {{.RustName}}: {{.RustName}}{{if .NeedsToOwned}}.to_owned(){{end}},
+{{- end}}
+    };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+{{- else}}
+    let input_bytes = b"{}".to_vec();
+{{- end}}
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
+
+    let response_offset = unsafe { {{exportName .}}(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
+    }
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
+}
+{{- else}}
 
 {{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
@@ -142,3 +209,4 @@ pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName
 }
 {{- end}}
 {{- end}}
+{{- end}}

plugins/cmd/ndpgen/internal/templates/host.go.tmpl

@@ -4,6 +4,9 @@ package {{.Package}}
 
 import (
 	"context"
+{{- if .Service.HasRawMethods}}
+	"encoding/binary"
+{{- end}}
 	"encoding/json"
 
 	extism "github.com/extism/go-sdk"
@@ -20,6 +23,7 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
+{{- if not .Raw}}
 
 // {{responseType .}} is the response type for {{$.Service.Name}}.{{.Name}}.
 type {{responseType .}} struct {
@@ -30,6 +34,7 @@ type {{responseType .}} struct {
 	Error string `json:"error,omitempty"`
 {{- end}}
 }
+{{- end}}
 {{end}}
 
 // Register{{.Service.Name}}HostFunctions registers {{.Service.Name}} service host functions.
@@ -51,18 +56,48 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 			// Read JSON request from plugin memory
 			reqBytes, err := p.ReadBytes(stack[0])
 			if err != nil {
+{{- if .Raw}}
+				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
+{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
+{{- end}}
 				return
 			}
 			var req {{requestType .}}
 			if err := json.Unmarshal(reqBytes, &req); err != nil {
+{{- if .Raw}}
+				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
+{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
+{{- end}}
 				return
 			}
 {{- end}}
 
 			// Call the service method
-{{- if .HasReturns}}
+{{- if .Raw}}
+			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
+			if svcErr != nil {
+				{{$.Service.Name | lower}}WriteRawError(p, stack, svcErr)
+				return
+			}
+
+			// Write binary-framed response to plugin memory:
+			// [0x00][4-byte content-type length (big-endian)][content-type string][raw data]
+			ctBytes := []byte({{lower (index .Returns 0).Name}})
+			frame := make([]byte, 1+4+len(ctBytes)+len({{lower (index .Returns 1).Name}}))
+			frame[0] = 0x00 // success
+			binary.BigEndian.PutUint32(frame[1:5], uint32(len(ctBytes)))
+			copy(frame[5:5+len(ctBytes)], ctBytes)
+			copy(frame[5+len(ctBytes):], {{lower (index .Returns 1).Name}})
+
+			respPtr, err := p.WriteBytes(frame)
+			if err != nil {
+				stack[0] = 0
+				return
+			}
+			stack[0] = respPtr
+{{- else if .HasReturns}}
 {{- if .HasError}}
 			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
 			if svcErr != nil {
@@ -127,3 +162,16 @@ func {{.Service.Name | lower}}WriteError(p *extism.CurrentPlugin, stack []uint64
 	respPtr, _ := p.WriteBytes(respBytes)
 	stack[0] = respPtr
 }
+{{- if .Service.HasRawMethods}}
+
+// {{.Service.Name | lower}}WriteRawError writes a binary-framed error response to plugin memory.
+// Format: [0x01][UTF-8 error message]
+func {{.Service.Name | lower}}WriteRawError(p *extism.CurrentPlugin, stack []uint64, err error) {
+	errMsg := []byte(err.Error())
+	frame := make([]byte, 1+len(errMsg))
+	frame[0] = 0x01 // error
+	copy(frame[1:], errMsg)
+	respPtr, _ := p.WriteBytes(frame)
+	stack[0] = respPtr
+}
+{{- end}}

plugins/cmd/ndpgen/internal/types.go

@@ -173,6 +173,16 @@ func (s Service) HasErrors() bool {
 	return false
 }
 
+// HasRawMethods returns true if any method in the service uses raw binary framing.
+func (s Service) HasRawMethods() bool {
+	for _, m := range s.Methods {
+		if m.Raw {
+			return true
+		}
+	}
+	return false
+}
+
 // Method represents a host function method within a service.
 type Method struct {
 	Name       string  // Go method name (e.g., "Call")
@@ -181,6 +191,7 @@ type Method struct {
 	Returns    []Param // Return values (excluding error)
 	HasError   bool    // Whether the method returns an error
 	Doc        string  // Documentation comment for the method
+	Raw        bool    // If true, response uses binary framing instead of JSON
 }
 
 // FunctionName returns the Extism host function export name.
@@ -332,52 +343,6 @@ type Param struct {
 	JSONName string // JSON field name (camelCase)
 }
 
-// IsByteSlice returns true if the parameter type is []byte.
-func (p Param) IsByteSlice() bool {
-	return p.Type == "[]byte"
-}
-
-// IsByteSlice returns true if the field type is []byte.
-func (f FieldDef) IsByteSlice() bool {
-	return f.Type == "[]byte"
-}
-
-// HasByteFields returns true if any method params, returns, or struct fields use []byte.
-func (s Service) HasByteFields() bool {
-	for _, m := range s.Methods {
-		for _, p := range m.Params {
-			if p.IsByteSlice() {
-				return true
-			}
-		}
-		for _, r := range m.Returns {
-			if r.IsByteSlice() {
-				return true
-			}
-		}
-	}
-	for _, st := range s.Structs {
-		for _, f := range st.Fields {
-			if f.IsByteSlice() {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// HasByteFields returns true if any capability struct fields use []byte.
-func (c Capability) HasByteFields() bool {
-	for _, st := range c.Structs {
-		for _, f := range st.Fields {
-			if f.IsByteSlice() {
-				return true
-			}
-		}
-	}
-	return false
-}
-
 // NewParam creates a Param with auto-generated JSON name.
 func NewParam(name, typ string) Param {
 	return Param{

plugins/cmd/ndpgen/testdata/codec_client_expected.py

@@ -12,7 +12,6 @@ from typing import Any
 
 import extism
 import json
-import base64
 
 
 class HostFunctionError(Exception):
@@ -39,7 +38,7 @@ def codec_encode(data: bytes) -> bytes:
         HostFunctionError: If the host function returns an error.
     """
     request = {
-        "data": base64.b64encode(data).decode("ascii"),
+        "data": data,
     }
     request_bytes = json.dumps(request).encode("utf-8")
     request_mem = extism.memory.alloc(request_bytes)
@@ -50,4 +49,4 @@ def codec_encode(data: bytes) -> bytes:
     if response.get("error"):
         raise HostFunctionError(response["error"])
 
-    return base64.b64decode(response.get("result", ""))
+    return response.get("result", b"")

plugins/cmd/ndpgen/testdata/codec_client_expected.rs

@@ -5,34 +5,10 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct CodecEncodeRequest {
-    #[serde(with = "base64_bytes")]
     data: Vec<u8>,
 }
 
@@ -40,7 +16,6 @@ struct CodecEncodeRequest {
 #[serde(rename_all = "camelCase")]
 struct CodecEncodeResponse {
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     result: Vec<u8>,
     #[serde(default)]
     error: Option<String>,

plugins/cmd/ndpgen/testdata/comprehensive_client_expected.py

@@ -12,7 +12,6 @@ from typing import Any
 
 import extism
 import json
-import base64
 
 
 class HostFunctionError(Exception):
@@ -328,7 +327,7 @@ def comprehensive_byte_slice(data: bytes) -> bytes:
         HostFunctionError: If the host function returns an error.
     """
     request = {
-        "data": base64.b64encode(data).decode("ascii"),
+        "data": data,
     }
     request_bytes = json.dumps(request).encode("utf-8")
     request_mem = extism.memory.alloc(request_bytes)
@@ -339,4 +338,4 @@ def comprehensive_byte_slice(data: bytes) -> bytes:
     if response.get("error"):
         raise HostFunctionError(response["error"])
 
-    return base64.b64decode(response.get("result", ""))
+    return response.get("result", b"")

plugins/cmd/ndpgen/testdata/comprehensive_client_expected.rs

@@ -5,29 +5,6 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -167,7 +144,6 @@ struct ComprehensiveMultipleReturnsResponse {
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct ComprehensiveByteSliceRequest {
-    #[serde(with = "base64_bytes")]
     data: Vec<u8>,
 }
 
@@ -175,7 +151,6 @@ struct ComprehensiveByteSliceRequest {
 #[serde(rename_all = "camelCase")]
 struct ComprehensiveByteSliceResponse {
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     result: Vec<u8>,
     #[serde(default)]
     error: Option<String>,

plugins/cmd/ndpgen/testdata/raw_client_expected.go.txt

@@ -0,0 +1,66 @@
+// Code generated by ndpgen. DO NOT EDIT.
+//
+// This file contains client wrappers for the Stream host service.
+// It is intended for use in Navidrome plugins built with TinyGo.
+//
+//go:build wasip1
+
+package ndpdk
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+
+	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
+)
+
+// stream_getstream is the host function provided by Navidrome.
+//
+//go:wasmimport extism:host/user stream_getstream
+func stream_getstream(uint64) uint64
+
+type streamGetStreamRequest struct {
+	Uri string `json:"uri"`
+}
+
+// StreamGetStream calls the stream_getstream host function.
+// GetStream returns raw binary stream data with content type.
+func StreamGetStream(uri string) (string, []byte, error) {
+	// Marshal request to JSON
+	req := streamGetStreamRequest{
+		Uri: uri,
+	}
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return "", nil, err
+	}
+	reqMem := pdk.AllocateBytes(reqBytes)
+	defer reqMem.Free()
+
+	// Call the host function
+	responsePtr := stream_getstream(reqMem.Offset())
+
+	// Read the response from memory
+	responseMem := pdk.FindMemory(responsePtr)
+	responseBytes := responseMem.ReadBytes()
+
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
+	}
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
+	}
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
+}

plugins/cmd/ndpgen/testdata/raw_client_expected.py

@@ -0,0 +1,63 @@
+# Code generated by ndpgen. DO NOT EDIT.
+#
+# This file contains client wrappers for the Stream host service.
+# It is intended for use in Navidrome plugins built with extism-py.
+#
+# IMPORTANT: Due to a limitation in extism-py, you cannot import this file directly.
+# The @extism.import_fn decorators are only detected when defined in the plugin's
+# main __init__.py file. Copy the needed functions from this file into your plugin.
+
+from dataclasses import dataclass
+from typing import Any, Tuple
+
+import extism
+import json
+import struct
+
+
+class HostFunctionError(Exception):
+    """Raised when a host function returns an error."""
+    pass
+
+
+@extism.import_fn("extism:host/user", "stream_getstream")
+def _stream_getstream(offset: int) -> int:
+    """Raw host function - do not call directly."""
+    ...
+
+
+def stream_get_stream(uri: str) -> Tuple[str, bytes]:
+    """GetStream returns raw binary stream data with content type.
+
+    Args:
+        uri: str parameter.
+
+    Returns:
+        Tuple of (content_type, data) with the raw binary response.
+
+    Raises:
+        HostFunctionError: If the host function returns an error.
+    """
+    request = {
+        "uri": uri,
+    }
+    request_bytes = json.dumps(request).encode("utf-8")
+    request_mem = extism.memory.alloc(request_bytes)
+    response_offset = _stream_getstream(request_mem.offset)
+    response_mem = extism.memory.find(response_offset)
+    response_bytes = response_mem.bytes()
+
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data

plugins/cmd/ndpgen/testdata/raw_client_expected.rs

@@ -0,0 +1,73 @@
+// Code generated by ndpgen. DO NOT EDIT.
+//
+// This file contains client wrappers for the Stream host service.
+// It is intended for use in Navidrome plugins built with extism-pdk.
+
+use extism_pdk::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StreamGetStreamRequest {
+    uri: String,
+}
+
+#[host_fn]
+extern "ExtismHost" {
+}
+
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn stream_getstream(offset: u64) -> u64;
+}
+
+/// GetStream returns raw binary stream data with content type.
+///
+/// # Arguments
+/// * `uri` - String parameter.
+///
+/// # Returns
+/// A tuple of (content_type, data) with the raw binary response.
+///
+/// # Errors
+/// Returns an error if the host function call fails.
+pub fn get_stream(uri: &str) -> Result<(String, Vec<u8>), Error> {
+    let req = StreamGetStreamRequest {
+        uri: uri.to_owned(),
+    };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
+
+    let response_offset = unsafe { stream_getstream(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
+    }
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
+}

plugins/cmd/ndpgen/testdata/raw_service.go.txt

@@ -0,0 +1,10 @@
+package testpkg
+
+import "context"
+
+//nd:hostservice name=Stream permission=stream
+type StreamService interface {
+	// GetStream returns raw binary stream data with content type.
+	//nd:hostfunc raw=true
+	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}

plugins/host/subsonicapi.go

@@ -17,8 +17,8 @@ type SubsonicAPIService interface {
 	Call(ctx context.Context, uri string) (responseJSON string, err error)
 
 	// CallRaw executes a Subsonic API request and returns the raw binary response.
-	// Designed for binary endpoints like getCoverArt and stream that return
-	// non-JSON data. The data is base64-encoded over JSON on the wire.
-	//nd:hostfunc
+	// Optimized for binary endpoints like getCoverArt and stream that return
+	// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+	//nd:hostfunc raw=true
 	CallRaw(ctx context.Context, uri string) (contentType string, data []byte, err error)
 }

plugins/host/subsonicapi_gen.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"context"
+	"encoding/binary"
 	"encoding/json"
 
 	extism "github.com/extism/go-sdk"
@@ -25,13 +26,6 @@ type SubsonicAPICallRawRequest struct {
 	Uri string `json:"uri"`
 }
 
-// SubsonicAPICallRawResponse is the response type for SubsonicAPI.CallRaw.
-type SubsonicAPICallRawResponse struct {
-	ContentType string `json:"contentType,omitempty"`
-	Data        []byte `json:"data,omitempty"`
-	Error       string `json:"error,omitempty"`
-}
-
 // RegisterSubsonicAPIHostFunctions registers SubsonicAPI service host functions.
 // The returned host functions should be added to the plugin's configuration.
 func RegisterSubsonicAPIHostFunctions(service SubsonicAPIService) []extism.HostFunction {
@@ -82,28 +76,37 @@ func newSubsonicAPICallRawHostFunction(service SubsonicAPIService) extism.HostFu
 			// Read JSON request from plugin memory
 			reqBytes, err := p.ReadBytes(stack[0])
 			if err != nil {
-				subsonicapiWriteError(p, stack, err)
+				subsonicapiWriteRawError(p, stack, err)
 				return
 			}
 			var req SubsonicAPICallRawRequest
 			if err := json.Unmarshal(reqBytes, &req); err != nil {
-				subsonicapiWriteError(p, stack, err)
+				subsonicapiWriteRawError(p, stack, err)
 				return
 			}
 
 			// Call the service method
 			contenttype, data, svcErr := service.CallRaw(ctx, req.Uri)
 			if svcErr != nil {
-				subsonicapiWriteError(p, stack, svcErr)
+				subsonicapiWriteRawError(p, stack, svcErr)
 				return
 			}
 
-			// Write JSON response to plugin memory
-			resp := SubsonicAPICallRawResponse{
-				ContentType: contenttype,
-				Data:        data,
+			// Write binary-framed response to plugin memory:
+			// [0x00][4-byte content-type length (big-endian)][content-type string][raw data]
+			ctBytes := []byte(contenttype)
+			frame := make([]byte, 1+4+len(ctBytes)+len(data))
+			frame[0] = 0x00 // success
+			binary.BigEndian.PutUint32(frame[1:5], uint32(len(ctBytes)))
+			copy(frame[5:5+len(ctBytes)], ctBytes)
+			copy(frame[5+len(ctBytes):], data)
+
+			respPtr, err := p.WriteBytes(frame)
+			if err != nil {
+				stack[0] = 0
+				return
 			}
-			subsonicapiWriteResponse(p, stack, resp)
+			stack[0] = respPtr
 		},
 		[]extism.ValueType{extism.ValueTypePTR},
 		[]extism.ValueType{extism.ValueTypePTR},
@@ -134,3 +137,14 @@ func subsonicapiWriteError(p *extism.CurrentPlugin, stack []uint64, err error) {
 	respPtr, _ := p.WriteBytes(respBytes)
 	stack[0] = respPtr
 }
+
+// subsonicapiWriteRawError writes a binary-framed error response to plugin memory.
+// Format: [0x01][UTF-8 error message]
+func subsonicapiWriteRawError(p *extism.CurrentPlugin, stack []uint64, err error) {
+	errMsg := []byte(err.Error())
+	frame := make([]byte, 1+len(errMsg))
+	frame[0] = 0x01 // error
+	copy(frame[1:], errMsg)
+	respPtr, _ := p.WriteBytes(frame)
+	stack[0] = respPtr
+}

plugins/host_scheduler.go

@@ -188,6 +188,12 @@ func (s *schedulerServiceImpl) invokeCallback(ctx context.Context, scheduleID st
 		return
 	}
 
+	// Check if plugin has the scheduler capability
+	if !hasCapability(instance.capabilities, CapabilityScheduler) {
+		log.Warn(ctx, "Plugin does not have scheduler capability", "plugin", s.pluginName, "scheduleID", scheduleID)
+		return
+	}
+
 	// Prepare callback input
 	input := capabilities.SchedulerCallbackRequest{
 		ScheduleID:  scheduleID,

plugins/manager.go

@@ -428,11 +428,10 @@ func (m *Manager) UpdatePluginUsers(ctx context.Context, id, usersJSON string, a
 // If the plugin is enabled, it will be reloaded with the new settings.
 // If the plugin requires library permission and no libraries are configured (and allLibraries is false),
 // the plugin will be automatically disabled.
-func (m *Manager) UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries, allowWriteAccess bool) error {
+func (m *Manager) UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries bool) error {
 	return m.updatePluginSettings(ctx, id, func(p *model.Plugin) {
 		p.Libraries = librariesJSON
 		p.AllLibraries = allLibraries
-		p.AllowWriteAccess = allowWriteAccess
 	})
 }
 

plugins/manager_loader.go

@@ -226,8 +226,6 @@ func (m *Manager) loadEnabledPlugins(ctx context.Context) error {
 // loadPluginWithConfig loads a plugin with configuration from DB.
 // The p.Path should point to an .ndp package file.
 func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
-	ctx := log.NewContext(m.ctx, "plugin", p.ID)
-
 	if m.stopped.Load() {
 		return fmt.Errorf("manager is stopped")
 	}
@@ -285,13 +283,27 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 
 	// Configure filesystem access for library permission
 	if pkg.Manifest.Permissions != nil && pkg.Manifest.Permissions.Library != nil && pkg.Manifest.Permissions.Library.Filesystem {
-		adminCtx := adminContext(ctx)
+		adminCtx := adminContext(m.ctx)
 		libraries, err := m.ds.Library(adminCtx).GetAll()
 		if err != nil {
 			return fmt.Errorf("failed to get libraries for filesystem access: %w", err)
 		}
 
-		allowedPaths := buildAllowedPaths(ctx, libraries, allowedLibraries, p.AllLibraries, p.AllowWriteAccess)
+		// Build a set of allowed library IDs for fast lookup
+		allowedLibrarySet := make(map[int]struct{}, len(allowedLibraries))
+		for _, id := range allowedLibraries {
+			allowedLibrarySet[id] = struct{}{}
+		}
+
+		allowedPaths := make(map[string]string)
+		for _, lib := range libraries {
+			// Only mount if allLibraries is true or library is in the allowed list
+			if p.AllLibraries {
+				allowedPaths[lib.Path] = toPluginMountPoint(int32(lib.ID))
+			} else if _, ok := allowedLibrarySet[lib.ID]; ok {
+				allowedPaths[lib.Path] = toPluginMountPoint(int32(lib.ID))
+			}
+		}
 		pluginManifest.AllowedPaths = allowedPaths
 	}
 
@@ -327,7 +339,7 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 	// Enable experimental threads if requested in manifest
 	if pkg.Manifest.HasExperimentalThreads() {
 		runtimeConfig = runtimeConfig.WithCoreFeatures(api.CoreFeaturesV2 | experimental.CoreFeaturesThreads)
-		log.Debug(ctx, "Enabling experimental threads support")
+		log.Debug(m.ctx, "Enabling experimental threads support", "plugin", p.ID)
 	}
 
 	extismConfig := extism.PluginConfig{
@@ -335,24 +347,24 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 		RuntimeConfig:             runtimeConfig,
 		EnableHttpResponseHeaders: true,
 	}
-	compiled, err := extism.NewCompiledPlugin(ctx, pluginManifest, extismConfig, hostFunctions)
+	compiled, err := extism.NewCompiledPlugin(m.ctx, pluginManifest, extismConfig, hostFunctions)
 	if err != nil {
 		return fmt.Errorf("compiling plugin: %w", err)
 	}
 
 	// Create instance to detect capabilities
-	instance, err := compiled.Instance(ctx, extism.PluginInstanceConfig{})
+	instance, err := compiled.Instance(m.ctx, extism.PluginInstanceConfig{})
 	if err != nil {
-		compiled.Close(ctx)
+		compiled.Close(m.ctx)
 		return fmt.Errorf("creating instance: %w", err)
 	}
 	instance.SetLogger(extismLogger(p.ID))
 	capabilities := detectCapabilities(instance)
-	instance.Close(ctx)
+	instance.Close(m.ctx)
 
 	// Validate manifest against detected capabilities
 	if err := ValidateWithCapabilities(pkg.Manifest, capabilities); err != nil {
-		compiled.Close(ctx)
+		compiled.Close(m.ctx)
 		return fmt.Errorf("manifest validation: %w", err)
 	}
 
@@ -371,7 +383,7 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 	m.mu.Unlock()
 
 	// Call plugin init function
-	callPluginInit(ctx, m.plugins[p.ID])
+	callPluginInit(m.ctx, m.plugins[p.ID])
 
 	return nil
 }
@@ -402,29 +414,3 @@ func parsePluginConfig(configJSON string) (map[string]string, error) {
 	}
 	return pluginConfig, nil
 }
-
-// buildAllowedPaths constructs the extism AllowedPaths map for filesystem access.
-// When allowWriteAccess is false (default), paths are prefixed with "ro:" for read-only.
-// Only libraries that match the allowed set (or all libraries if allLibraries is true) are included.
-func buildAllowedPaths(ctx context.Context, libraries model.Libraries, allowedLibraryIDs []int, allLibraries, allowWriteAccess bool) map[string]string {
-	allowedLibrarySet := make(map[int]struct{}, len(allowedLibraryIDs))
-	for _, id := range allowedLibraryIDs {
-		allowedLibrarySet[id] = struct{}{}
-	}
-
-	allowedPaths := make(map[string]string)
-	for _, lib := range libraries {
-		_, allowed := allowedLibrarySet[lib.ID]
-		if allLibraries || allowed {
-			mountPoint := toPluginMountPoint(int32(lib.ID))
-			if allowWriteAccess {
-				log.Info(ctx, "Granting read-write filesystem access to library", "libraryID", lib.ID, "mountPoint", mountPoint)
-				allowedPaths[lib.Path] = mountPoint
-			} else {
-				log.Debug(ctx, "Granting read-only filesystem access to library", "libraryID", lib.ID, "mountPoint", mountPoint)
-				allowedPaths["ro:"+lib.Path] = mountPoint
-			}
-		}
-	}
-	return allowedPaths
-}

plugins/manager_loader_test.go

@@ -3,7 +3,6 @@
 package plugins
 
 import (
-	"github.com/navidrome/navidrome/model"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@@ -59,66 +58,3 @@ var _ = Describe("parsePluginConfig", func() {
 		Expect(result).ToNot(BeNil())
 	})
 })
-
-var _ = Describe("buildAllowedPaths", func() {
-	var libraries model.Libraries
-
-	BeforeEach(func() {
-		libraries = model.Libraries{
-			{ID: 1, Path: "/music/library1"},
-			{ID: 2, Path: "/music/library2"},
-			{ID: 3, Path: "/music/library3"},
-		}
-	})
-
-	Context("read-only (default)", func() {
-		It("mounts all libraries with ro: prefix when allLibraries is true", func() {
-			result := buildAllowedPaths(nil, libraries, nil, true, false)
-			Expect(result).To(HaveLen(3))
-			Expect(result).To(HaveKeyWithValue("ro:/music/library1", "/libraries/1"))
-			Expect(result).To(HaveKeyWithValue("ro:/music/library2", "/libraries/2"))
-			Expect(result).To(HaveKeyWithValue("ro:/music/library3", "/libraries/3"))
-		})
-
-		It("mounts only selected libraries with ro: prefix", func() {
-			result := buildAllowedPaths(nil, libraries, []int{1, 3}, false, false)
-			Expect(result).To(HaveLen(2))
-			Expect(result).To(HaveKeyWithValue("ro:/music/library1", "/libraries/1"))
-			Expect(result).To(HaveKeyWithValue("ro:/music/library3", "/libraries/3"))
-			Expect(result).ToNot(HaveKey("ro:/music/library2"))
-		})
-	})
-
-	Context("read-write (allowWriteAccess=true)", func() {
-		It("mounts all libraries without ro: prefix when allLibraries is true", func() {
-			result := buildAllowedPaths(nil, libraries, nil, true, true)
-			Expect(result).To(HaveLen(3))
-			Expect(result).To(HaveKeyWithValue("/music/library1", "/libraries/1"))
-			Expect(result).To(HaveKeyWithValue("/music/library2", "/libraries/2"))
-			Expect(result).To(HaveKeyWithValue("/music/library3", "/libraries/3"))
-		})
-
-		It("mounts only selected libraries without ro: prefix", func() {
-			result := buildAllowedPaths(nil, libraries, []int{2}, false, true)
-			Expect(result).To(HaveLen(1))
-			Expect(result).To(HaveKeyWithValue("/music/library2", "/libraries/2"))
-		})
-	})
-
-	Context("edge cases", func() {
-		It("returns empty map when no libraries match", func() {
-			result := buildAllowedPaths(nil, libraries, []int{99}, false, false)
-			Expect(result).To(BeEmpty())
-		})
-
-		It("returns empty map when libraries list is empty", func() {
-			result := buildAllowedPaths(nil, nil, []int{1}, false, false)
-			Expect(result).To(BeEmpty())
-		})
-
-		It("returns empty map when allLibraries is false and no IDs provided", func() {
-			result := buildAllowedPaths(nil, libraries, nil, false, false)
-			Expect(result).To(BeEmpty())
-		})
-	})
-})

plugins/manifest.go

@@ -64,14 +64,6 @@ func ValidateWithCapabilities(m *Manifest, capabilities []Capability) error {
 			return fmt.Errorf("scrobbler capability requires 'users' permission to be declared in manifest")
 		}
 	}
-
-	// Scheduler permission requires SchedulerCallback capability
-	if m.Permissions != nil && m.Permissions.Scheduler != nil {
-		if !hasCapability(capabilities, CapabilityScheduler) {
-			return fmt.Errorf("'scheduler' permission requires plugin to export '%s' function", FuncSchedulerCallback)
-		}
-	}
-
 	return nil
 }
 

plugins/pdk/go/go.mod

@@ -6,10 +6,3 @@ require (
 	github.com/extism/go-pdk v1.1.3
 	github.com/stretchr/testify v1.11.1
 )
-
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

plugins/pdk/go/host/nd_host_httpclient.go

@@ -14,7 +14,6 @@ import (
 	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
 )
 
-// HTTPRequest represents the HTTPRequest data structure.
 // HTTPRequest represents an outbound HTTP request from a plugin.
 type HTTPRequest struct {
 	Method    string            `json:"method"`
@@ -24,7 +23,6 @@ type HTTPRequest struct {
 	TimeoutMs int32             `json:"timeoutMs"`
 }
 
-// HTTPResponse represents the HTTPResponse data structure.
 // HTTPResponse represents the response from an outbound HTTP request.
 type HTTPResponse struct {
 	StatusCode int32             `json:"statusCode"`
@@ -37,11 +35,11 @@ type HTTPResponse struct {
 //go:wasmimport extism:host/user http_send
 func http_send(uint64) uint64
 
-type hTTPSendRequest struct {
+type httpSendRequest struct {
 	Request HTTPRequest `json:"request"`
 }
 
-type hTTPSendResponse struct {
+type httpSendResponse struct {
 	Result *HTTPResponse `json:"result,omitempty"`
 	Error  string        `json:"error,omitempty"`
 }
@@ -57,7 +55,7 @@ type hTTPSendResponse struct {
 // Successful HTTP calls (including 4xx/5xx status codes) return a non-nil response with nil error.
 func HTTPSend(request HTTPRequest) (*HTTPResponse, error) {
 	// Marshal request to JSON
-	req := hTTPSendRequest{
+	req := httpSendRequest{
 		Request: request,
 	}
 	reqBytes, err := json.Marshal(req)
@@ -75,7 +73,7 @@ func HTTPSend(request HTTPRequest) (*HTTPResponse, error) {
 	responseBytes := responseMem.ReadBytes()
 
 	// Parse the response
-	var response hTTPSendResponse
+	var response httpSendResponse
 	if err := json.Unmarshal(responseBytes, &response); err != nil {
 		return nil, err
 	}

plugins/pdk/go/host/nd_host_httpclient_stub.go

@@ -10,7 +10,6 @@ package host
 
 import "github.com/stretchr/testify/mock"
 
-// HTTPRequest represents the HTTPRequest data structure.
 // HTTPRequest represents an outbound HTTP request from a plugin.
 type HTTPRequest struct {
 	Method    string            `json:"method"`
@@ -20,7 +19,6 @@ type HTTPRequest struct {
 	TimeoutMs int32             `json:"timeoutMs"`
 }
 
-// HTTPResponse represents the HTTPResponse data structure.
 // HTTPResponse represents the response from an outbound HTTP request.
 type HTTPResponse struct {
 	StatusCode int32             `json:"statusCode"`

plugins/pdk/go/host/nd_host_subsonicapi.go

@@ -8,6 +8,7 @@
 package host
 
 import (
+	"encoding/binary"
 	"encoding/json"
 	"errors"
 
@@ -37,12 +38,6 @@ type subsonicAPICallRawRequest struct {
 	Uri string `json:"uri"`
 }
 
-type subsonicAPICallRawResponse struct {
-	ContentType string `json:"contentType,omitempty"`
-	Data        []byte `json:"data,omitempty"`
-	Error       string `json:"error,omitempty"`
-}
-
 // SubsonicAPICall calls the subsonicapi_call host function.
 // Call executes a Subsonic API request and returns the JSON response.
 //
@@ -83,8 +78,8 @@ func SubsonicAPICall(uri string) (string, error) {
 
 // SubsonicAPICallRaw calls the subsonicapi_callraw host function.
 // CallRaw executes a Subsonic API request and returns the raw binary response.
-// Designed for binary endpoints like getCoverArt and stream that return
-// non-JSON data. The data is base64-encoded over JSON on the wire.
+// Optimized for binary endpoints like getCoverArt and stream that return
+// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
 func SubsonicAPICallRaw(uri string) (string, []byte, error) {
 	// Marshal request to JSON
 	req := subsonicAPICallRawRequest{
@@ -104,16 +99,22 @@ func SubsonicAPICallRaw(uri string) (string, []byte, error) {
 	responseMem := pdk.FindMemory(responsePtr)
 	responseBytes := responseMem.ReadBytes()
 
-	// Parse the response
-	var response subsonicAPICallRawResponse
-	if err := json.Unmarshal(responseBytes, &response); err != nil {
-		return "", nil, err
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
 	}
-
-	// Convert Error field to Go error
-	if response.Error != "" {
-		return "", nil, errors.New(response.Error)
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
 	}
-
-	return response.ContentType, response.Data, nil
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
 }

plugins/pdk/go/host/nd_host_subsonicapi_stub.go

@@ -42,8 +42,8 @@ func (m *mockSubsonicAPIService) CallRaw(uri string) (string, []byte, error) {
 
 // SubsonicAPICallRaw delegates to the mock instance.
 // CallRaw executes a Subsonic API request and returns the raw binary response.
-// Designed for binary endpoints like getCoverArt and stream that return
-// non-JSON data. The data is base64-encoded over JSON on the wire.
+// Optimized for binary endpoints like getCoverArt and stream that return
+// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
 func SubsonicAPICallRaw(uri string) (string, []byte, error) {
 	return SubsonicAPIMock.CallRaw(uri)
 }

plugins/pdk/python/host/nd_host_cache.py

@@ -12,7 +12,6 @@ from typing import Any
 
 import extism
 import json
-import base64
 
 
 class HostFunctionError(Exception):
@@ -338,7 +337,7 @@ Returns an error if the operation fails.
     """
     request = {
         "key": key,
-        "value": base64.b64encode(value).decode("ascii"),
+        "value": value,
         "ttlSeconds": ttl_seconds,
     }
     request_bytes = json.dumps(request).encode("utf-8")
@@ -383,7 +382,7 @@ or the stored value is not a byte slice, exists will be false.
         raise HostFunctionError(response["error"])
 
     return CacheGetBytesResult(
-        value=base64.b64decode(response.get("value", "")),
+        value=response.get("value", b""),
         exists=response.get("exists", False),
     )
 

plugins/pdk/python/host/nd_host_http.py

@@ -1,60 +0,0 @@
-# Code generated by ndpgen. DO NOT EDIT.
-#
-# This file contains client wrappers for the HTTP host service.
-# It is intended for use in Navidrome plugins built with extism-py.
-#
-# IMPORTANT: Due to a limitation in extism-py, you cannot import this file directly.
-# The @extism.import_fn decorators are only detected when defined in the plugin's
-# main __init__.py file. Copy the needed functions from this file into your plugin.
-
-from dataclasses import dataclass
-from typing import Any
-
-import extism
-import json
-import base64
-
-
-class HostFunctionError(Exception):
-    """Raised when a host function returns an error."""
-    pass
-
-
-@extism.import_fn("extism:host/user", "http_send")
-def _http_send(offset: int) -> int:
-    """Raw host function - do not call directly."""
-    ...
-
-
-def http_send(request: Any) -> Any:
-    """Send executes an HTTP request and returns the response.
-
-Parameters:
-  - request: The HTTP request to execute, including method, URL, headers, body, and timeout
-
-Returns the HTTP response with status code, headers, and body.
-Network errors, timeouts, and permission failures are returned as Go errors.
-Successful HTTP calls (including 4xx/5xx status codes) return a non-nil response with nil error.
-
-    Args:
-        request: Any parameter.
-
-    Returns:
-        Any: The result value.
-
-    Raises:
-        HostFunctionError: If the host function returns an error.
-    """
-    request = {
-        "request": request,
-    }
-    request_bytes = json.dumps(request).encode("utf-8")
-    request_mem = extism.memory.alloc(request_bytes)
-    response_offset = _http_send(request_mem.offset)
-    response_mem = extism.memory.find(response_offset)
-    response = json.loads(extism.memory.string(response_mem))
-
-    if response.get("error"):
-        raise HostFunctionError(response["error"])
-
-    return response.get("result", None)

plugins/pdk/python/host/nd_host_kvstore.py

@@ -12,7 +12,6 @@ from typing import Any
 
 import extism
 import json
-import base64
 
 
 class HostFunctionError(Exception):
@@ -81,7 +80,7 @@ Returns an error if the storage limit would be exceeded or the operation fails.
     """
     request = {
         "key": key,
-        "value": base64.b64encode(value).decode("ascii"),
+        "value": value,
     }
     request_bytes = json.dumps(request).encode("utf-8")
     request_mem = extism.memory.alloc(request_bytes)
@@ -124,7 +123,7 @@ Returns the value and whether the key exists.
         raise HostFunctionError(response["error"])
 
     return KVStoreGetResult(
-        value=base64.b64decode(response.get("value", "")),
+        value=response.get("value", b""),
         exists=response.get("exists", False),
     )
 

plugins/pdk/python/host/nd_host_subsonicapi.py

@@ -8,11 +8,11 @@
 # main __init__.py file. Copy the needed functions from this file into your plugin.
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Tuple
 
 import extism
 import json
-import base64
+import struct
 
 
 class HostFunctionError(Exception):
@@ -32,13 +32,6 @@ def _subsonicapi_callraw(offset: int) -> int:
     ...
 
 
-@dataclass
-class SubsonicAPICallRawResult:
-    """Result type for subsonicapi_call_raw."""
-    content_type: str
-    data: bytes
-
-
 def subsonicapi_call(uri: str) -> str:
     """Call executes a Subsonic API request and returns the JSON response.
 
@@ -69,16 +62,16 @@ e.g., "getAlbumList2?type=random&size=10". The response is returned as raw JSON.
     return response.get("responseJson", "")
 
 
-def subsonicapi_call_raw(uri: str) -> SubsonicAPICallRawResult:
+def subsonicapi_call_raw(uri: str) -> Tuple[str, bytes]:
     """CallRaw executes a Subsonic API request and returns the raw binary response.
-Designed for binary endpoints like getCoverArt and stream that return
-non-JSON data. The data is base64-encoded over JSON on the wire.
+Optimized for binary endpoints like getCoverArt and stream that return
+non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
 
     Args:
         uri: str parameter.
 
     Returns:
-        SubsonicAPICallRawResult containing content_type, data,.
+        Tuple of (content_type, data) with the raw binary response.
 
     Raises:
         HostFunctionError: If the host function returns an error.
@@ -90,12 +83,19 @@ non-JSON data. The data is base64-encoded over JSON on the wire.
     request_mem = extism.memory.alloc(request_bytes)
     response_offset = _subsonicapi_callraw(request_mem.offset)
     response_mem = extism.memory.find(response_offset)
-    response = json.loads(extism.memory.string(response_mem))
+    response_bytes = response_mem.bytes()
 
-    if response.get("error"):
-        raise HostFunctionError(response["error"])
-
-    return SubsonicAPICallRawResult(
-        content_type=response.get("contentType", ""),
-        data=base64.b64decode(response.get("data", "")),
-    )
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data

plugins/pdk/python/host/nd_host_websocket.py

@@ -12,7 +12,6 @@ from typing import Any
 
 import extism
 import json
-import base64
 
 
 class HostFunctionError(Exception):
@@ -135,7 +134,7 @@ Returns an error if the connection is not found or if sending fails.
     """
     request = {
         "connectionId": connection_id,
-        "data": base64.b64encode(data).decode("ascii"),
+        "data": data,
     }
     request_bytes = json.dumps(request).encode("utf-8")
     request_mem = extism.memory.alloc(request_bytes)

plugins/pdk/rust/nd-pdk-capabilities/Cargo.toml

@@ -11,7 +11,6 @@ path = "src/lib.rs"
 crate-type = ["rlib"]
 
 [dependencies]
-base64 = "0.22"
 extism-pdk = "1.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

plugins/pdk/rust/nd-pdk-host/Cargo.toml

@@ -11,7 +11,6 @@ readme = "README.md"
 crate-type = ["rlib"]
 
 [dependencies]
-base64 = "0.22"
 extism-pdk = "1.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

plugins/pdk/rust/nd-pdk-host/src/nd_host_cache.rs

@@ -5,29 +5,6 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -129,7 +106,6 @@ struct CacheGetFloatResponse {
 #[serde(rename_all = "camelCase")]
 struct CacheSetBytesRequest {
     key: String,
-    #[serde(with = "base64_bytes")]
     value: Vec<u8>,
     ttl_seconds: i64,
 }
@@ -151,7 +127,6 @@ struct CacheGetBytesRequest {
 #[serde(rename_all = "camelCase")]
 struct CacheGetBytesResponse {
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     value: Vec<u8>,
     #[serde(default)]
     exists: bool,

plugins/pdk/rust/nd-pdk-host/src/nd_host_http.rs

@@ -5,40 +5,16 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 /// HTTPRequest represents an outbound HTTP request from a plugin.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct HTTPRequest {
+pub struct HttpRequest {
     pub method: String,
     pub url: String,
     #[serde(default)]
     pub headers: std::collections::HashMap<String, String>,
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     pub body: Vec<u8>,
     #[serde(default)]
     pub timeout_ms: i32,
@@ -47,26 +23,25 @@ pub struct HTTPRequest {
 /// HTTPResponse represents the response from an outbound HTTP request.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct HTTPResponse {
+pub struct HttpResponse {
     pub status_code: i32,
     #[serde(default)]
     pub headers: std::collections::HashMap<String, String>,
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     pub body: Vec<u8>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct HTTPSendRequest {
-    request: HTTPRequest,
+    request: HttpRequest,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct HTTPSendResponse {
     #[serde(default)]
-    result: Option<HTTPResponse>,
+    result: Option<HttpResponse>,
     #[serde(default)]
     error: Option<String>,
 }
@@ -77,23 +52,23 @@ extern "ExtismHost" {
 }
 
 /// Send executes an HTTP request and returns the response.
-/// 
+///
 /// Parameters:
 ///   - request: The HTTP request to execute, including method, URL, headers, body, and timeout
-/// 
+///
 /// Returns the HTTP response with status code, headers, and body.
-/// Network errors, timeouts, and permission failures are returned as Go errors.
+/// Network errors, timeouts, and permission failures are returned as errors.
 /// Successful HTTP calls (including 4xx/5xx status codes) return a non-nil response with nil error.
 ///
 /// # Arguments
-/// * `request` - HTTPRequest parameter.
+/// * `request` - HttpRequest parameter.
 ///
 /// # Returns
 /// The result value.
 ///
 /// # Errors
 /// Returns an error if the host function call fails.
-pub fn send(request: HTTPRequest) -> Result<Option<HTTPResponse>, Error> {
+pub fn send(request: HttpRequest) -> Result<Option<HttpResponse>, Error> {
     let response = unsafe {
         http_send(Json(HTTPSendRequest {
             request: request,

plugins/pdk/rust/nd-pdk-host/src/nd_host_kvstore.rs

@@ -5,35 +5,11 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct KVStoreSetRequest {
     key: String,
-    #[serde(with = "base64_bytes")]
     value: Vec<u8>,
 }
 
@@ -54,7 +30,6 @@ struct KVStoreGetRequest {
 #[serde(rename_all = "camelCase")]
 struct KVStoreGetResponse {
     #[serde(default)]
-    #[serde(with = "base64_bytes")]
     value: Vec<u8>,
     #[serde(default)]
     exists: bool,

plugins/pdk/rust/nd-pdk-host/src/nd_host_subsonicapi.rs

@@ -5,29 +5,6 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -50,22 +27,14 @@ struct SubsonicAPICallRawRequest {
     uri: String,
 }
 
-#[derive(Debug, Clone, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct SubsonicAPICallRawResponse {
-    #[serde(default)]
-    content_type: String,
-    #[serde(default)]
-    #[serde(with = "base64_bytes")]
-    data: Vec<u8>,
-    #[serde(default)]
-    error: Option<String>,
-}
-
 #[host_fn]
 extern "ExtismHost" {
     fn subsonicapi_call(input: Json<SubsonicAPICallRequest>) -> Json<SubsonicAPICallResponse>;
-    fn subsonicapi_callraw(input: Json<SubsonicAPICallRawRequest>) -> Json<SubsonicAPICallRawResponse>;
+}
+
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn subsonicapi_callraw(offset: u64) -> u64;
 }
 
 /// Call executes a Subsonic API request and returns the JSON response.
@@ -96,27 +65,54 @@ pub fn call(uri: &str) -> Result<String, Error> {
 }
 
 /// CallRaw executes a Subsonic API request and returns the raw binary response.
-/// Designed for binary endpoints like getCoverArt and stream that return
-/// non-JSON data. The data is base64-encoded over JSON on the wire.
+/// Optimized for binary endpoints like getCoverArt and stream that return
+/// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
 ///
 /// # Arguments
 /// * `uri` - String parameter.
 ///
 /// # Returns
-/// A tuple of (content_type, data).
+/// A tuple of (content_type, data) with the raw binary response.
 ///
 /// # Errors
 /// Returns an error if the host function call fails.
 pub fn call_raw(uri: &str) -> Result<(String, Vec<u8>), Error> {
-    let response = unsafe {
-        subsonicapi_callraw(Json(SubsonicAPICallRawRequest {
-            uri: uri.to_owned(),
-        }))?
+    let req = SubsonicAPICallRawRequest {
+        uri: uri.to_owned(),
     };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
 
-    if let Some(err) = response.0.error {
-        return Err(Error::msg(err));
+    let response_offset = unsafe { subsonicapi_callraw(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
     }
-
-    Ok((response.0.content_type, response.0.data))
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
 }

plugins/pdk/rust/nd-pdk-host/src/nd_host_websocket.rs

@@ -5,29 +5,6 @@
 
 use extism_pdk::*;
 use serde::{Deserialize, Serialize};
-use base64::Engine as _;
-use base64::engine::general_purpose::STANDARD as BASE64;
-
-mod base64_bytes {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-    use base64::Engine as _;
-    use base64::engine::general_purpose::STANDARD as BASE64;
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&BASE64.encode(bytes))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        BASE64.decode(&s).map_err(serde::de::Error::custom)
-    }
-}
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -64,7 +41,6 @@ struct WebSocketSendTextResponse {
 #[serde(rename_all = "camelCase")]
 struct WebSocketSendBinaryRequest {
     connection_id: String,
-    #[serde(with = "base64_bytes")]
     data: Vec<u8>,
 }
 

resources/i18n/pt-br.json

@@ -353,8 +353,7 @@
         "allUsers": "Permitir todos os usuários",
         "selectedUsers": "Usuários selecionados",
         "allLibraries": "Permitir todas as bibliotecas",
-        "selectedLibraries": "Bibliotecas selecionadas",
-        "allowWriteAccess": "Permitir acesso de escrita"
+        "selectedLibraries": "Bibliotecas selecionadas"
       },
       "sections": {
         "status": "Status",
@@ -397,7 +396,6 @@
         "allLibrariesHelp": "Quando habilitado, o plugin terá acesso a todas as bibliotecas, incluindo as criadas no futuro.",
         "noLibraries": "Nenhuma biblioteca selecionada",
         "librariesRequired": "Este plugin requer acesso a informações de bibliotecas. Selecione quais bibliotecas o plugin pode acessar, ou habilite 'Permitir todas as bibliotecas'.",
-        "allowWriteAccessHelp": "Quando habilitado, o plugin pode modificar arquivos nos diretórios das bibliotecas. Por padrão, plugins têm acesso somente leitura.",
         "requiredHosts": "Hosts necessários",
         "configValidationError": "Falha na validação da configuração:",
         "schemaRenderError": "Não foi possível renderizar o formulário de configuração. O schema do plugin pode estar inválido."

server/nativeapi/native_api.go

@@ -29,7 +29,7 @@ type PluginManager interface {
 	ValidatePluginConfig(ctx context.Context, id, configJSON string) error
 	UpdatePluginConfig(ctx context.Context, id, configJSON string) error
 	UpdatePluginUsers(ctx context.Context, id, usersJSON string, allUsers bool) error
-	UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries, allowWriteAccess bool) error
+	UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries bool) error
 	RescanPlugins(ctx context.Context) error
 	UnloadDisabledPlugins(ctx context.Context)
 }

server/nativeapi/plugin.go

@@ -56,13 +56,12 @@ func pluginsEnabledMiddleware(next http.Handler) http.Handler {
 
 // PluginUpdateRequest represents the fields that can be updated via the API
 type PluginUpdateRequest struct {
-	Enabled          *bool   `json:"enabled,omitempty"`
-	Config           *string `json:"config,omitempty"`
-	Users            *string `json:"users,omitempty"`
-	AllUsers         *bool   `json:"allUsers,omitempty"`
-	Libraries        *string `json:"libraries,omitempty"`
-	AllLibraries     *bool   `json:"allLibraries,omitempty"`
-	AllowWriteAccess *bool   `json:"allowWriteAccess,omitempty"`
+	Enabled      *bool   `json:"enabled,omitempty"`
+	Config       *string `json:"config,omitempty"`
+	Users        *string `json:"users,omitempty"`
+	AllUsers     *bool   `json:"allUsers,omitempty"`
+	Libraries    *string `json:"libraries,omitempty"`
+	AllLibraries *bool   `json:"allLibraries,omitempty"`
 }
 
 func (api *Router) updatePlugin(w http.ResponseWriter, r *http.Request) {
@@ -110,7 +109,7 @@ func (api *Router) updatePlugin(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Handle libraries permission update (if provided)
-	if req.Libraries != nil || req.AllLibraries != nil || req.AllowWriteAccess != nil {
+	if req.Libraries != nil || req.AllLibraries != nil {
 		if err := validateAndUpdateLibraries(ctx, api.pluginManager, repo, id, req, w); err != nil {
 			log.Error(ctx, "Error updating plugin libraries", err)
 			return
@@ -246,7 +245,6 @@ func validateAndUpdateLibraries(ctx context.Context, pm PluginManager, repo mode
 
 	librariesJSON := plugin.Libraries
 	allLibraries := plugin.AllLibraries
-	allowWriteAccess := plugin.AllowWriteAccess
 
 	if req.Libraries != nil {
 		if *req.Libraries != "" && !isValidJSON(*req.Libraries) {
@@ -258,11 +256,8 @@ func validateAndUpdateLibraries(ctx context.Context, pm PluginManager, repo mode
 	if req.AllLibraries != nil {
 		allLibraries = *req.AllLibraries
 	}
-	if req.AllowWriteAccess != nil {
-		allowWriteAccess = *req.AllowWriteAccess
-	}
 
-	if err := pm.UpdatePluginLibraries(ctx, id, librariesJSON, allLibraries, allowWriteAccess); err != nil {
+	if err := pm.UpdatePluginLibraries(ctx, id, librariesJSON, allLibraries); err != nil {
 		log.Error(ctx, "Error updating plugin libraries", "id", id, err)
 		http.Error(w, "Error updating plugin libraries: "+err.Error(), http.StatusInternalServerError)
 		return err

server/subsonic/browsing.go

@@ -443,7 +443,7 @@ func (api *Router) buildArtist(r *http.Request, artist *model.Artist) (*response
 func (api *Router) buildAlbumDirectory(ctx context.Context, album *model.Album) (*responses.Directory, error) {
 	dir := &responses.Directory{}
 	dir.Id = album.ID
-	dir.Name = album.FullName()
+	dir.Name = album.Name
 	dir.Parent = album.AlbumArtistID
 	dir.PlayCount = album.PlayCount
 	if album.PlayCount > 0 {

server/subsonic/helpers.go

@@ -197,7 +197,7 @@ func childFromMediaFile(ctx context.Context, mf model.MediaFile) responses.Child
 	}
 
 	child.Parent = mf.AlbumID
-	child.Album = mf.FullAlbumName()
+	child.Album = mf.Album
 	child.Year = int32(mf.Year)
 	child.Artist = mf.Artist
 	child.Genre = mf.Genre
@@ -302,7 +302,7 @@ func artistRefs(participants model.ParticipantList) []responses.ArtistID3Ref {
 func fakePath(mf model.MediaFile) string {
 	builder := strings.Builder{}
 
-	builder.WriteString(fmt.Sprintf("%s/%s/", sanitizeSlashes(mf.AlbumArtist), sanitizeSlashes(mf.FullAlbumName())))
+	builder.WriteString(fmt.Sprintf("%s/%s/", sanitizeSlashes(mf.AlbumArtist), sanitizeSlashes(mf.Album)))
 	if mf.DiscNumber != 0 {
 		builder.WriteString(fmt.Sprintf("%02d-", mf.DiscNumber))
 	}
@@ -321,10 +321,9 @@ func childFromAlbum(ctx context.Context, al model.Album) responses.Child {
 	child := responses.Child{}
 	child.Id = al.ID
 	child.IsDir = true
-	fullName := al.FullName()
-	child.Title = fullName
-	child.Name = fullName
-	child.Album = fullName
+	child.Title = al.Name
+	child.Name = al.Name
+	child.Album = al.Name
 	child.Artist = al.AlbumArtist
 	child.Year = int32(cmp.Or(al.MaxOriginalYear, al.MaxYear))
 	child.Genre = al.Genre
@@ -406,7 +405,7 @@ func buildDiscSubtitles(a model.Album) []responses.DiscTitle {
 func buildAlbumID3(ctx context.Context, album model.Album) responses.AlbumID3 {
 	dir := responses.AlbumID3{}
 	dir.Id = album.ID
-	dir.Name = album.FullName()
+	dir.Name = album.Name
 	dir.Artist = album.AlbumArtist
 	dir.ArtistId = album.AlbumArtistID
 	dir.CoverArt = album.CoverArtID().String()

tests/mock_plugin_manager.go

@@ -18,7 +18,7 @@ type MockPluginManager struct {
 	// UpdatePluginUsersFn is called when UpdatePluginUsers is invoked. If nil, returns UsersError.
 	UpdatePluginUsersFn func(ctx context.Context, id, usersJSON string, allUsers bool) error
 	// UpdatePluginLibrariesFn is called when UpdatePluginLibraries is invoked. If nil, returns LibrariesError.
-	UpdatePluginLibrariesFn func(ctx context.Context, id, librariesJSON string, allLibraries, allowWriteAccess bool) error
+	UpdatePluginLibrariesFn func(ctx context.Context, id, librariesJSON string, allLibraries bool) error
 	// RescanPluginsFn is called when RescanPlugins is invoked. If nil, returns RescanError.
 	RescanPluginsFn func(ctx context.Context) error
 
@@ -48,10 +48,9 @@ type MockPluginManager struct {
 		AllUsers  bool
 	}
 	UpdatePluginLibrariesCalls []struct {
-		ID               string
-		LibrariesJSON    string
-		AllLibraries     bool
-		AllowWriteAccess bool
+		ID            string
+		LibrariesJSON string
+		AllLibraries  bool
 	}
 	RescanPluginsCalls int
 }
@@ -106,15 +105,14 @@ func (m *MockPluginManager) UpdatePluginUsers(ctx context.Context, id, usersJSON
 	return m.UsersError
 }
 
-func (m *MockPluginManager) UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries, allowWriteAccess bool) error {
+func (m *MockPluginManager) UpdatePluginLibraries(ctx context.Context, id, librariesJSON string, allLibraries bool) error {
 	m.UpdatePluginLibrariesCalls = append(m.UpdatePluginLibrariesCalls, struct {
-		ID               string
-		LibrariesJSON    string
-		AllLibraries     bool
-		AllowWriteAccess bool
-	}{ID: id, LibrariesJSON: librariesJSON, AllLibraries: allLibraries, AllowWriteAccess: allowWriteAccess})
+		ID            string
+		LibrariesJSON string
+		AllLibraries  bool
+	}{ID: id, LibrariesJSON: librariesJSON, AllLibraries: allLibraries})
 	if m.UpdatePluginLibrariesFn != nil {
-		return m.UpdatePluginLibrariesFn(ctx, id, librariesJSON, allLibraries, allowWriteAccess)
+		return m.UpdatePluginLibrariesFn(ctx, id, librariesJSON, allLibraries)
 	}
 	return m.LibrariesError
 }

ui/src/i18n/en.json

@@ -355,8 +355,7 @@
         "allUsers": "Allow all users",
         "selectedUsers": "Selected users",
         "allLibraries": "Allow all libraries",
-        "selectedLibraries": "Selected libraries",
-        "allowWriteAccess": "Allow write access"
+        "selectedLibraries": "Selected libraries"
       },
       "sections": {
         "status": "Status",
@@ -401,7 +400,6 @@
         "allLibrariesHelp": "When enabled, the plugin will have access to all libraries, including those created in the future.",
         "noLibraries": "No libraries selected",
         "librariesRequired": "This plugin requires access to library information. Select which libraries the plugin can access, or enable 'Allow all libraries'.",
-        "allowWriteAccessHelp": "When enabled, the plugin can modify files in the library directories. By default, plugins have read-only access.",
         "requiredHosts": "Required hosts"
       },
       "placeholders": {

ui/src/plugin/LibraryPermissionCard.jsx

@@ -23,10 +23,8 @@ export const LibraryPermissionCard = ({
   classes,
   selectedLibraries,
   allLibraries,
-  allowWriteAccess,
   onSelectedLibrariesChange,
   onAllLibrariesChange,
-  onAllowWriteAccessChange,
 }) => {
   const translate = useTranslate()
 
@@ -60,17 +58,9 @@ export const LibraryPermissionCard = ({
     [onAllLibrariesChange],
   )
 
-  const handleAllowWriteAccessToggle = React.useCallback(
-    (event) => {
-      onAllowWriteAccessChange(event.target.checked)
-    },
-    [onAllowWriteAccessChange],
-  )
-
   // Get permission reason from manifest
   const libraryPermission = manifest?.permissions?.library
   const reason = libraryPermission?.reason
-  const hasFilesystem = libraryPermission?.filesystem === true
 
   // Check if permission is required but not configured
   const isConfigurationRequired =
@@ -117,24 +107,6 @@ export const LibraryPermissionCard = ({
           </Typography>
         </Box>
 
-        {hasFilesystem && (
-          <Box mb={2}>
-            <FormControlLabel
-              control={
-                <Switch
-                  checked={allowWriteAccess}
-                  onChange={handleAllowWriteAccessToggle}
-                  color="primary"
-                />
-              }
-              label={translate('resources.plugin.fields.allowWriteAccess')}
-            />
-            <Typography variant="body2" color="textSecondary">
-              {translate('resources.plugin.messages.allowWriteAccessHelp')}
-            </Typography>
-          </Box>
-        )}
-
         {!allLibraries && (
           <Box className={classes.usersList}>
             <Typography variant="subtitle2" gutterBottom>
@@ -194,8 +166,6 @@ LibraryPermissionCard.propTypes = {
   classes: PropTypes.object.isRequired,
   selectedLibraries: PropTypes.array.isRequired,
   allLibraries: PropTypes.bool.isRequired,
-  allowWriteAccess: PropTypes.bool.isRequired,
   onSelectedLibrariesChange: PropTypes.func.isRequired,
   onAllLibrariesChange: PropTypes.func.isRequired,
-  onAllowWriteAccessChange: PropTypes.func.isRequired,
 }

ui/src/plugin/PluginShow.jsx

@@ -48,11 +48,8 @@ const PluginShowLayout = () => {
   // Libraries permission state
   const [selectedLibraries, setSelectedLibraries] = useState([])
   const [allLibraries, setAllLibraries] = useState(false)
-  const [allowWriteAccess, setAllowWriteAccess] = useState(false)
   const [lastRecordLibraries, setLastRecordLibraries] = useState(null)
   const [lastRecordAllLibraries, setLastRecordAllLibraries] = useState(null)
-  const [lastRecordAllowWriteAccess, setLastRecordAllowWriteAccess] =
-    useState(null)
 
   // Parse JSON config to object
   const jsonToObject = useCallback((jsonString) => {
@@ -102,12 +99,10 @@ const PluginShowLayout = () => {
     if (record && !isDirty) {
       const recordLibraries = record.libraries || ''
       const recordAllLibraries = record.allLibraries || false
-      const recordAllowWriteAccess = record.allowWriteAccess || false
 
       if (
         recordLibraries !== lastRecordLibraries ||
-        recordAllLibraries !== lastRecordAllLibraries ||
-        recordAllowWriteAccess !== lastRecordAllowWriteAccess
+        recordAllLibraries !== lastRecordAllLibraries
       ) {
         try {
           setSelectedLibraries(
@@ -117,19 +112,11 @@ const PluginShowLayout = () => {
           setSelectedLibraries([])
         }
         setAllLibraries(recordAllLibraries)
-        setAllowWriteAccess(recordAllowWriteAccess)
         setLastRecordLibraries(recordLibraries)
         setLastRecordAllLibraries(recordAllLibraries)
-        setLastRecordAllowWriteAccess(recordAllowWriteAccess)
       }
     }
-  }, [
-    record,
-    lastRecordLibraries,
-    lastRecordAllLibraries,
-    lastRecordAllowWriteAccess,
-    isDirty,
-  ])
+  }, [record, lastRecordLibraries, lastRecordAllLibraries, isDirty])
 
   const handleConfigDataChange = useCallback(
     (newData, errors) => {
@@ -165,11 +152,6 @@ const PluginShowLayout = () => {
     setIsDirty(true)
   }, [])
 
-  const handleAllowWriteAccessChange = useCallback((newAllowWriteAccess) => {
-    setAllowWriteAccess(newAllowWriteAccess)
-    setIsDirty(true)
-  }, [])
-
   const [updatePlugin, { loading }] = useUpdate(
     'plugin',
     record?.id,
@@ -185,7 +167,6 @@ const PluginShowLayout = () => {
         setLastRecordAllUsers(null)
         setLastRecordLibraries(null)
         setLastRecordAllLibraries(null)
-        setLastRecordAllowWriteAccess(null)
         notify('resources.plugin.notifications.updated', 'info')
       },
       onFailure: (err) => {
@@ -218,7 +199,6 @@ const PluginShowLayout = () => {
     if (parsedManifest?.permissions?.library) {
       data.libraries = JSON.stringify(selectedLibraries)
       data.allLibraries = allLibraries
-      data.allowWriteAccess = allowWriteAccess
     }
 
     updatePlugin('plugin', record.id, data, record)
@@ -230,7 +210,6 @@ const PluginShowLayout = () => {
     allUsers,
     selectedLibraries,
     allLibraries,
-    allowWriteAccess,
   ])
 
   // Parse manifest
@@ -315,10 +294,8 @@ const PluginShowLayout = () => {
           classes={classes}
           selectedLibraries={selectedLibraries}
           allLibraries={allLibraries}
-          allowWriteAccess={allowWriteAccess}
           onSelectedLibrariesChange={handleSelectedLibrariesChange}
           onAllLibrariesChange={handleAllLibrariesChange}
-          onAllowWriteAccessChange={handleAllowWriteAccessChange}
         />
 
         <Box display="flex" justifyContent="flex-end">