@borgee/agents-host 0.2.101 → 0.2.110

package/dist/gateway/localhost-gateway.js

@@ -61,13 +61,15 @@ class RestartableConnectionsStateStore {
 class InMemoryGatewayTokenRegistry {
     resolveBaseUrl;
     tokenFactory;
+    resolveStableAgentId;
     activateRollback;
     byChannel = new Map();
     byToken = new Map();
     pendingTokensByChannel = new Map();
-    constructor(resolveBaseUrl, tokenFactory, activateRollback = () => { }) {
+    constructor(resolveBaseUrl, tokenFactory, resolveStableAgentId, activateRollback = () => { }) {
         this.resolveBaseUrl = resolveBaseUrl;
         this.tokenFactory = tokenFactory;
+        this.resolveStableAgentId = resolveStableAgentId;
         this.activateRollback = activateRollback;
     }
     activate() {
@@ -134,6 +136,7 @@ class InMemoryGatewayTokenRegistry {
         const created = {
             channelId,
             token: this.issueUniqueToken(),
+            agentId: this.resolveStableAgentId?.()?.trim() || undefined,
         };
         this.byChannel.set(channelId, created);
         this.byToken.set(created.token, created);
@@ -424,7 +427,7 @@ class LoopbackLocalhostGatewayController {
                     return;
                 }
                 case 'files': {
-                    const files = await this.controlPlane.listChannelFiles({ channelId: binding.channelId });
+                    const files = await this.controlPlane.listChannelFiles({ channelId: this.resolveFileScopeChannelId(binding) });
                     this.sendJson(response, 200, { files });
                     this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
                     return;
@@ -437,7 +440,7 @@ class LoopbackLocalhostGatewayController {
                     }
                     validatePortableRelativePath(path);
                     const content = await this.controlPlane.readChannelFile({
-                        channelId: binding.channelId,
+                        channelId: this.resolveFileScopeChannelId(binding),
                         path,
                         textOnly: true,
                     });
@@ -449,7 +452,7 @@ class LoopbackLocalhostGatewayController {
                     const body = parseFileTransferBody(await readGatewayJsonBody(request));
                     const rootPath = requireExecutionRoot(binding.payload ?? {});
                     const content = await this.controlPlane.readChannelFile({
-                        channelId: binding.channelId,
+                        channelId: this.resolveFileScopeChannelId(binding),
                         path: body.path,
                         textOnly: false,
                     });
@@ -464,13 +467,13 @@ class LoopbackLocalhostGatewayController {
                 case 'file-sync': {
                     const body = parseFileSyncBody(await readGatewayJsonBody(request));
                     const rootPath = requireExecutionRoot(binding.payload ?? {});
-                    const entries = (await this.controlPlane.listChannelFiles({ channelId: binding.channelId }))
+                    const entries = (await this.controlPlane.listChannelFiles({ channelId: this.resolveFileScopeChannelId(binding) }))
                         .filter((file) => !file.isDirectory)
                         .filter((file) => body.path == null || file.path === body.path || file.path.startsWith(`${body.path}/`));
                     const synced = [];
                     for (const file of entries) {
                         const content = await this.controlPlane.readChannelFile({
-                            channelId: binding.channelId,
+                            channelId: this.resolveFileScopeChannelId(binding),
                             path: file.path,
                             textOnly: false,
                         });
@@ -496,7 +499,7 @@ class LoopbackLocalhostGatewayController {
                     }
                     const content = await readWorkspaceFile(rootPath, body.sourcePath);
                     const file = await this.controlPlane.publishChannelFile({
-                        channelId: binding.channelId,
+                        channelId: this.resolveFileScopeChannelId(binding),
                         path: body.channelPath,
                         contentType: body.contentType ?? inferContentType(body.sourcePath),
                         base64: content.toString('base64'),
@@ -709,6 +712,12 @@ class LoopbackLocalhostGatewayController {
             throw error;
         }
     }
+    resolveFileScopeChannelId(binding) {
+        const taskChannelId = binding.payload?.taskAssignmentContext?.taskChannelId;
+        return typeof taskChannelId === 'string' && taskChannelId.trim().length > 0
+            ? taskChannelId
+            : binding.channelId;
+    }
     async loadAuthorizedTask(boundChannelId, route) {
         let task;
         try {
@@ -1031,7 +1040,23 @@ function mapGatewayControlPlaneError(error, fallbackReason) {
             case 'bpp.task_not_found':
             case 'bpp.channel_not_found':
             case 'bpp.guild_not_found':
+            case 'bpp.file_not_found':
                 return new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+            case 'bpp.file_invalid':
+            case 'bpp.file_content_invalid':
+                return new GatewayHttpError(400, { error: 'invalid_file_content' }, 'bad-request');
+            case 'bpp.file_input_required':
+                return new GatewayHttpError(422, { error: 'file_input_required' }, 'bad-request');
+            case 'bpp.file_conflict':
+                return new GatewayHttpError(409, { error: 'file_conflict' }, 'conflict');
+            case 'bpp.file_too_large':
+            case 'bpp.file_extracted_content_too_large':
+                return new GatewayHttpError(413, { error: 'file_too_large' }, 'bad-request');
+            case 'bpp.file_unsupported_media_type':
+            case 'bpp.file_extractor_required':
+                return new GatewayHttpError(415, { error: 'file_extractor_required' }, 'bad-request');
+            case 'bpp.file_extraction_failed':
+                return new GatewayHttpError(502, { error: 'file_extraction_failed' }, 'invalid-file-content');
             case 'bpp.task_title_required':
                 return new GatewayHttpError(400, { error: 'title_required' }, 'bad-request');
             case 'bpp.task_no_updates':
@@ -1088,7 +1113,7 @@ export function createLocalhostGatewayController(options) {
     }
     const contextPublisherFactory = (resolveBaseUrl) => {
         if (!options.tokenBindingGateEnabled) {
-            return new InMemoryGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), () => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
+            return new InMemoryGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), options.resolveStableAgentId, () => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
         }
         const stateRootDir = options.stateRootDir?.trim();
         if (!stateRootDir) {

package/dist/hosted-turn-content.js

@@ -27,7 +27,7 @@ export function buildHostedTurnContentParts(input) {
     return parts;
 }
 export function extractHostedMessageAttachments(parts) {
-    return parts.flatMap((part) => ('attachment' in part ? [normalizeHostedMessageAttachment(part.attachment)] : []));
+    return parts.flatMap((part) => 'attachment' in part ? [normalizeHostedMessageAttachment(part.attachment)] : []);
 }
 export function buildHostedIncomingContentText(parts) {
     const text = parts
@@ -42,7 +42,8 @@ export function buildHostedIncomingContentText(parts) {
         `[Attachment metadata was received for ${nonTextParts.length} attachment${nonTextParts.length === 1 ? '' : 's'}]`,
         ...nonTextParts.map((part, index) => {
             const filename = part.attachment.filename?.trim();
-            return `${index + 1}. ${part.type};${filename ? ` filename: ${filename};` : ''} content type: ${part.attachment.contentType}`;
+            const size = part.attachment.sizeBytes;
+            return `${index + 1}. ${part.type};${filename ? ` filename: ${filename};` : ''} content type: ${part.attachment.contentType}${size !== undefined ? `; size: ${size} bytes` : ''}`;
         }),
     ];
     const summary = summaryLines.join('\n');

package/dist/local-config.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
-import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseBooleanValue, parseProviderIdleShutdownMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseBooleanValue, parseProviderIdleShutdownMinutesValue, parseProviderOutputMode, parseCodexConnectionMode, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
 import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
@@ -107,6 +107,21 @@ function parseProviderCommandOverrides(value, sourceLabel) {
     if (claudeArgs !== undefined) {
         overrides.claudeArgs = claudeArgs;
     }
+    if (value.providerOutputMode !== undefined)
+        overrides.providerOutputMode = parseProviderOutputMode(value.providerOutputMode);
+    if (value.codexConnectionMode !== undefined)
+        overrides.codexConnectionMode = parseCodexConnectionMode(value.codexConnectionMode);
+    const sessionWorkspaceRoot = optionalNonEmptyString(value.sessionWorkspaceRoot, 'sessionWorkspaceRoot', sourceLabel);
+    if (sessionWorkspaceRoot !== undefined)
+        overrides.sessionWorkspaceRoot = sessionWorkspaceRoot;
+    const nativeProviderCommand = optionalNonEmptyString(value.nativeProviderCommand, 'nativeProviderCommand', sourceLabel);
+    if (nativeProviderCommand !== undefined)
+        overrides.nativeProviderCommand = nativeProviderCommand;
+    const codexSharedSocketPath = optionalNonEmptyString(value.codexSharedSocketPath, 'codexSharedSocketPath', sourceLabel);
+    if (codexSharedSocketPath !== undefined)
+        overrides.codexSharedSocketPath = codexSharedSocketPath;
+    if (value.codexTrustShared !== undefined)
+        overrides.codexTrustShared = parseBooleanValue(value.codexTrustShared, 'codexTrustShared', sourceLabel);
     const codexCommand = optionalNonEmptyString(value.codexCommand, 'codexCommand', sourceLabel);
     if (codexCommand !== undefined) {
         overrides.codexCommand = codexCommand;
@@ -688,6 +703,18 @@ function renderAgentConfigYaml(agent) {
     if (agent.enabled !== undefined) {
         config.enabled = agent.enabled;
     }
+    if (agent.providerOutputMode !== undefined)
+        config.providerOutputMode = agent.providerOutputMode;
+    if (agent.sessionWorkspaceRoot !== undefined)
+        config.sessionWorkspaceRoot = agent.sessionWorkspaceRoot;
+    if (agent.nativeProviderCommand !== undefined)
+        config.nativeProviderCommand = agent.nativeProviderCommand;
+    if (agent.codexConnectionMode !== undefined)
+        config.codexConnectionMode = agent.codexConnectionMode;
+    if (agent.codexSharedSocketPath !== undefined)
+        config.codexSharedSocketPath = agent.codexSharedSocketPath;
+    if (agent.codexTrustShared !== undefined)
+        config.codexTrustShared = agent.codexTrustShared;
     if (agent.claudeCommand !== undefined) {
         config.claudeCommand = agent.claudeCommand;
     }
@@ -742,6 +769,12 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
 function resolveAgentProviderCommandConfig(hostDefaults, agent) {
     return resolveProviderCommandConfig({
         ...hostDefaults,
+        ...(agent.providerOutputMode !== undefined ? { providerOutputMode: agent.providerOutputMode } : {}),
+        ...(agent.sessionWorkspaceRoot !== undefined ? { sessionWorkspaceRoot: agent.sessionWorkspaceRoot } : {}),
+        ...(agent.nativeProviderCommand !== undefined ? { nativeProviderCommand: agent.nativeProviderCommand } : {}),
+        ...(agent.codexConnectionMode !== undefined ? { codexConnectionMode: agent.codexConnectionMode } : {}),
+        ...(agent.codexSharedSocketPath !== undefined ? { codexSharedSocketPath: agent.codexSharedSocketPath } : {}),
+        ...(agent.codexTrustShared !== undefined ? { codexTrustShared: agent.codexTrustShared } : {}),
         ...(agent.claudeCommand !== undefined ? { claudeCommand: agent.claudeCommand } : {}),
         ...(agent.claudeArgs !== undefined ? { claudeArgs: agent.claudeArgs } : {}),
         ...(agent.codexCommand !== undefined ? { codexCommand: agent.codexCommand } : {}),

package/dist/managed-daemon.js

@@ -351,6 +351,11 @@ export function buildManagedLocalAgentConfig(options) {
             apiKey: config.agent.agentApiKey,
             provider: config.agent.provider,
             enabled: true,
+            ...(config.providerOutputMode !== undefined ? { providerOutputMode: config.providerOutputMode } : {}),
+            ...(config.nativeProviderCommand !== undefined ? { nativeProviderCommand: config.nativeProviderCommand } : {}),
+            ...(config.codexConnectionMode !== undefined ? { codexConnectionMode: config.codexConnectionMode } : {}),
+            ...(config.codexSharedSocketPath !== undefined ? { codexSharedSocketPath: config.codexSharedSocketPath } : {}),
+            ...(config.codexTrustShared !== undefined ? { codexTrustShared: config.codexTrustShared } : {}),
             claudeCommand: config.claudeCommand,
             claudeArgs: [...config.claudeArgs],
             codexCommand: config.codexCommand,
@@ -382,6 +387,11 @@ function mergeManagedLocalAgentConfig(hostDefaults, existingAgent, generatedAgen
         enabled: true,
         name: hasOverride('BORGEE_AGENT_NAME') ? generatedAgent.name : existingAgent.name,
         provider: hasOverride('RUNTIME_PROVIDER') ? generatedAgent.provider : existingAgent.provider,
+        providerOutputMode: hasOverride('PROVIDER_OUTPUT_MODE') ? generatedAgent.providerOutputMode : existingAgent.providerOutputMode,
+        nativeProviderCommand: hasOverride('NATIVE_PROVIDER_COMMAND') ? generatedAgent.nativeProviderCommand : existingAgent.nativeProviderCommand,
+        codexConnectionMode: hasOverride('CODEX_CONNECTION_MODE') ? generatedAgent.codexConnectionMode : existingAgent.codexConnectionMode,
+        codexSharedSocketPath: hasOverride('CODEX_SHARED_SOCKET_PATH') ? generatedAgent.codexSharedSocketPath : existingAgent.codexSharedSocketPath,
+        codexTrustShared: hasOverride('CODEX_TRUST_SHARED') ? generatedAgent.codexTrustShared : existingAgent.codexTrustShared,
         claudeCommand: hasOverride('CLAUDE_COMMAND') || shouldRefreshLegacyClaudeDefaults
             ? generatedAgent.claudeCommand
             : existingAgent.claudeCommand,
@@ -416,6 +426,11 @@ function collectExplicitManagedAgentEnvOverrides(processEnv, optionEnv) {
     for (const key of [
         'BORGEE_AGENT_NAME',
         'RUNTIME_PROVIDER',
+        'PROVIDER_OUTPUT_MODE',
+        'NATIVE_PROVIDER_COMMAND',
+        'CODEX_CONNECTION_MODE',
+        'CODEX_SHARED_SOCKET_PATH',
+        'CODEX_TRUST_SHARED',
         'CLAUDE_COMMAND',
         'CLAUDE_ARGS',
         'CODEX_COMMAND',

package/dist/native-environment.d.ts

@@ -0,0 +1,2 @@
+/** Explicit undefined values survive the native adapters' process.env merge. */
+export declare function filterNativeEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/native-environment.js

@@ -0,0 +1,9 @@
+/** Explicit undefined values survive the native adapters' process.env merge. */
+export function filterNativeEnvironment(env) {
+    const native = { ...env };
+    for (const key of Object.keys(native)) {
+        if (/^(?:BORGEE_|AGENT_HOST_|AGENT_REMOTE_|GATEWAY_|RELAY_)/i.test(key))
+            native[key] = undefined;
+    }
+    return native;
+}

package/dist/native-protocol-types/codec.d.ts

@@ -0,0 +1,49 @@
+import { type AgentStreamMessage as AgentStreamMessageValue } from './envelope.js';
+import { type HistoryPage as HistoryPageValue } from './history.js';
+import { type AgentSessionResponse as AgentSessionResponseValue, type ClientMessage as ClientMessageValue, type CommandAcknowledgementMessage as CommandAcknowledgementMessageValue, type CreateAgentRequest as CreateAgentRequestValue, type IncompatibleProtocolVersionErrorMessage as IncompatibleProtocolVersionErrorMessageValue, type ProviderListResponse as ProviderListResponseValue, type ResumeAgentRequest as ResumeAgentRequestValue, type ServerMessage as ServerMessageValue } from './messages.js';
+import { type ResourceResponse as ResourceResponseValue, type ResourceUpdate as ResourceUpdateValue } from './resources.js';
+import { type AgentSnapshot as AgentSnapshotValue } from './snapshot.js';
+export interface WireIssue {
+    code: 'invalid_json' | 'invalid_shape' | 'incompatible_protocol_version' | 'not_json_serializable';
+    path: string;
+    message: string;
+}
+export type WireDecodeResult<T> = {
+    status: 'ok';
+    value: T;
+} | {
+    status: 'rejected';
+    issues: WireIssue[];
+};
+export type WireEncodeResult = {
+    status: 'ok';
+    json: string;
+} | {
+    status: 'rejected';
+    issues: WireIssue[];
+};
+export declare function decodeAgentSnapshot(json: string): WireDecodeResult<AgentSnapshotValue>;
+export declare function encodeAgentSnapshot(value: AgentSnapshotValue): WireEncodeResult;
+export declare function decodeHistoryPage(json: string): WireDecodeResult<HistoryPageValue>;
+export declare function encodeHistoryPage(value: HistoryPageValue): WireEncodeResult;
+export declare function decodeAgentStreamMessage(json: string): WireDecodeResult<AgentStreamMessageValue>;
+export declare function encodeAgentStreamMessage(value: AgentStreamMessageValue): WireEncodeResult;
+export declare function decodeResourceResponse(json: string): WireDecodeResult<ResourceResponseValue>;
+export declare function encodeResourceResponse(value: ResourceResponseValue): WireEncodeResult;
+export declare function decodeResourceUpdate(json: string): WireDecodeResult<ResourceUpdateValue>;
+export declare function encodeResourceUpdate(value: ResourceUpdateValue): WireEncodeResult;
+export declare function decodeCreateAgentRequest(json: string): WireDecodeResult<CreateAgentRequestValue>;
+export declare function encodeCreateAgentRequest(value: CreateAgentRequestValue): WireEncodeResult;
+export declare function decodeResumeAgentRequest(json: string): WireDecodeResult<ResumeAgentRequestValue>;
+export declare function encodeResumeAgentRequest(value: ResumeAgentRequestValue): WireEncodeResult;
+export declare function decodeAgentSessionResponse(json: string): WireDecodeResult<AgentSessionResponseValue>;
+export declare function encodeAgentSessionResponse(value: AgentSessionResponseValue): WireEncodeResult;
+export declare function decodeProviderListResponse(json: string): WireDecodeResult<ProviderListResponseValue>;
+export declare function encodeProviderListResponse(value: ProviderListResponseValue): WireEncodeResult;
+export declare function decodeCommandAcknowledgementMessage(json: string): WireDecodeResult<CommandAcknowledgementMessageValue>;
+export declare function encodeCommandAcknowledgementMessage(value: CommandAcknowledgementMessageValue): WireEncodeResult;
+export declare function decodeClientMessage(json: string): WireDecodeResult<ClientMessageValue>;
+export declare function encodeClientMessage(value: ClientMessageValue): WireEncodeResult;
+export declare function decodeServerMessage(json: string): WireDecodeResult<ServerMessageValue>;
+export declare function decodeIncompatibleProtocolVersionError(json: string): WireDecodeResult<IncompatibleProtocolVersionErrorMessageValue>;
+export declare function encodeServerMessage(value: ServerMessageValue): WireEncodeResult;

package/dist/native-protocol-types/commands.d.ts

@@ -0,0 +1,71 @@
+import { type Static } from '@sinclair/typebox';
+export declare const AgentCommand: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"command">, import("@sinclair/typebox").TLiteral<"skill">, import("@sinclair/typebox").TLiteral<"prompt">]>;
+    inputHint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    shortDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    documentation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        locator: import("@sinclair/typebox").TString;
+        resourceId: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"available">, import("@sinclair/typebox").TLiteral<"failed">, import("@sinclair/typebox").TLiteral<"unavailable">]>;
+    }>>;
+}>;
+export type AgentCommand = Static<typeof AgentCommand>;
+export declare const AgentCommandResult: import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type AgentCommandResult = Static<typeof AgentCommandResult>;
+export declare const ListCommandsRequest: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"list_commands">;
+    payload: import("@sinclair/typebox").TObject<{
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const CommandListResponse: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"command_list">;
+    payload: import("@sinclair/typebox").TObject<{
+        commands: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TString;
+            kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"command">, import("@sinclair/typebox").TLiteral<"skill">, import("@sinclair/typebox").TLiteral<"prompt">]>;
+            inputHint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            shortDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            documentation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                locator: import("@sinclair/typebox").TString;
+                resourceId: import("@sinclair/typebox").TString;
+                status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"available">, import("@sinclair/typebox").TLiteral<"failed">, import("@sinclair/typebox").TLiteral<"unavailable">]>;
+            }>>;
+        }>>;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export type CommandListResponse = Static<typeof CommandListResponse>;
+export declare const ExecuteCommandRequest: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"execute_command">;
+    payload: import("@sinclair/typebox").TObject<{
+        commandId: import("@sinclair/typebox").TString;
+        args: import("@sinclair/typebox").TString;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const CommandResultResponse: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"command_result">;
+    payload: import("@sinclair/typebox").TObject<{
+        result: import("@sinclair/typebox").TObject<{
+            text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export type CommandResultResponse = Static<typeof CommandResultResponse>;

package/dist/native-protocol-types/compatibility.d.ts

@@ -0,0 +1,5 @@
+import { PROTOCOL_VERSION } from './version.js';
+export type NormalizedProtocolVersion = typeof PROTOCOL_VERSION | '1.6.0' | '1.5.0' | '1.4.0' | '1.1.0';
+export declare function isSupportedNormalizedVersion(version: unknown): version is NormalizedProtocolVersion;
+/** Validate committed bytes in their declared schema before adapting a projection copy. */
+export declare function validateNormalizedEventVersion(version: string, event: unknown): boolean;

package/dist/native-protocol-types/cursor.d.ts

@@ -0,0 +1,7 @@
+import { type Static } from '@sinclair/typebox';
+export declare const SafeNonNegativeInteger: import("@sinclair/typebox").TInteger;
+export declare const TimelineCursor: import("@sinclair/typebox").TObject<{
+    epoch: import("@sinclair/typebox").TString;
+    seq: import("@sinclair/typebox").TInteger;
+}>;
+export type TimelineCursor = Static<typeof TimelineCursor>;