@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/wire/wire.go

@@ -0,0 +1,218 @@
+// Package wire holds the protocol-level helpers of the AHP host: channel URI classification,
+// protocol errors, version negotiation, the client-dispatchable action table and file: URI
+// conversion. It has no I/O. Ports pi-ahp src/core/channels.ts, uri.ts and src/protocol/*.
+package wire
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+)
+
+// ResourceWatchScheme prefixes every resource watch channel URI ("<scheme>/<id>").
+const ResourceWatchScheme = "ahp-resource-watch:"
+
+// RootChannel is the singleton root channel.
+const RootChannel = "ahp-root://"
+
+// ChannelKind classifies a channel URI by the reducer that serves it.
+type ChannelKind string
+
+const (
+	KindRoot          ChannelKind = "root"
+	KindSession       ChannelKind = "session"
+	KindChat          ChannelKind = "chat"
+	KindTerminal      ChannelKind = "terminal"
+	KindChangeset     ChannelKind = "changeset"
+	KindResourceWatch ChannelKind = "resourceWatch"
+)
+
+// JSON-RPC and AHP error codes (pinned spec: errors.generated.go).
+const (
+	CodeParseError                 = -32700
+	CodeInvalidRequest             = -32600
+	CodeMethodNotFound             = -32601
+	CodeInvalidParams              = -32602
+	CodeInternalError              = -32603
+	CodeSessionNotFound            = -32001
+	CodeProviderNotFound           = -32002
+	CodeSessionAlreadyExists       = -32003
+	CodeTurnInProgress             = -32004
+	CodeUnsupportedProtocolVersion = -32005
+	CodeAuthRequired               = -32007
+	CodeNotFound                   = -32008
+	CodePermissionDenied           = -32009
+	CodeAlreadyExists              = -32010
+	// CodeConflict is the code of the npm 0.9.0 package pi-ahp was written against (errors.ts,
+	// AhpErrorCodes.Conflict); the pinned spec commit has no such code, see PORT.md.
+	CodeConflict = -32011
+)
+
+// ProtocolVersion is the one AHP version this host speaks (pinned: 0.9.0).
+const ProtocolVersion = "0.9.0"
+
+// Error is a protocol error: handlers return it and the router turns it into a JSON-RPC error response.
+type Error struct {
+	Code    int
+	Message string
+	Data    any
+}
+
+func (e *Error) Error() string { return e.Message }
+
+const (
+	sessionScheme       = "ahp-session:"
+	chatScheme          = "ahp-chat:"
+	terminalScheme      = "ahp-terminal:"
+	changesetScheme     = "ahp-changeset:"
+	resourceWatchScheme = "ahp-resource-watch:"
+)
+
+// KindOf classifies a channel URI, false for a scheme this host does not serve. Deliberately
+// strict: it drives subscribe, where guessing wrong would create a channel with the wrong reducer.
+func KindOf(uri string) (ChannelKind, bool) {
+	switch {
+	case uri == RootChannel:
+		return KindRoot, true
+	case strings.HasPrefix(uri, sessionScheme+"/"):
+		return KindSession, true
+	case strings.HasPrefix(uri, chatScheme+"/"):
+		return KindChat, true
+	case strings.HasPrefix(uri, terminalScheme+"/"):
+		return KindTerminal, true
+	case strings.HasPrefix(uri, changesetScheme+"/"):
+		return KindChangeset, true
+	case strings.HasPrefix(uri, resourceWatchScheme+"/"):
+		return KindResourceWatch, true
+	}
+	return "", false
+}
+
+// ActionBelongsToChannel reports whether an action type's namespace belongs to a channel kind.
+func ActionBelongsToChannel(actionType string, kind ChannelKind) bool {
+	return strings.HasPrefix(actionType, string(kind)+"/")
+}
+
+// IsChatChannel reports whether the URI is `ahp-chat:/…`.
+func IsChatChannel(uri string) bool { return strings.HasPrefix(uri, chatScheme+"/") }
+
+// SessionURI returns `ahp-session:/<id>`.
+func SessionURI(id string) string { return sessionScheme + "/" + id }
+
+// ChatURI returns `ahp-chat:/<id>`.
+func ChatURI(id string) string { return chatScheme + "/" + id }
+
+// ChatIDFromURI extracts `<id>` from `ahp-chat:/<id>`.
+func ChatIDFromURI(uri string) (string, bool) {
+	if !IsChatChannel(uri) {
+		return "", false
+	}
+	id := uri[len(chatScheme)+1:]
+	return id, id != ""
+}
+
+var singleSegment = regexp.MustCompile(`^([a-zA-Z][a-zA-Z0-9+.-]*):/([^/?#]+)$`)
+
+// SessionIDFromURI identifies a session from its canonical scheme or from explicit provider
+// aliases given as bare scheme names. Shape alone never makes an unknown URI a session.
+func SessionIDFromURI(uri string, providerAliases ...string) (string, bool) {
+	m := singleSegment.FindStringSubmatch(uri)
+	if m == nil {
+		return "", false
+	}
+	scheme := strings.ToLower(m[1])
+	if scheme == "ahp-session" {
+		return m[2], true
+	}
+	for _, alias := range providerAliases {
+		if scheme == strings.ToLower(alias) {
+			return m[2], true
+		}
+	}
+	return "", false
+}
+
+func newError(code int, message string, data any) *Error {
+	return &Error{Code: code, Message: message, Data: data}
+}
+
+// InvalidParams and the other constructors mirror pi-ahp's ProtocolError statics.
+// Coded builds a protocol error with an explicit code.
+func Coded(code int, message string) *Error { return newError(code, message, nil) }
+
+func InvalidParams(message string) *Error { return newError(CodeInvalidParams, message, nil) }
+func MethodNotFound(method string) *Error {
+	return newError(CodeMethodNotFound, "Unknown method: "+method, nil)
+}
+func SessionNotFound(channel string) *Error {
+	return newError(CodeSessionNotFound, "Session not found: "+channel, nil)
+}
+func SessionAlreadyExists(channel string) *Error {
+	return newError(CodeSessionAlreadyExists, "Session already exists: "+channel, nil)
+}
+func ProviderNotFound(provider string) *Error {
+	return newError(CodeProviderNotFound, "No agent for provider: "+provider, nil)
+}
+func NotFound(uri string) *Error { return newError(CodeNotFound, "Not found: "+uri, nil) }
+
+// HostSupportedVersions is what this host can speak. Generated wire models do not down-convert
+// required fields across minor versions, so it is the current version only.
+func HostSupportedVersions() []string { return []string{ProtocolVersion} }
+
+// NegotiateProtocolVersion picks the client's most-preferred version this host also speaks.
+func NegotiateProtocolVersion(offered []string) (string, error) {
+	if len(offered) == 0 {
+		return "", InvalidParams("initialize requires a non-empty protocolVersions array of strings")
+	}
+	for _, candidate := range offered {
+		for _, supported := range HostSupportedVersions() {
+			if candidate == supported {
+				return candidate, nil
+			}
+		}
+	}
+	return "", newError(CodeUnsupportedProtocolVersion,
+		"No mutually supported protocol version. Offered: "+strings.Join(offered, ", "),
+		map[string]any{"supportedVersions": HostSupportedVersions()})
+}
+
+// IsClientDispatchable reports whether a client may dispatch an action of this type.
+func IsClientDispatchable(actionType string) bool { return clientDispatchable[actionType] }
+
+// FileURIToPath converts a file: URI to a filesystem path. A value that is not a file: URI is
+// returned unchanged: clients occasionally send a bare path where the protocol asks for a URI.
+// A URI naming a remote host is an error (Node's fileURLToPath does the same).
+func FileURIToPath(uri string) (string, error) {
+	if !strings.HasPrefix(uri, "file://") {
+		return uri, nil
+	}
+	u, err := url.Parse(uri)
+	if err != nil {
+		return "", fmt.Errorf("invalid file URL %q: %w", uri, err)
+	}
+	if u.Host != "" && u.Host != "localhost" {
+		return "", fmt.Errorf("file URL host must be \"localhost\" or empty on %s: %q", runtime.GOOS, uri)
+	}
+	p := u.Path
+	if runtime.GOOS == "windows" {
+		p = strings.TrimPrefix(p, "/")
+		return filepath.FromSlash(p), nil
+	}
+	if strings.Contains(u.EscapedPath(), "%2F") || strings.Contains(u.EscapedPath(), "%2f") {
+		return "", errors.New("file URL path must not include encoded / characters")
+	}
+	return p, nil
+}
+
+// PathToFileURI converts an absolute path to a file: URI.
+func PathToFileURI(path string) string {
+	p := filepath.ToSlash(path)
+	if !strings.HasPrefix(p, "/") {
+		p = "/" + p
+	}
+	return (&url.URL{Scheme: "file", Path: p}).String()
+}

package/extensions/ahp/internal/wire/wire_test.go

@@ -0,0 +1,123 @@
+package wire_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Twins of upstream test/uri.test.ts (src/core/uri.ts).
+func TestFileURIConversion(t *testing.T) {
+	twin.Run(t, "uri", "decodes percent-escapes", func(t *testing.T) {
+		got, err := wire.FileURIToPath("file:///tmp/a%20b")
+		if err != nil || got != "/tmp/a b" {
+			t.Fatalf("got %q, %v; want /tmp/a b", got, err)
+		}
+	})
+	twin.Run(t, "uri", "round-trips a path", func(t *testing.T) {
+		got, err := wire.FileURIToPath(wire.PathToFileURI("/tmp/a b/c"))
+		if err != nil || got != "/tmp/a b/c" {
+			t.Fatalf("got %q, %v; want /tmp/a b/c", got, err)
+		}
+	})
+	twin.Run(t, "uri", "passes a bare path through", func(t *testing.T) {
+		// Clients occasionally send a path where the protocol asks for a URI.
+		got, err := wire.FileURIToPath("/tmp/plain")
+		if err != nil || got != "/tmp/plain" {
+			t.Fatalf("got %q, %v; want /tmp/plain", got, err)
+		}
+	})
+	twin.Run(t, "uri", "refuses a URI naming a remote host", func(t *testing.T) {
+		if got, err := wire.FileURIToPath("file://host/share/x"); err == nil {
+			t.Fatalf("expected an error, got %q", got)
+		}
+	})
+}
+
+// Channel helpers (src/core/channels.ts); no upstream test file, so these are additional Go cases.
+func TestChannelKinds(t *testing.T) {
+	cases := map[string]wire.ChannelKind{
+		"ahp-root://":           wire.KindRoot,
+		"ahp-session:/abc":      wire.KindSession,
+		"ahp-chat:/abc":         wire.KindChat,
+		"ahp-terminal:/t1":      wire.KindTerminal,
+		"ahp-changeset:/c":      wire.KindChangeset,
+		"ahp-resource-watch:/w": wire.KindResourceWatch,
+	}
+	for uri, want := range cases {
+		if got, ok := wire.KindOf(uri); !ok || got != want {
+			t.Errorf("KindOf(%q) = %v, %v; want %v", uri, got, ok, want)
+		}
+	}
+	for _, uri := range []string{"ahp-unknown:/x", "pi:/abc", "", "ahp-session:"} {
+		if got, ok := wire.KindOf(uri); ok {
+			t.Errorf("KindOf(%q) = %v, want unsupported", uri, got)
+		}
+	}
+	if !wire.ActionBelongsToChannel("chat/delta", wire.KindChat) || wire.ActionBelongsToChannel("chat/delta", wire.KindSession) {
+		t.Error("action namespace must match the channel kind")
+	}
+	if wire.ActionBelongsToChannel("resourceWatch/changed", wire.KindResourceWatch) != true {
+		t.Error("resourceWatch/ belongs to resourceWatch")
+	}
+	if wire.SessionURI("x") != "ahp-session:/x" || wire.ChatURI("x") != "ahp-chat:/x" {
+		t.Error("uri constructors")
+	}
+	if id, ok := wire.ChatIDFromURI("ahp-chat:/abc"); !ok || id != "abc" {
+		t.Errorf("ChatIDFromURI = %q, %v", id, ok)
+	}
+	if _, ok := wire.ChatIDFromURI("ahp-session:/abc"); ok {
+		t.Error("a session URI is not a chat")
+	}
+	if id, ok := wire.SessionIDFromURI("ahp-session:/abc"); !ok || id != "abc" {
+		t.Errorf("SessionIDFromURI canonical = %q, %v", id, ok)
+	}
+	if id, ok := wire.SessionIDFromURI("pi:/abc", "pi"); !ok || id != "abc" {
+		t.Errorf("SessionIDFromURI alias = %q, %v", id, ok)
+	}
+	if _, ok := wire.SessionIDFromURI("pi:/abc"); ok {
+		t.Error("shape alone never makes an unknown URI a session")
+	}
+	if _, ok := wire.SessionIDFromURI("ahp-session:/a/b"); ok {
+		t.Error("a session URI has a single path segment")
+	}
+}
+
+func TestNegotiateProtocolVersion(t *testing.T) {
+	got, err := wire.NegotiateProtocolVersion([]string{"0.9.0", "0.8.0"})
+	if err != nil || got != "0.9.0" {
+		t.Fatalf("got %q, %v", got, err)
+	}
+	got, err = wire.NegotiateProtocolVersion([]string{"99.0.0", "0.9.0"})
+	if err != nil || got != "0.9.0" {
+		t.Fatalf("unknown versions are skipped: got %q, %v", got, err)
+	}
+	_, err = wire.NegotiateProtocolVersion([]string{"0.8.0"})
+	var pe *wire.Error
+	if !asError(err, &pe) || pe.Code != wire.CodeUnsupportedProtocolVersion {
+		t.Fatalf("want UnsupportedProtocolVersion, got %v", err)
+	}
+	if !reflect.DeepEqual(pe.Data, map[string]any{"supportedVersions": []string{"0.9.0"}}) {
+		t.Fatalf("error data = %#v", pe.Data)
+	}
+	if _, err = wire.NegotiateProtocolVersion(nil); err == nil {
+		t.Fatal("an empty offer is invalid")
+	}
+}
+
+// The table is generated from the pinned spec's @clientDispatchable annotations
+// (types/action-origin.generated.ts, IS_CLIENT_DISPATCHABLE); this checks a sample of both kinds.
+func TestClientDispatchable(t *testing.T) {
+	for _, typ := range []string{"root/configChanged", "session/titleChanged", "chat/turnStarted", "chat/turnCancelled", "chat/truncated", "terminal/input", "terminal/cleared"} {
+		if !wire.IsClientDispatchable(typ) {
+			t.Errorf("%s must be client-dispatchable", typ)
+		}
+	}
+	for _, typ := range []string{"root/agentsChanged", "session/ready", "chat/delta", "chat/turnComplete", "terminal/data", "resourceWatch/changed", "nope/unknown"} {
+		if wire.IsClientDispatchable(typ) {
+			t.Errorf("%s must be server-only", typ)
+		}
+	}
+}

package/extensions/ahp/internal/ws/helpers_test.go

@@ -0,0 +1,7 @@
+package ws_test
+
+import "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+func activeSessions(n int64) ahptypes.StateAction {
+	return ahptypes.StateAction{Value: &ahptypes.RootActiveSessionsChangedAction{Type: ahptypes.ActionTypeRootActiveSessionsChanged, ActiveSessions: n}}
+}

package/extensions/ahp/internal/ws/vscode_test.go

@@ -0,0 +1,198 @@
+package ws_test
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/ws"
+)
+
+// VS Code's Agents window connects to a WebSocket AHP host given as ws://<host>:<port>?tkn=<token>
+// (command "Agents: Add Remote Agent Host...", or the chat.remoteAgentHosts setting). These tests send what VS Code sends, as
+// read from microsoft/vscode main; nothing here was run against a live VS Code. Files are under src/vs/platform/agentHost/.
+
+// vsCodeInitialize is VS Code's first message, field for field (browser/agentHostProtocolClient.ts, connect): request id 1
+// (_nextRequestId starts at 1), the root channel, every protocol version it can speak newest first with 0.8.0 left out
+// (CLIENT_SUPPORTED_PROTOCOL_VERSIONS, from common/state/protocol/version/registry.ts SUPPORTED_PROTOCOL_VERSIONS), a UUID
+// client id, the Agents window's clientInfo (common/agentHostClientInfo.ts), the _meta of toAgentHostClientMeta
+// (common/agentHostTelemetry.ts) for a direct WebSocket, and the root as the one initial subscription.
+func vsCodeInitialize(t *testing.T) []byte { return vsCodeInitializeOffering(t, vsCodeOffers["main"]) }
+
+// vsCodeOffers is the protocolVersions list each VS Code sends: 1.140.0 speaks 0.9.0 itself (PROTOCOL_VERSION), release/1.141
+// and main speak 0.10.0 and still offer 0.9.0.
+var vsCodeOffers = map[string][]string{
+	"1.140.0": {"0.9.0", "0.7.0", "0.6.0", "0.5.2", "0.5.1"},
+	"main":    {"0.10.0", "0.9.0", "0.7.0", "0.6.0", "0.5.2", "0.5.1"},
+}
+
+func vsCodeInitializeOffering(t *testing.T, versions []string) []byte {
+	t.Helper()
+	req, err := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": map[string]any{
+		"channel":              wire.RootChannel,
+		"protocolVersions":     []string{"0.10.0", "0.9.0", "0.7.0", "0.6.0", "0.5.2", "0.5.1"},
+		"clientId":             "6f1c2d3e-4b5a-4c7d-8e9f-0a1b2c3d4e5f",
+		"clientInfo":           map[string]any{"name": "vscode-agents-window", "title": "VS Code Agents Window"},
+		"_meta":                map[string]any{"vscode.telemetryLevel": "all", "vscode.clientConnectionKind": "direct_websocket"},
+		"initialSubscriptions": []string{wire.RootChannel},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return req
+}
+
+// vsCodeRootConfig is one of the notifications VS Code sends right after initialize (_forwardClientConfig, which dispatches
+// root/configChanged with client sequence 0 for each forwarded setting: _dispatchRootConfig).
+func vsCodeRootConfig(t *testing.T, config map[string]any) []byte {
+	t.Helper()
+	msg, err := json.Marshal(map[string]any{"jsonrpc": "2.0", "method": "dispatchAction", "params": map[string]any{
+		"channel": wire.RootChannel, "clientSeq": 0, "action": map[string]any{"type": "root/configChanged", "config": config},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return msg
+}
+
+// rawAt upgrades by hand at the request target VS Code's address produces, so a test can see opcodes and the status line.
+func rawAt(t *testing.T, s *ws.Server, target string) (net.Conn, *bufio.Reader, *http.Response) {
+	t.Helper()
+	conn, err := net.Dial("tcp", "127.0.0.1:"+itoa(s.Port()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { conn.Close() })
+	io.WriteString(conn, "GET "+target+" HTTP/1.1\r\nHost: 127.0.0.1\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n\r\n")
+	br := bufio.NewReader(conn)
+	resp, err := http.ReadResponse(br, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return conn, br, resp
+}
+
+func TestVSCodeHandshakeNegotiatesTheSupportedVersionOverTextFrames(t *testing.T) {
+	_, s := serve(t, ws.Options{Token: "s3cret"})
+	conn, br, resp := rawAt(t, s, "/?tkn=s3cret")
+	if resp.StatusCode != http.StatusSwitchingProtocols {
+		t.Fatalf("upgrade with the right tkn = %d", resp.StatusCode)
+	}
+	if _, err := conn.Write(maskedFrame(true, 1, vsCodeInitialize(t))); err != nil {
+		t.Fatal(err)
+	}
+
+	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	op, payload := readFrame(t, br)
+	if op != 1 {
+		t.Fatalf("the reply was opcode %d; VS Code drops every non-text frame and closes the connection (4002) after ten (browser/webSocketClientTransport.ts)", op)
+	}
+	var reply struct {
+		Result struct {
+			ProtocolVersion string `json:"protocolVersion"`
+			Snapshots       []struct {
+				Resource string `json:"resource"`
+				State    struct {
+					Agents []struct {
+						Provider string `json:"provider"`
+					} `json:"agents"`
+				} `json:"state"`
+			} `json:"snapshots"`
+		} `json:"result"`
+	}
+	if err := json.Unmarshal(payload, &reply); err != nil {
+		t.Fatalf("%s: %v", payload, err)
+	}
+	if reply.Result.ProtocolVersion != "0.9.0" {
+		t.Fatalf("VS Code's offer (0.10.0, 0.9.0, 0.7.0, 0.6.0, 0.5.2, 0.5.1) negotiated %q, want the one version this host speaks, 0.9.0", reply.Result.ProtocolVersion)
+	}
+	if len(reply.Result.Snapshots) != 1 || reply.Result.Snapshots[0].Resource != wire.RootChannel {
+		t.Fatalf("the initial root subscription returned %+v", reply.Result.Snapshots)
+	}
+	for _, agent := range reply.Result.Snapshots[0].State.Agents {
+		if agent.Provider == "" || strings.Contains(agent.Provider, "-") {
+			t.Errorf("agent provider id %q must be non-empty and dash-free", agent.Provider)
+		}
+	}
+
+	// Then, as VS Code does, forward settings as root/configChanged notifications and keep using the connection (VS Code's
+	// keep-alive ping is {"channel":"ahp-root://"}): the host must neither drop it nor answer with anything but text frames.
+	for _, config := range []map[string]any{{"telemetryLevel": "all"}, {"terminalAutoApproveEnabled": true}} {
+		if _, err := conn.Write(maskedFrame(true, 1, vsCodeRootConfig(t, config))); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if _, err := conn.Write(maskedFrame(true, 1, []byte(`{"jsonrpc":"2.0","id":2,"method":"ping","params":{"channel":"ahp-root://"}}`))); err != nil {
+		t.Fatal(err)
+	}
+	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	for {
+		op, payload := readFrame(t, br)
+		if op != 1 {
+			t.Fatalf("a later frame was opcode %d, want text", op)
+		}
+		var msg struct {
+			ID    *int            `json:"id"`
+			Error json.RawMessage `json:"error"`
+		}
+		if err := json.Unmarshal(payload, &msg); err != nil {
+			t.Fatalf("%s: %v", payload, err)
+		}
+		if msg.ID != nil && *msg.ID == 2 {
+			if msg.Error != nil {
+				t.Fatalf("ping after the config notifications failed: %s", payload)
+			}
+			break
+		}
+	}
+}
+
+func TestVSCodeAddressFormIsAccepted(t *testing.T) {
+	_, s := serve(t, ws.Options{Token: "s3cret"})
+	for release, versions := range vsCodeOffers {
+		// The address VS Code is given has no slash before the query.
+		c, _, err := ws.Dial("ws://127.0.0.1:"+itoa(s.Port())+"?tkn=s3cret", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := c.WriteText(vsCodeInitializeOffering(t, versions)); err != nil {
+			t.Fatal(err)
+		}
+		msg, err := c.ReadMessage(2 * time.Second)
+		c.Close()
+		if err != nil || !strings.Contains(string(msg), `"protocolVersion":"0.9.0"`) {
+			t.Fatalf("VS Code %s: reply %s (%v)", release, msg, err)
+		}
+	}
+}
+
+func TestVSCodeWrongOrMissingTknIsRefusedAtTheUpgrade(t *testing.T) {
+	_, s := serve(t, ws.Options{Token: "s3cret"})
+	for _, target := range []string{"/?tkn=wrong", "/?tkn=", "/", "/?TKN=s3cret"} {
+		_, _, resp := rawAt(t, s, target)
+		// 403 Forbidden with no upgrade, as VS Code's own agent host answers a missing or wrong tkn
+		// (microsoft/vscode src/vs/platform/agentHost/node/webSocketTransport.ts, verifyClient: cb(false, 403, 'Forbidden')).
+		// The AHP spec leaves endpoint access to the transport (docs/specification/transport.md, "Authentication"), and
+		// VS Code's client cannot see the status: a browser WebSocket reports any refused upgrade as one error.
+		if resp.StatusCode != http.StatusForbidden {
+			t.Errorf("GET %s = %d, want 403 and no upgrade", target, resp.StatusCode)
+		}
+	}
+}
+
+func TestProviderIDIsDashFree(t *testing.T) {
+	// AHP session URIs are <provider>:/<id>; VS Code parses the scheme, so a dash in the provider breaks them.
+	if pi.Provider == "" || strings.Contains(pi.Provider, "-") {
+		t.Fatalf("provider id %q must be non-empty and dash-free", pi.Provider)
+	}
+	if got := pi.BuildAgentInfo(nil).Provider; got != pi.Provider {
+		t.Fatalf("the agent advertises provider %q, not %q", got, pi.Provider)
+	}
+}