@nimbalyst/extension-sdk 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -8,12 +8,32 @@ The SDK is versioned independently of the Nimbalyst app. Each release declares i
 
 | SDK version | Minimum Nimbalyst app version |
 | --- | --- |
+| 0.2.2 | 0.58.5 |
+| 0.2.1 | 0.58.5 |
 | 0.2.0 | 0.58.5 |
 | 0.1.5 | 0.58.5 |
 | 0.1.0 | 0.58.5 |
 
 ## [Unreleased]
 
+## [0.2.2]
+
+### Added
+
+- Host-provided tracker reference chips and pickers let extensions persist stable item keys while using Nimbalyst's live metadata and navigation.
+
+## [0.2.1]
+
+### Added
+
+- `ExtensionAITool.access` declares whether a tool uses filesystem, editor-read, or editor-write access; `readOnly` remains as a compatibility alias.
+- `useCollaborativeEditor` accepts `{ codec, bind }` so an editor's pure collab codec is defined once and shared with the host's headless seeding; the previous `createBinding`/`initializeFromContent` config keeps working.
+- `CollaborationContext.flushWithAck` (server-persisted flush) and optional `hasUndecodedContent`.
+
+### Fixed
+
+- The first-open seed no longer runs from empty initial content or when the transport skipped payloads it could not decode — both cases wrote a default document over the shared room's real content.
+
 ## [0.2.0]
 
 Adds opt-in collaborative editing for custom editors. Backwards-compatible: extensions built against 0.2.0 continue to work on older Nimbalyst hosts -- the collaboration hook detects the absence of `host.collaboration` and reports `isCollaborative: false` so the editor falls back to local-only editing.

package/README.md

@@ -93,6 +93,38 @@ const previewHost = createReadOnlyHost(code, {
 
 Type imports for props: `MonacoEditorProps`, `MonacoEditorConfig`, `MarkdownEditorProps`, `MarkdownEditorConfig` from `@nimbalyst/extension-sdk`.
 
+## Tracker References
+
+Custom editors and panels can link their own data to tracker items without
+querying Nimbalyst's internal tracker store. Persist only the reference keys
+returned by the picker; chips resolve live metadata and open the item through
+the host's contextual navigation.
+
+```tsx
+import {
+  TrackerReferenceChip,
+  TrackerReferencePicker,
+} from '@nimbalyst/extension-sdk';
+
+<TrackerReferencePicker
+  value={trackerRefs}
+  onChange={setTrackerRefs}
+  disabled={host.readOnly}
+/>
+
+{trackerRefs.map(referenceKey => (
+  <TrackerReferenceChip
+    key={referenceKey}
+    referenceKey={referenceKey}
+    variant="compact"
+  />
+))}
+```
+
+The picker supports single or multiple selection, search, unresolved keys, and
+read-only mutation state. `TrackerReferenceChip` supports `default` and
+`compact` variants; both retain live preview and navigation behavior.
+
 ## AI Tool Example
 
 ```ts

package/dist/__tests__/createTextCollabContentAdapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createTextCollabContentAdapter.test.d.ts.map

package/dist/__tests__/createTextCollabContentAdapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTextCollabContentAdapter.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/createTextCollabContentAdapter.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/createTextCollabContentAdapter.test.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import * as Y from 'yjs';
+import { createTextCollabContentAdapter } from '../collab/createTextCollabContentAdapter';
+const adapter = createTextCollabContentAdapter({
+    documentType: 'calc.md',
+    fileExtensions: ['.calc.md'],
+    mimeType: 'text/markdown',
+    textField: 'content',
+});
+describe('createTextCollabContentAdapter', () => {
+    it('reports identity (documentType, extensions, version)', () => {
+        expect(adapter.documentType).toBe('calc.md');
+        expect(adapter.fileExtensions).toEqual(['.calc.md']);
+        expect(adapter.layoutVersion).toBe(1);
+    });
+    it('isEmpty is true for a fresh Y.Doc and false after seeding', () => {
+        const doc = new Y.Doc();
+        expect(adapter.isEmpty(doc)).toBe(true);
+        adapter.seedFromFile(doc, 'price = 100 USD\n');
+        expect(adapter.isEmpty(doc)).toBe(false);
+    });
+    it('round-trips file content through seed -> export -> plain text', () => {
+        const doc = new Y.Doc();
+        const source = '# Inputs\nprice = 100 USD\nqty = 3\n';
+        adapter.seedFromFile(doc, source);
+        expect(adapter.exportToFile(doc)).toBe(source);
+        expect(adapter.toPlainText(doc)).toBe(source);
+    });
+    it('decodes Uint8Array file sources', () => {
+        const doc = new Y.Doc();
+        const source = 'total = price * qty\n';
+        adapter.seedFromFile(doc, new TextEncoder().encode(source));
+        expect(adapter.exportToFile(doc)).toBe(source);
+    });
+    it('seedFromFile is a no-op when the Y.Text is already populated (open race)', () => {
+        const doc = new Y.Doc();
+        adapter.seedFromFile(doc, 'first');
+        adapter.seedFromFile(doc, 'second');
+        expect(adapter.exportToFile(doc)).toBe('first');
+    });
+    it('applyFromFile replaces existing content on a populated Y.Doc', () => {
+        const doc = new Y.Doc();
+        adapter.seedFromFile(doc, 'old content');
+        adapter.applyFromFile(doc, 'brand new content');
+        expect(adapter.exportToFile(doc)).toBe('brand new content');
+    });
+    it('does not re-seed a doc that already received content via sync (race guard)', () => {
+        // Models the bootstrap race on a SINGLE shared doc: another client's seed
+        // arrives over the wire first, then this client (which had decided the doc
+        // was empty) calls seedFromFile. The length guard makes the late seed a
+        // no-op, so the synced content is preserved verbatim (no concatenation).
+        // The hook layer additionally re-checks isEmpty before seeding.
+        const remote = new Y.Doc();
+        adapter.seedFromFile(remote, 'a = 1\nb = 2\n');
+        const local = new Y.Doc();
+        Y.applyUpdate(local, Y.encodeStateAsUpdate(remote)); // remote seed arrives
+        adapter.seedFromFile(local, 'a = 1\nb = 2\n'); // late local seed -> no-op
+        expect(adapter.exportToFile(local)).toBe('a = 1\nb = 2\n');
+    });
+});

package/dist/__tests__/externalsPlugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=externalsPlugin.test.d.ts.map

package/dist/__tests__/externalsPlugin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalsPlugin.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/externalsPlugin.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/externalsPlugin.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { nimbalystExternalsPlugin } from '../externalsPlugin';
+describe('nimbalystExternalsPlugin runtime bridge', () => {
+    it('emits named exports for host-provided tracker reference APIs', async () => {
+        const plugin = nimbalystExternalsPlugin();
+        const resolveId = plugin.resolveId;
+        const load = plugin.load;
+        const id = await resolveId('@nimbalyst/runtime', undefined, {});
+        expect(id).toBe('\0nimbalyst-external:@nimbalyst/runtime');
+        const source = await load(id);
+        expect(source).toContain('export const TrackerReferenceChip');
+        expect(source).toContain('export const TrackerReferencePicker');
+        expect(source).toContain('export const useResolvedTrackerReference');
+        expect(source).toContain('export const navigateToTrackerReference');
+    });
+});

package/dist/__tests__/fileDirectoryTree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fileDirectoryTree.test.d.ts.map

package/dist/__tests__/fileDirectoryTree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileDirectoryTree.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fileDirectoryTree.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fileDirectoryTree.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { buildFileDirectoryTree, getFileDirectoryPaths, getFilePathBasename, getWorkspaceRelativeFilePath, } from '../fileDirectoryTree';
+const buildTree = (files, workspacePath) => buildFileDirectoryTree(files.map(filePath => ({ filePath })), file => file.filePath, workspacePath);
+describe('file path helpers', () => {
+    it('normalizes Unix, Windows, and mixed separators', () => {
+        expect(getWorkspaceRelativeFilePath('/repo/src/App.tsx', '/repo')).toBe('src/App.tsx');
+        expect(getWorkspaceRelativeFilePath('C:\\repo\\src\\App.tsx', 'C:\\repo'))
+            .toBe('src/App.tsx');
+        expect(getWorkspaceRelativeFilePath('C:\\repo/src\\App.tsx', 'C:\\repo\\'))
+            .toBe('src/App.tsx');
+    });
+    it('compares Windows drive paths case-insensitively', () => {
+        expect(getWorkspaceRelativeFilePath('c:\\Repo\\src\\App.tsx', 'C:\\repo'))
+            .toBe('src/App.tsx');
+    });
+    it('does not strip a partial workspace prefix', () => {
+        expect(getWorkspaceRelativeFilePath('/repo-copy/src/App.tsx', '/repo'))
+            .toBe('/repo-copy/src/App.tsx');
+    });
+    it('gets basenames from Unix and Windows paths', () => {
+        expect(getFilePathBasename('packages/runtime/index.ts')).toBe('index.ts');
+        expect(getFilePathBasename('packages\\runtime\\index.ts')).toBe('index.ts');
+    });
+});
+describe('buildFileDirectoryTree', () => {
+    it('groups Windows files with duplicate basenames under their directories', () => {
+        const tree = buildTree([
+            'C:\\repo\\skills\\one\\SKILL.md',
+            'C:\\repo\\skills\\two\\SKILL.md',
+            'C:\\repo\\README.md',
+        ], 'C:\\repo');
+        expect(tree.displayPath).toBe('');
+        expect(tree.files.map(file => file.filePath)).toEqual(['C:\\repo\\README.md']);
+        expect([...tree.subdirectories.keys()]).toEqual(['skills']);
+        expect(getFileDirectoryPaths(tree)).toEqual(['skills', 'skills/one', 'skills/two']);
+        expect(tree.fileCount).toBe(3);
+        expect(tree.subdirectories.get('skills')?.fileCount).toBe(2);
+    });
+    it('groups workspace-relative Windows paths for commit proposals', () => {
+        const tree = buildTree([
+            'packages\\runtime\\SKILL.md',
+            'packages\\electron\\SKILL.md',
+        ]);
+        expect(tree.displayPath).toBe('packages');
+        expect(getFileDirectoryPaths(tree)).toEqual(['packages', 'packages/runtime', 'packages/electron']);
+    });
+    it('collapses a single-child Unix directory chain', () => {
+        const tree = buildTree(['/repo/packages/runtime/src/index.ts'], '/repo');
+        expect(tree.displayPath).toBe('packages/runtime/src');
+        expect(tree.path).toBe('packages/runtime/src');
+        expect(tree.fileCount).toBe(1);
+        expect(tree.files).toHaveLength(1);
+    });
+});

package/dist/__tests__/hasSeedableContent.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hasSeedableContent.test.d.ts.map

package/dist/__tests__/hasSeedableContent.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasSeedableContent.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/hasSeedableContent.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/hasSeedableContent.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { hasSeedableContent } from '../useCollaborativeEditor';
+/**
+ * NIM-1520 fallout guard: a host with no bytes for a collab doc returns ''
+ * from loadInitialContent; seeding from that writes a DEFAULT document over
+ * the room's real content ("Untitled map" clobber). Empty content must never
+ * be considered seedable.
+ */
+describe('hasSeedableContent', () => {
+    it('rejects null/undefined/empty/whitespace strings', () => {
+        expect(hasSeedableContent(null)).toBe(false);
+        expect(hasSeedableContent(undefined)).toBe(false);
+        expect(hasSeedableContent('')).toBe(false);
+        expect(hasSeedableContent('   \n\t')).toBe(false);
+    });
+    it('rejects empty binary buffers', () => {
+        expect(hasSeedableContent(new ArrayBuffer(0))).toBe(false);
+        expect(hasSeedableContent(new Uint8Array(0))).toBe(false);
+    });
+    it('accepts real content', () => {
+        expect(hasSeedableContent('# Title')).toBe(true);
+        expect(hasSeedableContent(new Uint8Array([1, 2, 3]))).toBe(true);
+        expect(hasSeedableContent(new ArrayBuffer(8))).toBe(true);
+    });
+});

package/dist/__tests__/manifestValidation.agentProviders.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=manifestValidation.agentProviders.test.d.ts.map

package/dist/__tests__/manifestValidation.agentProviders.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifestValidation.agentProviders.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/manifestValidation.agentProviders.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/manifestValidation.agentProviders.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { validateAgentProviders } from '../manifestValidation';
+// The validator must agree with the AiAgentProviderContribution /
+// AiAgentProviderModel types: the provider label field is `displayName`, and
+// model entries carry no per-entry `provider`. A manifest matching the shipped
+// gemini-antigravity contribution should pass cleanly. Before the alignment,
+// the validator required `name` and `model.provider`, so the real manifest
+// failed its own validator (#558 review, point 1).
+const backendModules = [{ id: 'antigravity-server', entry: 'backend/index.js' }];
+function geminiLikeProvider(overrides = {}) {
+    return {
+        id: 'antigravity-gemini-agent',
+        displayName: 'Gemini',
+        platform: 'antigravity-gemini',
+        backendModuleId: 'antigravity-server',
+        modelDiscovery: 'static',
+        models: [
+            { id: 'antigravity-gemini-agent:gemini-3-flash-agent', name: 'Gemini 3.5 Flash (High)', default: true },
+            { id: 'antigravity-gemini-agent:gemini-3.5-flash-low', name: 'Gemini 3.5 Flash (Medium)' },
+        ],
+        ...overrides,
+    };
+}
+describe('validateAgentProviders - alignment with the SDK type (#558)', () => {
+    it('accepts a provider that uses displayName and models without a provider field', () => {
+        const issues = validateAgentProviders([geminiLikeProvider()], backendModules);
+        expect(issues).toEqual([]);
+    });
+    it('flags a provider missing displayName', () => {
+        const { displayName, ...noDisplayName } = geminiLikeProvider();
+        const issues = validateAgentProviders([noDisplayName], backendModules);
+        expect(issues.some((i) => i.message.includes('displayName'))).toBe(true);
+    });
+    it('does not require a per-model provider field', () => {
+        // A model entry with only id + name is valid; the host derives the
+        // provider from the contribution id.
+        const issues = validateAgentProviders([geminiLikeProvider({ models: [{ id: 'm1', name: 'Model One' }] })], backendModules);
+        expect(issues).toEqual([]);
+    });
+    it('still requires a model name', () => {
+        const issues = validateAgentProviders([geminiLikeProvider({ models: [{ id: 'm1' }] })], backendModules);
+        expect(issues.some((i) => i.message.includes('.name must be a non-empty string'))).toBe(true);
+    });
+});

package/dist/agents/AgentProtocol.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Protocol Interface for Agent SDK Adapters
+ *
+ * This interface normalizes the differences between various agent SDKs
+ * (Claude Agent SDK, OpenAI Codex SDK) to provide a unified abstraction
+ * layer for agent providers.
+ *
+ * The protocol adapters isolate platform-specific SDK details from the
+ * provider implementations, making it easier to:
+ * - Add new agent SDKs
+ * - Update SDK versions without touching provider logic
+ * - Test providers with mock protocols
+ * - Share common infrastructure across providers
+ *
+ * Ownership note: this module is the canonical home of the protocol
+ * contract. The runtime re-exports these types via
+ * `@nimbalyst/runtime/ai/server/protocols/ProtocolInterface` so that
+ * existing runtime imports keep working without source churn, but the
+ * SDK now owns the type bodies. Adding a new field, changing a tag, or
+ * tightening a discriminator happens here first; the runtime picks it
+ * up via the re-export.
+ */
+/**
+ * MCP server configuration
+ */
+export interface MCPServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Platform-specific session data for internal use
+ */
+export interface RawProtocolSession {
+    [key: string]: unknown;
+}
+/**
+ * Structured result from tool execution
+ */
+export interface ToolResult {
+    success: boolean;
+    result?: unknown;
+    output?: unknown;
+    error?: string | unknown;
+    status?: string;
+    command?: string;
+    exit_code?: number;
+    changes?: unknown;
+    query?: string;
+    action?: unknown;
+    fileSnapshots?: Record<string, {
+        content: string | null;
+        error?: string;
+        isBinary?: boolean;
+        truncated?: boolean;
+    }>;
+}
+/**
+ * Options for creating or resuming a session
+ */
+export interface SessionOptions {
+    /** Working directory path for the session */
+    workspacePath: string;
+    /** Model identifier (e.g., 'sonnet', 'gpt-5') */
+    model?: string;
+    /** System prompt to initialize the agent */
+    systemPrompt?: string;
+    /** Abort signal for cancelling the session */
+    abortSignal?: AbortSignal;
+    /** Permission mode for tool approvals ('ask', 'auto', 'plan') */
+    permissionMode?: string;
+    /** MCP server configurations */
+    mcpServers?: Record<string, MCPServerConfig>;
+    /** Environment variables for the session */
+    env?: Record<string, string>;
+    /** Tools to allow (whitelist) */
+    allowedTools?: string[];
+    /** Tools to disallow (blacklist) */
+    disallowedTools?: string[];
+    /** Platform-specific options that don't fit the common schema */
+    raw?: Record<string, unknown>;
+}
+/**
+ * Attachment shape used by ProtocolMessage.
+ *
+ * Inlined into the SDK (rather than re-imported from the runtime's
+ * `ChatAttachment`) so the protocol contract has no dependency on
+ * runtime types. The runtime's `ChatAttachment` is structurally
+ * assignable to this shape, so existing runtime call sites that pass
+ * `ChatAttachment[]` continue to type-check at the SDK boundary.
+ */
+export interface ProtocolAttachment {
+    id: string;
+    filename: string;
+    filepath: string;
+    mimeType: string;
+    size: number;
+    type: 'image' | 'pdf' | 'document';
+    thumbnail?: string;
+    addedAt: number;
+}
+/**
+ * Message sent to the agent
+ */
+export interface ProtocolMessage {
+    /** Text content of the message */
+    content: string;
+    /** Optional attachments (images, PDFs, documents) */
+    attachments?: ProtocolAttachment[];
+    /** Session ID for logging and tracking */
+    sessionId?: string;
+    /** AI mode when message was sent ('planning' or 'agent' or 'auto') */
+    mode?: 'planning' | 'agent' | 'auto';
+    /**
+     * Abort signal for THIS turn. Protocol sessions are cached across turns, so
+     * a signal passed at session creation goes stale after the first turn --
+     * per-message is the only correct place to carry it.
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Session created or resumed by the protocol
+ */
+export interface ProtocolSession {
+    /** Platform-specific session identifier */
+    id: string;
+    /** Platform identifier (e.g., 'claude-sdk', 'codex-sdk') */
+    platform: string;
+    /** Platform-specific session data (for internal use) */
+    raw?: RawProtocolSession;
+}
+/**
+ * Event types emitted during message streaming
+ */
+export type ProtocolEventType = 'raw_event' | 'text' | 'reasoning' | 'tool_call' | 'tool_result' | 'error' | 'complete' | 'usage' | 'planning_mode_entered' | 'planning_mode_exited';
+/**
+ * Event emitted during message streaming
+ */
+export interface ProtocolEvent {
+    /** Event type */
+    type: ProtocolEventType;
+    /** Text content (for 'text' events) */
+    content?: string;
+    /** Tool call data (for 'tool_call' events) */
+    toolCall?: {
+        id?: string;
+        name: string;
+        arguments?: Record<string, any>;
+        result?: ToolResult | string;
+    };
+    /** Tool result data (for 'tool_result' events) */
+    toolResult?: {
+        id?: string;
+        name: string;
+        result?: ToolResult | string;
+    };
+    /** Error message (for 'error' events) */
+    error?: string;
+    /** Token usage (for 'usage' or 'complete' events) */
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    };
+    /** Current context fill tokens for this turn (provider-reported snapshot) */
+    contextFillTokens?: number;
+    /** Maximum context window for the active model */
+    contextWindow?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent Protocol Interface
+ *
+ * All agent SDK adapters must implement this interface to provide
+ * a consistent abstraction layer for agent providers.
+ */
+export interface AgentProtocol {
+    /**
+     * Platform identifier (e.g., 'claude-sdk', 'codex-sdk')
+     */
+    readonly platform: string;
+    /**
+     * Create a new session
+     *
+     * @param options - Session configuration
+     * @returns Protocol session with platform-specific ID
+     */
+    createSession(options: SessionOptions): Promise<ProtocolSession>;
+    /**
+     * Resume an existing session
+     *
+     * @param sessionId - Platform-specific session ID to resume
+     * @param options - Session configuration
+     * @returns Protocol session
+     */
+    resumeSession(sessionId: string, options: SessionOptions): Promise<ProtocolSession>;
+    /**
+     * Fork an existing session (create a branch)
+     *
+     * Not all platforms support forking. If unsupported, implementations
+     * should either throw an error or create a new session.
+     *
+     * @param sessionId - Platform-specific session ID to fork from
+     * @param options - Session configuration for the fork
+     * @returns New protocol session branched from the source
+     */
+    forkSession(sessionId: string, options: SessionOptions): Promise<ProtocolSession>;
+    /**
+     * Send a message and receive streaming events
+     *
+     * @param session - Active protocol session
+     * @param message - Message to send
+     * @returns Async iterable of protocol events
+     */
+    sendMessage(session: ProtocolSession, message: ProtocolMessage): AsyncIterable<ProtocolEvent>;
+    /**
+     * Abort an active session
+     *
+     * @param session - Session to abort
+     */
+    abortSession(session: ProtocolSession): void;
+    /**
+     * Clean up session resources
+     *
+     * Called when a session is deleted or no longer needed.
+     *
+     * @param session - Session to clean up
+     */
+    cleanupSession(session: ProtocolSession): void;
+}
+//# sourceMappingURL=AgentProtocol.d.ts.map

package/dist/agents/AgentProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentProtocol.d.ts","sourceRoot":"","sources":["../../src/agents/AgentProtocol.ts"],"names":[],"mappings":"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"}

package/dist/agents/AgentProtocol.js

@@ -0,0 +1,23 @@
+/**
+ * Protocol Interface for Agent SDK Adapters
+ *
+ * This interface normalizes the differences between various agent SDKs
+ * (Claude Agent SDK, OpenAI Codex SDK) to provide a unified abstraction
+ * layer for agent providers.
+ *
+ * The protocol adapters isolate platform-specific SDK details from the
+ * provider implementations, making it easier to:
+ * - Add new agent SDKs
+ * - Update SDK versions without touching provider logic
+ * - Test providers with mock protocols
+ * - Share common infrastructure across providers
+ *
+ * Ownership note: this module is the canonical home of the protocol
+ * contract. The runtime re-exports these types via
+ * `@nimbalyst/runtime/ai/server/protocols/ProtocolInterface` so that
+ * existing runtime imports keep working without source churn, but the
+ * SDK now owns the type bodies. Adding a new field, changing a tag, or
+ * tightening a discriminator happens here first; the runtime picks it
+ * up via the re-export.
+ */
+export {};