@makaio/contracts 1.0.0-dev-1779051654000

package/dist/protocol/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/protocol/catalog.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASQ,CAAC"}

package/dist/protocol/export-manifest-audit-utils.d.ts

@@ -0,0 +1,38 @@
+import type { ProtocolExportAuditCheckResult, ProtocolExportAuditIssue, ProtocolExportSubjectAudit, ProtocolNamespaceCatalog, ProtocolNamespaceCatalogEntry } from './types.js';
+/**
+ * Resolve the selected subject keys for a catalog entry.
+ * @param entry - Protocol catalog entry to inspect
+ * @returns Sorted subject keys selected by the catalog entry
+ */
+export declare function getCatalogSubjectKeys(entry: ProtocolNamespaceCatalogEntry): string[];
+/**
+ * Build a namespace-keyed catalog map and reject duplicate entries.
+ * @param catalog - Explicit publication catalog
+ * @returns Catalog entries keyed by namespace
+ */
+export declare function getCatalogEntries(catalog: ProtocolNamespaceCatalog): Map<string, ProtocolNamespaceCatalogEntry>;
+/**
+ * Create a blocking audit issue for one selected subject.
+ * @param namespace - Namespace selected by the catalog
+ * @param subject - Subject key selected by the catalog
+ * @param check - Audit check that failed
+ * @param message - Failure message to report
+ * @returns Structured protocol export audit issue
+ */
+export declare function createAuditIssue(namespace: string, subject: string, check: ProtocolExportAuditIssue['check'], message: string): ProtocolExportAuditIssue;
+/**
+ * Create an audit entry for a selected subject.
+ * @param namespace - Namespace selected by the catalog
+ * @param subject - Subject key selected by the catalog
+ * @param jsonSchema - JSON Schema export audit result
+ * @param rustModel - Rust model generation audit result
+ * @returns Per-subject protocol export audit result
+ */
+export declare function createSubjectAudit(namespace: string, subject: string, jsonSchema: ProtocolExportAuditCheckResult, rustModel: ProtocolExportAuditCheckResult): ProtocolExportSubjectAudit;
+/**
+ * Format blocking audit issues for a thrown export error.
+ * @param issues - Blocking audit issues to format
+ * @returns Human-readable audit failure summary
+ */
+export declare function formatProtocolExportAuditIssues(issues: readonly ProtocolExportAuditIssue[]): string;
+//# sourceMappingURL=export-manifest-audit-utils.d.ts.map

package/dist/protocol/export-manifest-audit-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-manifest-audit-utils.d.ts","sourceRoot":"","sources":["../../src/protocol/export-manifest-audit-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAC9B,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,YAAY,CAAC;AAGpB;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,6BAA6B,GAAG,MAAM,EAAE,CAYpF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAY/G;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,wBAAwB,CAQ1B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,8BAA8B,EAC1C,SAAS,EAAE,8BAA8B,GACxC,0BAA0B,CAQ5B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,SAAS,wBAAwB,EAAE,GAAG,MAAM,CAGnG"}

package/dist/protocol/export-manifest-json-utils.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { JsonObject } from './types.js';
+/**
+ * Check whether a value is a JSON object.
+ * @param value - Value to check
+ * @returns True when the value is a non-array object
+ */
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/**
+ * Recursively sort JSON object keys while preserving array order.
+ * @param value - JSON-compatible value to sort
+ * @returns Value with object keys sorted deterministically
+ */
+export declare function sortJsonValue(value: unknown): unknown;
+/**
+ * Convert a Zod schema to the embedded manifest JSON Schema shape.
+ * @param namespace - Namespace being exported
+ * @param subject - Subject being exported
+ * @param schema - Zod schema to convert
+ * @returns JSON Schema without a top-level dialect marker
+ */
+export declare function toManifestJsonSchema(namespace: string, subject: string, schema: z.ZodType): JsonObject;
+//# sourceMappingURL=export-manifest-json-utils.d.ts.map

package/dist/protocol/export-manifest-json-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-manifest-json-utils.d.ts","sourceRoot":"","sources":["../../src/protocol/export-manifest-json-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAcrD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,UAAU,CAiBtG"}

package/dist/protocol/export-manifest-rust-checker.d.ts

@@ -0,0 +1,11 @@
+import type { MakaioProtocolSubject, ProtocolExportAuditCheckResult } from './types.js';
+/**
+ * Default Rust model representability checker.
+ * Walks the JSON Schema tree for each embedded schema and flags patterns that cannot be
+ * represented as Rust structs by the Makaio Rust SDK code generator.
+ * @param subject - Manifest subject whose schemas are checked for Rust representability
+ * @returns Passed audit result when all schemas are representable, or failed with a
+ *   descriptive message identifying the first non-representable pattern found
+ */
+export declare function defaultRustModelChecker(subject: MakaioProtocolSubject): ProtocolExportAuditCheckResult;
+//# sourceMappingURL=export-manifest-rust-checker.d.ts.map

package/dist/protocol/export-manifest-rust-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-manifest-rust-checker.d.ts","sourceRoot":"","sources":["../../src/protocol/export-manifest-rust-checker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,qBAAqB,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AA4GpG;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,qBAAqB,GAAG,8BAA8B,CAStG"}

package/dist/protocol/export-manifest-string-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compare two strings using stable code-point ordering.
+ * @param left - Left-hand string to compare
+ * @param right - Right-hand string to compare
+ * @returns Negative when `left` sorts before `right`, positive when after, otherwise zero
+ */
+export declare function compareCodePointStrings(left: string, right: string): number;
+/**
+ * Compare two strings with a stable case-folded primary order and code-point tie-breaker.
+ *
+ * This stays local to `contracts` even though `bus-core` has a sibling helper with the same
+ * semantics: manifest export must not depend on `bus-core` runtime code just to sort subjects.
+ * @param left - Left-hand string to compare
+ * @param right - Right-hand string to compare
+ * @returns Negative when `left` sorts before `right`, positive when after, otherwise zero
+ */
+export declare function compareStrings(left: string, right: string): number;
+//# sourceMappingURL=export-manifest-string-utils.d.ts.map

package/dist/protocol/export-manifest-string-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-manifest-string-utils.d.ts","sourceRoot":"","sources":["../../src/protocol/export-manifest-string-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlE"}

package/dist/protocol/index.d.ts

@@ -0,0 +1,5 @@
+export { PublicProtocolNamespaces } from './catalog.js';
+export { defaultRustModelChecker } from './export-manifest-rust-checker.js';
+export { formatProtocolExportAuditIssues } from './export-manifest-audit-utils.js';
+export type { JsonObject, MakaioProtocolEventSubject, MakaioProtocolManifest, MakaioProtocolRequestSubject, MakaioProtocolSubject, MakaioProtocolSubjectBase, ProtocolExportAuditCheckResult, ProtocolExportAuditIssue, ProtocolExportAuditReport, ProtocolExportAuditStatus, ProtocolExportOptions, ProtocolExportSubjectAudit, ProtocolNamespaceCatalog, ProtocolNamespaceCatalogEntry, RustModelRepresentabilityChecker, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocol/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AACnF,YAAY,EACV,UAAU,EACV,0BAA0B,EAC1B,sBAAsB,EACtB,4BAA4B,EAC5B,qBAAqB,EACrB,yBAAyB,EACzB,8BAA8B,EAC9B,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,wBAAwB,EACxB,6BAA6B,EAC7B,gCAAgC,GACjC,MAAM,YAAY,CAAC"}

package/dist/protocol/types.d.ts

@@ -0,0 +1,107 @@
+import type { SchemaRecord } from '@makaio/framework/core';
+/** JSON object used for embedded JSON Schema documents. */
+export type JsonObject = Record<string, unknown>;
+/** Protocol manifest emitted for language-specific SDK generation. */
+export interface MakaioProtocolManifest {
+    /** Manifest format version. */
+    version: 2;
+    /** Published bus subjects selected by the protocol catalog. */
+    subjects: MakaioProtocolSubject[];
+}
+/** Shared fields for every published protocol subject. */
+export interface MakaioProtocolSubjectBase {
+    /** Namespace passed to `registerNamespace()`. */
+    namespace: string;
+    /** Subject key inside the namespace. */
+    subject: string;
+    /** Fully-qualified subject key in `namespace.subject` form. */
+    fullSubject: string;
+    /** Whether the subject is local-only in the TypeScript bus. */
+    local: boolean;
+    /** Whether the subject is channel-only in the TypeScript bus. */
+    channel: boolean;
+}
+/** Published fire-and-forget event subject. */
+export interface MakaioProtocolEventSubject extends MakaioProtocolSubjectBase {
+    /** Subject kind discriminator. */
+    kind: 'event';
+    /** JSON Schema for the event payload. */
+    payloadSchema: JsonObject;
+}
+/** Published request/response subject. */
+export interface MakaioProtocolRequestSubject extends MakaioProtocolSubjectBase {
+    /** Subject kind discriminator. */
+    kind: 'request';
+    /** JSON Schema for the request payload. */
+    requestSchema: JsonObject;
+    /** JSON Schema for the response payload. */
+    responseSchema: JsonObject;
+}
+/** One published protocol subject entry. */
+export type MakaioProtocolSubject = MakaioProtocolEventSubject | MakaioProtocolRequestSubject;
+/** Status for one protocol export audit check. */
+export type ProtocolExportAuditStatus = 'passed' | 'failed' | 'skipped';
+/** One protocol export audit check result. */
+export interface ProtocolExportAuditCheckResult {
+    /** Audit check status. */
+    status: ProtocolExportAuditStatus;
+    /** Human-readable detail for failed or skipped checks. */
+    message?: string;
+}
+/** One failed protocol export audit check. */
+export interface ProtocolExportAuditIssue {
+    /** Namespace passed to `registerNamespace()`. */
+    namespace: string;
+    /** Subject key inside the namespace. */
+    subject: string;
+    /** Fully-qualified subject key in `namespace.subject` form. */
+    fullSubject: string;
+    /** Audit check that produced the issue. */
+    check: 'jsonSchema' | 'rustModel';
+    /** Failure message for the selected subject. */
+    message: string;
+}
+/** Per-subject protocol export audit result. */
+export interface ProtocolExportSubjectAudit {
+    /** Namespace passed to `registerNamespace()`. */
+    namespace: string;
+    /** Subject key inside the namespace. */
+    subject: string;
+    /** Fully-qualified subject key in `namespace.subject` form. */
+    fullSubject: string;
+    /** JSON Schema export representability result. */
+    jsonSchema: ProtocolExportAuditCheckResult;
+    /** Rust model generation representability result. */
+    rustModel: ProtocolExportAuditCheckResult;
+}
+/** Structured protocol export audit report. */
+export interface ProtocolExportAuditReport {
+    /** Per-subject audit results for the selected catalog. */
+    subjects: ProtocolExportSubjectAudit[];
+    /** Failed audit checks that should block manifest export. */
+    issues: ProtocolExportAuditIssue[];
+}
+/** Checks whether a manifest subject can be represented as generated Rust structs. */
+export type RustModelRepresentabilityChecker = (subject: MakaioProtocolSubject) => ProtocolExportAuditCheckResult;
+/** Options for protocol manifest export and audit. */
+export interface ProtocolExportOptions {
+    /**
+     * Optional explicit catalog. When omitted, auto-discovers all registered subjects
+     * and silently skips those that cannot be exported (non-blocking mode).
+     */
+    catalog?: ProtocolNamespaceCatalog;
+    /** Optional override for the built-in Rust model representability checker. */
+    rustModelChecker?: RustModelRepresentabilityChecker;
+}
+/** Catalog entry selecting one namespace for protocol publication. */
+export interface ProtocolNamespaceCatalogEntry {
+    /** Registered namespace to publish from. */
+    namespace: string;
+    /** Source schemas owned by `@makaio/contracts`. */
+    schemas: SchemaRecord;
+    /** Optional named subset of schema keys to publish. */
+    subjects?: readonly string[];
+}
+/** Explicit publication policy for protocol manifest generation. */
+export type ProtocolNamespaceCatalog = readonly ProtocolNamespaceCatalogEntry[];
+//# sourceMappingURL=types.d.ts.map

package/dist/protocol/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/protocol/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,2DAA2D;AAC3D,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX,+DAA+D;IAC/D,QAAQ,EAAE,qBAAqB,EAAE,CAAC;CACnC;AAED,0DAA0D;AAC1D,MAAM,WAAW,yBAAyB;IACxC,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,KAAK,EAAE,OAAO,CAAC;IACf,iEAAiE;IACjE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,+CAA+C;AAC/C,MAAM,WAAW,0BAA2B,SAAQ,yBAAyB;IAC3E,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,yCAAyC;IACzC,aAAa,EAAE,UAAU,CAAC;CAC3B;AAED,0CAA0C;AAC1C,MAAM,WAAW,4BAA6B,SAAQ,yBAAyB;IAC7E,kCAAkC;IAClC,IAAI,EAAE,SAAS,CAAC;IAChB,2CAA2C;IAC3C,aAAa,EAAE,UAAU,CAAC;IAC1B,4CAA4C;IAC5C,cAAc,EAAE,UAAU,CAAC;CAC5B;AAED,4CAA4C;AAC5C,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,GAAG,4BAA4B,CAAC;AAE9F,kDAAkD;AAClD,MAAM,MAAM,yBAAyB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE,8CAA8C;AAC9C,MAAM,WAAW,8BAA8B;IAC7C,0BAA0B;IAC1B,MAAM,EAAE,yBAAyB,CAAC;IAClC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8CAA8C;AAC9C,MAAM,WAAW,wBAAwB;IACvC,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,KAAK,EAAE,YAAY,GAAG,WAAW,CAAC;IAClC,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,gDAAgD;AAChD,MAAM,WAAW,0BAA0B;IACzC,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,UAAU,EAAE,8BAA8B,CAAC;IAC3C,qDAAqD;IACrD,SAAS,EAAE,8BAA8B,CAAC;CAC3C;AAED,+CAA+C;AAC/C,MAAM,WAAW,yBAAyB;IACxC,0DAA0D;IAC1D,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,6DAA6D;IAC7D,MAAM,EAAE,wBAAwB,EAAE,CAAC;CACpC;AAED,sFAAsF;AACtF,MAAM,MAAM,gCAAgC,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,8BAA8B,CAAC;AAElH,sDAAsD;AACtD,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,gCAAgC,CAAC;CACrD;AAED,sEAAsE;AACtE,MAAM,WAAW,6BAA6B;IAC5C,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,OAAO,EAAE,YAAY,CAAC;IACtB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,oEAAoE;AACpE,MAAM,MAAM,wBAAwB,GAAG,SAAS,6BAA6B,EAAE,CAAC"}

package/dist/provider/definition.d.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+/**
+ * Wire protocol identifiers supported by Makaio adapters.
+ *
+ * Each value corresponds to an inference wire protocol:
+ * - `'anthropic'` — Anthropic Messages API (streaming via SSE)
+ * - `'openai'`    — OpenAI Chat Completions API (streaming via SSE)
+ */
+export declare const ProtocolIdSchema: z.ZodEnum<{
+    anthropic: "anthropic";
+    openai: "openai";
+}>;
+/**
+ * Inferred union type for supported wire protocols.
+ */
+export type ProtocolId = z.infer<typeof ProtocolIdSchema>;
+/**
+ * Maps wire protocol identifiers to their base endpoint URLs.
+ *
+ * A provider may support multiple protocols simultaneously — for example,
+ * Z.AI exposes both an Anthropic-compatible and an OpenAI-compatible endpoint.
+ * Omit a protocol key when the provider does not support it.
+ * @example Z.AI dual-protocol provider
+ * ```ts
+ * {
+ *   anthropic: 'https://api.z.ai/v1/anthropic',
+ *   openai: 'https://api.z.ai/v1/openai',
+ * }
+ * ```
+ */
+export declare const ProtocolEndpointsSchema: z.ZodObject<{
+    anthropic: z.ZodOptional<z.ZodString>;
+    openai: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Inferred type for a protocol-to-endpoint mapping.
+ */
+export type ProtocolEndpoints = z.infer<typeof ProtocolEndpointsSchema>;
+/**
+ * Provider definition schema.
+ *
+ * The canonical parsed provider contract. Defines the stable identity,
+ * display metadata, protocol endpoints, runtime-populated model catalog, and
+ * credential environment variables for a single inference provider.
+ *
+ * Static provider packages should declare {@link ProviderDefinitionInput}:
+ * they describe what a provider *is*, not how it is configured at runtime.
+ * The runtime layer (storage, sync service, model registry) derives parsed
+ * provider definitions and per-user provider records from those declarations.
+ *
+ * Providers that do not communicate over a network (e.g., GitHub Copilot,
+ * which uses its own SDK transport) omit `endpoints`.
+ * @example Anthropic provider definition
+ * ```ts
+ * {
+ *   id: 'anthropic',
+ *   name: 'Anthropic',
+ *   description: 'Official Anthropic Claude API',
+ *   endpoints: { anthropic: 'https://api.anthropic.com' },
+ *   defaultModel: 'claude-sonnet-4-5',
+ *   fastModel: 'claude-haiku-4-5',
+ *   credentialEnvVars: { apiKey: 'ANTHROPIC_API_KEY' },
+ * }
+ * ```
+ * `availableModels` is omitted — the registry service populates it from the
+ * YAML lab registry at boot time and defaults to `[]` when absent.
+ */
+export declare const ProviderDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    endpoints: z.ZodOptional<z.ZodObject<{
+        anthropic: z.ZodOptional<z.ZodString>;
+        openai: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    fastModel: z.ZodOptional<z.ZodString>;
+    primaryTestModel: z.ZodOptional<z.ZodString>;
+    secondaryTestModel: z.ZodOptional<z.ZodString>;
+    availableModels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        friendlyName: z.ZodOptional<z.ZodString>;
+        family: z.ZodOptional<z.ZodString>;
+        contextWindowSize: z.ZodNumber;
+        labId: z.ZodString;
+        supportedReasoningLevels: z.ZodOptional<z.ZodObject<{
+            none: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            low: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            medium: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            high: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            'extra-high': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        }, z.core.$strip>>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            capabilities: z.ZodOptional<z.ZodObject<{
+                vision: z.ZodOptional<z.ZodBoolean>;
+                toolCalling: z.ZodOptional<z.ZodBoolean>;
+                parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+                structuredOutput: z.ZodOptional<z.ZodBoolean>;
+                pdfUpload: z.ZodOptional<z.ZodBoolean>;
+                speechToText: z.ZodOptional<z.ZodObject<{
+                    modes: z.ZodArray<z.ZodEnum<{
+                        batch: "batch";
+                        streaming: "streaming";
+                    }>>;
+                    vocabularyBiasing: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                textToSpeech: z.ZodOptional<z.ZodObject<{
+                    modes: z.ZodArray<z.ZodEnum<{
+                        buffered: "buffered";
+                        streaming: "streaming";
+                    }>>;
+                    voiceSelection: z.ZodOptional<z.ZodBoolean>;
+                    voiceInstructions: z.ZodOptional<z.ZodBoolean>;
+                    outputFormats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            pricing: z.ZodOptional<z.ZodObject<{
+                token: z.ZodOptional<z.ZodObject<{
+                    inputPerMillion: z.ZodNumber;
+                    inputCachedPerMillion: z.ZodOptional<z.ZodNumber>;
+                    cacheWritePerMillion: z.ZodOptional<z.ZodNumber>;
+                    outputPerMillion: z.ZodNumber;
+                }, z.core.$strip>>;
+                request: z.ZodOptional<z.ZodObject<{
+                    multiplier: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            includedInSubscription: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    defaultModelFilterMode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        "show-all": "show-all";
+    }>>;
+    credentialEnvVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Inferred output type for a fully-parsed provider definition.
+ *
+ * Fields with `.default()` (e.g., `availableModels`) are always present here.
+ * Use this type for runtime consumers that read provider definition values.
+ */
+export type ProviderDefinition = z.infer<typeof ProviderDefinitionSchema>;
+/**
+ * Input type for provider definition declarations.
+ *
+ * Fields with `.default()` (e.g., `availableModels`) are optional here —
+ * the registry service populates them from YAML at boot time.
+ * Use this type when declaring a static `providerDefinition` constant in a
+ * provider package so that `availableModels` may be omitted.
+ */
+export type ProviderDefinitionInput = z.input<typeof ProviderDefinitionSchema>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/provider/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/provider/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;EAAkC,CAAC;AAEhE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB;;;iBAQhC,CAAC;AAEL;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkFnC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/provider/index.d.ts

@@ -0,0 +1,3 @@
+export { ModelVisibilitySchema, ModelFilterModeSchema, resolveModelVisibility, type ModelVisibility, type ModelFilterMode, } from './visibility.js';
+export { ProtocolIdSchema, ProtocolEndpointsSchema, ProviderDefinitionSchema, type ProtocolId, type ProtocolEndpoints, type ProviderDefinition, type ProviderDefinitionInput, } from './definition.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,wBAAwB,EACxB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,GAC7B,MAAM,iBAAiB,CAAC"}

package/dist/provider/index.mjs

@@ -0,0 +1 @@
+import{n as e,r as t,t as n}from"../visibility-D4i0fywT.mjs";import{n as r,r as i,t as a}from"../definition-7C4TvfXk.mjs";export{n as ModelFilterModeSchema,e as ModelVisibilitySchema,a as ProtocolEndpointsSchema,r as ProtocolIdSchema,i as ProviderDefinitionSchema,t as resolveModelVisibility};

package/dist/provider/visibility.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/**
+ * Per-model visibility state. Ordered: disabled → enabled → visible.
+ *
+ * - `disabled` — Model is off; cannot be used by profiles/workers or shown in picker.
+ * - `enabled` — Model is usable by profiles/workers but hidden from the AgentPicker.
+ * - `visible` — Model is usable and shown in the AgentPicker UI.
+ */
+export declare const ModelVisibilitySchema: z.ZodEnum<{
+    disabled: "disabled";
+    enabled: "enabled";
+    visible: "visible";
+}>;
+export type ModelVisibility = z.infer<typeof ModelVisibilitySchema>;
+/**
+ * Determines the default visibility state for models without explicit overrides.
+ *
+ * - `show-all` — All models default to `visible`. Suitable for curated providers (Anthropic, Gemini).
+ * - `allowlist` — All models default to `disabled`. Suitable for firehose providers (NanoGPT, OpenRouter).
+ */
+export declare const ModelFilterModeSchema: z.ZodEnum<{
+    allowlist: "allowlist";
+    "show-all": "show-all";
+}>;
+export type ModelFilterMode = z.infer<typeof ModelFilterModeSchema>;
+/**
+ * Resolves the effective visibility for a model given the provider's filter mode
+ * and any per-model overrides.
+ *
+ * Pure function usable by both backend validation and frontend filtering.
+ * @param modelName - The model identifier to resolve
+ * @param filterMode - The provider's filter mode
+ * @param overrides - Sparse per-model visibility overrides (nullable)
+ * @returns The resolved visibility state
+ */
+export declare function resolveModelVisibility(modelName: string, filterMode: ModelFilterMode, overrides: Record<string, ModelVisibility> | null | undefined): ModelVisibility;
+//# sourceMappingURL=visibility.d.ts.map

package/dist/provider/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../src/provider/visibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;EAA6C,CAAC;AAChF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;EAAoC,CAAC;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,IAAI,GAAG,SAAS,GAC5D,eAAe,CAEjB"}

package/dist/schemas-BJb5W0VZ.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";const t={FILE_READ:`file.read`,FILE_WRITE:`file.write`,FILE_DELETE:`file.delete`,SEARCH_CONTENT:`search.content`,SEARCH_FILES:`search.files`,SEARCH_WEB:`search.web`,SHELL_EXECUTE:`shell.execute`,NETWORK_REQUEST:`network.request`,PROCESS_MANAGE:`process.manage`},n=new Set([t.FILE_READ,t.SEARCH_CONTENT,t.SEARCH_FILES,t.SEARCH_WEB]),r=new Set([t.FILE_WRITE,t.FILE_DELETE,t.SHELL_EXECUTE,t.PROCESS_MANAGE]),i=Object.values(t),a=e.enum(i);function o(e){let t=[];return e.length>0&&e.every(e=>n.has(e))&&t.push(`read-only`),e.some(e=>r.has(e))&&t.push(`destructive`),t}const s=e.enum([`reject`,`always-ask`,`full-access`]),c=e.record(e.string(),s),l=e.object({enabled:e.array(e.string()),disabled:e.array(e.string())}),u=e=>!!e.clientId||!!e.adapterName,d=`At least one of clientId or adapterName must be set`,f=e.object({id:e.string(),name:e.string(),description:e.string().optional(),adapterName:e.string().min(1).optional(),clientId:e.string().min(1).optional(),approvalPolicy:s.default(`always-ask`),nativeTools:l,registryTools:l,skills:l.optional(),toolCapabilityMap:e.record(e.string(),e.array(a).readonly()).optional(),capabilityOverrides:e.record(e.string(),s).optional(),toolApprovalOverrides:c.optional(),env:e.record(e.string(),e.string()).optional(),credentials:e.record(e.string(),e.string()).optional(),cwd:e.string().optional(),isDefault:e.boolean().default(!1),enabled:e.boolean().default(!0),createdAt:e.number(),updatedAt:e.number()}),p=f.refine(u,{message:d}),m=f.omit({id:!0,createdAt:!0,updatedAt:!0}).extend({approvalPolicy:s.optional(),isDefault:e.boolean().optional(),enabled:e.boolean().optional()}).refine(u,{message:d});export{c as a,o as c,p as i,f as n,t as o,m as r,a as s,s as t};

package/dist/schemas-BkyMBNp4.mjs

@@ -0,0 +1 @@
+import{c as e,f as t,h as n,i as r,o as i,r as a,s as ee}from"./shared-CE23KND3.mjs";import{a as o,s as te}from"./visibility-D4i0fywT.mjs";import{t as ne}from"./credential-ref-DAVeyQ2h.mjs";import{t as re}from"./definition-7C4TvfXk.mjs";import{t as ie}from"./schemas-BJb5W0VZ.mjs";import{r as ae}from"./profile-Bcegl5D9.mjs";import{i as s}from"./account-identity-ZrtBl3Bq.mjs";import{SessionLineageSchema as oe}from"./adapter/schemas/session-lineage.mjs";import{z as c}from"zod";const l=c.object({adapterId:c.string(),adapterName:c.string()}),se=c.object({cwd:c.string().optional(),allowedTools:c.array(c.string()).optional(),disallowedTools:c.array(c.string()).optional(),allowedDirectories:c.array(c.string()).optional(),systemPrompt:t.optional()}),ce=`adapter identity must be provided at the top level; contextOverrides cannot supply adapter identity`;function le(e){let t={adapterId:e.adapterId,adapterName:e.adapterName},n={adapterId:e.contextOverrides?.adapterId,adapterName:e.contextOverrides?.adapterName},r=[];!u(t)&&u(n)&&(n.adapterId!==void 0&&r.push({field:`adapterId`,message:ce}),n.adapterName!==void 0&&r.push({field:`adapterName`,message:ce}));for(let e of[`adapterId`,`adapterName`]){let i=n[e];if(i===void 0)continue;let a=t[e];if(a===void 0){u(t)&&r.push({field:e,message:`contextOverrides.${e} cannot supply adapter identity when top-level adapter identity is present`});continue}a!==i&&r.push({field:e,message:`contextOverrides.${e} must match top-level ${e} when both are provided`})}return{issues:r,effectiveIdentity:{adapterId:t.adapterId??n.adapterId,adapterName:t.adapterName??n.adapterName}}}function u(e){return e.adapterId!==void 0||e.adapterName!==void 0}const ue=c.object({readOnly:c.boolean().optional(),destructive:c.boolean().optional(),idempotent:c.boolean().optional(),requiresApproval:c.boolean().optional()}),de=c.object({name:c.string(),description:c.string(),annotations:ue.optional(),toolsetName:c.string()}),fe=c.object({code:c.string(),message:c.string(),details:c.unknown().optional()}),d=c.object({toolName:c.string(),toolsetName:c.string()}),pe=de.extend({inputSchema:c.record(c.string(),c.unknown()).optional()}),me=c.object({name:c.string(),description:c.string(),version:c.string(),toolCount:c.number(),configSchema:c.record(c.string(),c.unknown()).optional()}),f=c.object({cwd:c.string().optional(),env:c.record(c.string(),c.string()).optional(),sessionId:c.string().optional(),agentId:c.string().optional(),adapterId:c.string().optional(),adapterName:c.string().optional(),turnId:c.string().optional(),turnContext:c.record(c.string(),c.unknown()).optional(),reasoning:c.string().optional(),toolCallId:c.string().optional(),constraints:c.record(c.string(),c.unknown()).optional()});function he(e,t){let{issues:n}=le(e);for(let e of n)t.addIssue({code:c.ZodIssueCode.custom,message:e.message,path:[`contextOverrides`,e.field]})}const ge=c.object({toolName:c.string(),input:c.unknown(),adapterId:c.string().optional(),adapterName:c.string().optional(),contextOverrides:f.optional()}).superRefine(he),_e={list:{request:c.object({toolsetName:c.string().optional(),adapterId:c.string().optional(),adapterName:c.string().optional()}),response:c.object({tools:c.array(pe),toolsets:c.array(me)})},execute:{request:ge,response:c.discriminatedUnion(`success`,[c.object({success:c.literal(!0),data:c.unknown()}),c.object({success:c.literal(!1),error:fe})])},registered:c.object({toolsetName:c.string(),toolsetVersion:c.string(),toolNames:c.array(c.string())}),started:d.extend({executionId:c.string(),timestamp:c.number()}),completed:d.extend({executionId:c.string(),timestamp:c.number(),durationMs:c.number()}),error:d.extend({executionId:c.string(),timestamp:c.number(),error:fe}),registryChanged:c.object({revision:c.number().int().positive(),reason:c.enum([`toolset-registered`,`toolset-unregistered`,`plugin-loaded`,`plugin-unloaded`]),toolsetName:c.string()})},ve=c.object({name:c.string(),permission_policy:c.enum([`always_allow`,`always_ask`,`always_deny`])}),ye=c.array(ve).superRefine((e,t)=>{let n=new Set;e.forEach((e,r)=>{if(n.has(e.name)){t.addIssue({code:c.ZodIssueCode.custom,path:[r,`name`],message:`Duplicate MCP tool policy name "${e.name}"`});return}n.add(e.name)})}),be=c.object({type:c.literal(`stdio`),command:c.string(),args:c.array(c.string()).optional(),env:c.record(c.string(),c.string()).optional(),alwaysLoad:c.boolean().optional()}),p=c.object({url:c.string().url(),headers:c.record(c.string(),c.string()).optional(),tools:ye.optional(),alwaysLoad:c.boolean().optional()}),xe=p.extend({type:c.literal(`sse`)}),Se=p.extend({type:c.literal(`http`)}),m=c.discriminatedUnion(`type`,[be,xe,Se]),h=c.enum([`direct`,`discovery`,`hidden`]),g=h.exclude([`hidden`]),_=c.record(c.string(),h).optional(),v=c.string().max(256).refine(e=>(e.match(/\*/g)?.length??0)<=10,{message:`Pattern must contain at most 10 wildcard characters`}),Ce=c.object({transport:m,exposureMode:g.optional(),toolExposure:_}),we=c.object({enabled:c.boolean(),maxAttempts:c.number().int().positive(),baseDelayMs:c.number().int().positive(),maxDelayMs:c.number().int().positive()}).refine(e=>e.maxDelayMs>=e.baseDelayMs,{message:`maxDelayMs must be >= baseDelayMs`,path:[`maxDelayMs`]});c.object({servers:c.record(c.string(),Ce),hideTools:c.array(v).optional(),exposeTools:c.array(v).optional(),defaultExposureMode:g.optional(),autoReconnect:we.optional()}),c.object({servers:c.array(c.string()).optional(),exposeTools:c.array(v).optional(),hideTools:c.array(v).optional(),serverOverrides:c.record(c.string(),c.object({exposureMode:g.optional(),toolExposure:_})).optional()});const y=c.object({directTools:c.array(v).optional(),discoveryTools:c.array(v).optional(),toolExposure:_}),Te=c.object({name:c.string(),transport:m,exposureMode:g}),b=c.object({fullName:c.string(),originalName:c.string(),serverName:c.string(),description:c.string().optional(),inputSchema:c.record(c.string(),c.unknown()),exposureMode:h,enabled:c.boolean(),enabledBy:c.enum([`discovery`,`toolset`]).optional(),enabledAt:c.number().int().nonnegative().optional(),exposed:c.boolean()}),x=c.object({sessionId:c.string(),projectId:c.string().nullable(),profileId:c.string().nullable(),servers:c.array(Te),directTools:c.array(b),discoverableTools:c.array(b)}),S=x.omit({projectId:!0,profileId:!0}),Ee=c.object({agentId:c.string(),adapterId:c.string(),adapterName:c.string(),adapterSessionId:c.string(),sessionId:c.string()}),De={"server.connected":c.object({serverName:c.string(),toolCount:c.number().int().nonnegative()}),"server.disconnected":c.object({serverName:c.string(),reason:c.string()}),"server.reconnecting":c.object({serverName:c.string(),attempt:c.number().int().positive()}),"server.error":c.object({serverName:c.string(),error:c.string()}),"tools.updated":c.object({added:c.array(c.string()),removed:c.array(c.string())}),"tools.enabled":c.object({tools:c.array(c.string()),source:c.enum([`discovery`,`toolset`])}),"session.resolve":{request:c.object({sessionId:c.string(),profileId:c.string().nullable(),projectId:c.string().nullable(),profileMcpConfig:y.optional()}),response:x},"session.register":{request:Ee.extend({contextOverrides:f,pinned:c.boolean().optional()}),response:c.object({port:c.number().int().positive()})},"session.unregister":{request:c.object({adapterSessionId:c.string()}),response:c.object({})}},C=c.looseObject({kind:c.string(),providerConfigId:c.string().optional(),model:c.string().optional(),reasoningEffort:o.optional(),cwd:c.string().optional(),systemPrompt:t.optional(),allowedTools:c.array(c.string()).optional(),disallowedTools:c.array(c.string()).optional(),env:c.record(c.string(),c.string()).optional(),mcpSessionContext:S.optional(),allowedDirectories:c.array(c.string()).optional()}),w=C.extend({kind:c.literal(`adapter`),adapterName:c.string().trim().min(1).optional(),adapterId:c.string().trim().min(1).optional()}).refine(e=>!!e.adapterName||!!e.adapterId,{message:`AdapterSelection requires at least one of 'adapterName' or 'adapterId'`}),T=C,E=c.object({providerConfigId:c.string(),definitionId:c.string(),endpointOverrides:re.optional(),credentialRefs:c.record(c.string(),ne),credentialEnvVars:c.record(c.string(),c.string()).optional(),ambientCredentialEnvVars:c.array(c.string()).optional()}),Oe={request:c.object({adapterName:c.string().optional(),adapterId:c.string().optional()}).refine(e=>e.adapterName||e.adapterId,{message:`Either adapterName or adapterId must be provided`}),response:c.object({capabilities:c.array(c.string()),nativeTools:c.array(c.string())})},D=c.enum([`lead`,`member`]),O=c.enum([`fork`,`branch`,`subagent`,`compress`,`rewrite`,`coordinator`,`aside`]),ke=c.object({sessionId:c.string(),title:c.string().nullable(),forkPointMessageId:c.string().nullable(),branchKind:O.nullable(),messageCount:c.number(),hasChildren:c.boolean(),spawningToolCallId:c.string().optional()}),Ae=c.object({fromMessageId:c.string(),toMessageId:c.string(),policy:c.enum([`verbatim`,`summarize`,`exclude`]),stripReasoning:c.boolean().optional(),stripToolOutputs:c.boolean().optional(),overrides:c.record(c.string(),c.literal(`exclude`)).optional(),summaryText:c.string().optional()}),k=c.object({removedMessageIds:c.array(c.string()).optional(),appliedPipeline:c.array(c.object({actionId:c.string(),options:c.record(c.string(),c.unknown()).optional()})).optional(),segments:c.array(Ae).optional()}),je=c.object({parentSessionId:c.string(),childSessionId:c.string(),summary:c.string().optional(),source:c.enum([`extension`,`user`,`system`]).optional(),extensionId:c.string().optional()}),Me=c.object({success:c.boolean(),handoff:c.string().optional()}),Ne=c.object({parentSessionId:c.string(),childSessionId:c.string(),source:c.enum([`extension`,`user`,`system`]).optional(),extensionId:c.string().optional()}),Pe=c.object({success:c.boolean()}),Fe=c.object({sessionId:c.string()}),Ie=c.object({children:c.array(ke)}),Le=c.object({parentSessionId:c.string(),childSessionId:c.string(),reason:c.string()}),Re=c.object({parentSessionId:c.string(),childSessionId:c.string(),forkPoint:c.string().optional()}),ze=c.object({parentSessionId:c.string(),childSessionId:c.string()}),Be=c.object({parentSessionId:c.string(),childSessionId:c.string(),handoff:c.string()}),Ve=c.object({sessionId:c.string(),parentSessionId:c.string().optional()}),He=c.object({parentSessionId:c.string(),childSessionId:c.string(),result:c.unknown()}),Ue=c.object({sessionId:c.string(),reason:c.string(),source:c.enum([`extension`,`user`,`system`]).optional(),extensionId:c.string().optional()}),We=c.object({sessionId:c.string(),pipeline:c.array(c.object({actionId:c.string(),options:c.record(c.string(),c.unknown()).optional()}))}),Ge=c.object({eventId:c.string(),contextJson:c.record(c.string(),c.unknown()),tokensBefore:c.number(),tokensAfter:c.number().optional()}),Ke=c.object({sessionId:c.string(),childSessionId:c.string(),parentSessionId:c.string(),kind:O,forkPointMessageId:c.string().optional(),transforms:k.optional()}),qe=c.object({sessionId:c.string(),childSessionId:c.string(),parentSessionId:c.string(),resultJson:c.string().optional(),resultMessageId:c.string().optional()}),Je=c.object({sessionId:c.string(),summaryJson:c.string(),tokensBefore:c.number().optional(),tokensAfter:c.number().optional(),compressedMessageIds:c.array(c.string()).optional()}),Ye=c.object({sessionId:c.string(),parentSessionId:c.string().nullable(),branchKind:O.nullable(),createdAt:c.number(),originWindowId:c.string().optional()}),Xe=c.object({sessionId:c.string(),changedProperties:c.array(c.string())}),Ze={merge:{request:je,response:Me},abandon:{request:Ne,response:Pe},getChildren:{request:Fe,response:Ie},forking:Le,forked:Re,merging:ze,merged:Be,abandoned:Ve,childCompleted:He,compressionRequested:Ue,"branch.created":Ke,"branch.merged":qe,squash:Je,created:Ye,updated:Xe,compress:{request:We,response:Ge}},Qe=C.safeExtend({kind:c.literal(`canonical-model`),model:c.string().trim().min(1)}),A=c.object({messageHistory:c.array(e).optional(),hasNewTransforms:c.boolean().optional(),hasCompression:c.boolean().optional(),extractedContext:c.unknown().optional(),isFirstTurn:c.boolean().optional(),hasConnectorSwap:c.boolean().optional(),turnContext:c.record(c.string(),n).optional()}),$e=r,j=c.enum([`user`,`assistant`]),M=c.enum([`voice`,`text`,`compact`]),N=c.object({messageId:c.string(),turnId:c.string().nullable(),sessionId:c.string(),role:j,contentText:c.string(),blocks:c.array($e),agentId:c.string().optional(),adapterSessionId:c.string().optional(),adapterMessageId:c.string().optional(),timestamp:c.number(),editOf:c.string().optional(),origin:M.optional()}),P=c.enum([`active`,`completed`,`error`]),F=c.object({inputTokens:c.number(),outputTokens:c.number(),cost:c.number().optional()}),I=c.object({total:F,byAgent:c.record(c.string(),F).optional()}),L=c.object({turnId:c.string(),sessionId:c.string(),turnNumber:c.number().int().min(1),startedAt:c.number(),completedAt:c.number().optional(),status:P,error:c.string().optional(),usage:I.optional()}),R=c.enum([`sent`,`acknowledged`,`completed`]),et=c.object({messageId:c.string(),agentId:c.string(),status:R,timestamp:c.number(),error:c.string().optional()}),z=c.object({source:c.enum([`user`,`extension`,`system`]),sourceId:c.string().optional()}),B=c.object({sessionId:c.string(),turnId:c.string(),turnNumber:c.number().int().min(1)}),V=B.extend({messageId:c.string()}),tt=C.safeExtend({kind:c.string().regex(/^(?!(?:adapter|canonical-model)$).+$/)}),nt=c.union([w,Qe,tt]),H={sendMessage:{request:c.object({sessionId:c.string(),message:i,agent:nt.optional(),agentIds:c.union([c.array(c.string()),c.literal(`all`)]).optional(),deliveryMode:c.enum([`enqueue`]).optional(),turnId:c.string().optional(),sessionContext:A.optional(),responseSchema:c.record(c.string(),c.unknown()).optional(),source:c.enum([`extension`,`user`,`system`]).optional(),extensionId:c.string().optional(),originWindowId:c.string().optional(),skipConnectorSwapWarning:c.boolean().optional(),origin:M.optional()}),response:c.object({messageId:c.string(),turnId:c.string(),sessionId:c.string()})},"agent.attach":{request:c.object({sessionId:c.string(),agent:T,initialMessage:i.optional(),role:c.enum([`lead`,`member`]).optional()}),response:c.object({agentId:c.string(),adapterSessionId:c.string(),role:c.enum([`lead`,`member`]),messageId:c.string().optional(),turnId:c.string().optional()})},"turn.started":B.extend({messageId:c.string(),agentIds:c.array(c.string()),initiator:z.optional()}),"turn.completed":B.extend({success:c.boolean(),error:c.string().optional(),initiator:z.optional()}),"user_message.sent":V.extend({content:i,agentIds:c.array(c.string()),source:c.enum([`extension`,`user`,`system`]).optional(),origin:M.optional()}),"user_message.acknowledged":V.extend({agentId:c.string()}),"user_message.completed":V.extend({agentId:c.string(),outcome:ee,supersededBy:c.string().optional(),mergedInto:c.string().optional(),error:c.string().optional()}),fork:{request:c.object({sourceSessionId:c.string(),fromMessageId:c.string().optional(),name:c.string().optional(),branchKind:c.enum([`fork`,`branch`,`aside`]).optional(),transforms:k.optional(),targetWorkingDirectory:c.string().optional(),existingSessionId:c.string().optional()}),response:c.object({sessionId:c.string()})},usage:{request:c.object({sessionId:c.string(),totalInputTokens:c.number(),totalOutputTokens:c.number(),totalTokens:c.number(),totalCalls:c.number(),adapterCount:c.number()}),response:c.object({acknowledged:c.literal(!0)})}},U=c.enum([`auto`,`manual`,`off`]),W=c.enum([`idle`,`active`,`dead`,`disposed`]),G=c.object({agentId:c.string(),adapterId:c.string(),adapterName:c.string(),sessionId:c.string(),adapterSessionId:c.string().optional(),model:c.string().optional(),cwd:c.string().optional(),providerConfigId:c.string().optional(),personaId:c.string().optional(),profileId:c.string().optional(),harnessId:c.string().optional(),clientId:c.string().optional(),compressionMode:U.optional(),role:D,status:W,createdAt:c.number(),lastActivityAt:c.number()}),K=c.object({sessionId:c.string(),createdAt:c.number(),lastActivityAt:c.number(),agents:c.array(G),status:c.enum([`active`,`closed`,`archived`,`discovered`]),leadAgentId:c.string().optional(),parentSessionId:c.string().optional(),rootSessionId:c.string().optional(),forkPointMessageId:c.string().optional(),branchKind:O.optional(),adapterName:c.string().optional(),adapterSessionId:c.string().optional(),adapterId:c.string().optional(),clientId:c.string().optional(),clientAccountId:c.string().optional(),lastClientIdentityObservation:s.optional(),isOrchestrated:c.boolean().optional(),title:c.string().optional(),summary:c.string().optional(),summaryUpdatedAt:c.number().optional(),isImported:c.boolean().optional(),forkTransforms:k.optional(),targetWorkingDirectory:c.string().optional(),executionTargetId:c.string().optional(),spawningToolCallId:c.string().optional(),approvalPolicyOverride:ie.nullable().optional()}),rt=c.object({messageCount:c.number(),firstUserMessage:c.string().nullable()}),q=K.extend({preview:rt.optional()}),it={list:{request:c.object({status:c.enum([`active`,`closed`,`archived`,`discovered`,`all`]).optional(),limit:c.number().int().min(1).optional(),offset:c.number().int().min(0).optional(),includePreview:c.boolean().optional(),executionTargetId:c.string().optional()}),response:c.object({sessions:c.array(q),total:c.number()})},search:{request:c.object({query:c.string(),limit:c.number().int().min(1).optional(),status:c.enum([`active`,`closed`,`archived`,`discovered`,`all`]).optional(),isImported:c.boolean().optional()}),response:c.object({sessions:c.array(q),total:c.number()})},get:{request:c.object({sessionId:c.string()}),response:c.object({session:K.nullable()})},create:{request:c.object({sessionId:c.string().optional(),parentSessionId:c.string().optional(),forkPointMessageId:c.string().optional(),branchKind:O.optional(),forkTransforms:k.optional(),title:c.string().optional(),targetWorkingDirectory:c.string().optional(),executionTargetId:c.string().optional(),spawningToolCallId:c.string().optional(),originWindowId:c.string().optional()}).superRefine((e,t)=>{e.spawningToolCallId&&e.branchKind!==`subagent`&&t.addIssue({code:c.ZodIssueCode.custom,path:[`spawningToolCallId`],message:`spawningToolCallId is only valid for subagent sessions`})}),response:c.object({sessionId:c.string()})},close:{request:c.object({sessionId:c.string()}),response:c.object({success:c.boolean()})},resume:{request:c.object({sessionId:c.string()}),response:c.object({success:c.boolean()})},archive:{request:c.object({sessionId:c.string()}),response:c.object({success:c.boolean()})},purge:{request:c.object({sessionId:c.string()}),response:c.object({success:c.boolean(),eventsDeleted:c.number().optional(),error:c.string().optional()})},update:{request:c.object({sessionId:c.string(),executionTargetId:c.string().nullable().optional(),approvalPolicyOverride:ie.nullable().optional(),title:c.string().optional()}),response:c.object({success:c.boolean()})},getByAdapterSessionId:{request:c.object({adapterSessionId:c.string()}),response:c.object({session:K.nullable()})},getStatusCounts:{request:c.object({}),response:c.object({all:c.number(),active:c.number(),closed:c.number(),archived:c.number(),discovered:c.number()})}},J=c.object({sessionId:c.string(),eventId:c.string(),timestamp:c.number()}),at=c.discriminatedUnion(`type`,[J.extend({type:c.literal(`agent.added`),payload:c.object({sessionId:c.string(),adapterSessionId:c.string(),agentId:c.string(),adapterId:c.string(),adapterName:c.string(),role:c.enum([`lead`,`member`]).optional(),model:c.string().optional(),cwd:c.string().optional()})}),J.extend({type:c.literal(`user_message.sent`),payload:H[`user_message.sent`]}),J.extend({type:c.literal(`user_message.acknowledged`),payload:H[`user_message.acknowledged`]}),J.extend({type:c.literal(`user_message.completed`),payload:H[`user_message.completed`]}),J.extend({type:c.literal(`turn.started`),payload:H[`turn.started`]}),J.extend({type:c.literal(`turn.completed`),payload:H[`turn.completed`]}),J.extend({type:c.literal(`message`),payload:c.object({messageId:c.string(),turnId:c.string().nullable(),role:c.enum([`user`,`assistant`])})}),J.extend({type:c.literal(`branch.created`),payload:c.object({childSessionId:c.string(),parentSessionId:c.string(),kind:O,forkPointMessageId:c.string().optional()})}),J.extend({type:c.literal(`branch.merged`),payload:c.object({childSessionId:c.string(),parentSessionId:c.string(),resultJson:c.string().optional(),resultMessageId:c.string().optional()})}),J.extend({type:c.literal(`squash`),payload:c.object({summaryJson:c.string(),tokensBefore:c.number().optional(),tokensAfter:c.number().optional(),compressedMessageIds:c.array(c.string()).optional()})})]),ot=[`message`,`agent.added`,`turn.started`,`turn.completed`,`user_message.sent`,`user_message.acknowledged`,`user_message.completed`,`branch.created`,`branch.merged`,`squash`],st=ot,ct=J.extend({type:c.string().refine(e=>!ot.includes(e),{message:`Plugin session event type must not shadow a core event type.`}),payload:c.record(c.string(),c.unknown())}),Y=c.union([at,ct]),lt=c.string(),ut=c.object({sessionId:c.string().min(1),clientId:c.string().min(1),previousClientAccountId:c.string().min(1).nullable(),clientAccountId:c.string().min(1),source:c.string().min(1),observedAt:c.number().int().finite().nonnegative(),lastClientIdentityObservation:s}),dt={"agent.added":c.object({sessionId:c.string(),adapterSessionId:c.string(),agentId:c.string(),adapterId:c.string(),adapterName:c.string(),role:D.optional(),model:c.string().optional(),cwd:c.string().optional()}),"agent.removed":c.object({sessionId:c.string(),agentId:c.string()}),closed:c.object({sessionId:c.string(),reason:c.string().optional()}),resumed:c.object({sessionId:c.string()}),archived:c.object({sessionId:c.string()}),purged:c.object({sessionId:c.string()}),compressed:c.object({sessionId:c.string(),eventId:c.string()}),"clientAccount.changed":ut,"connectorSwap.editRequested":c.object({sessionId:c.string(),agentId:c.string(),previousCwd:c.string().optional(),newCwd:c.string().optional(),previousModel:c.string().optional(),newModel:c.string().optional()}),getContextWindowState:{request:c.object({sessionId:c.string()}),response:c.object({state:c.object({currentTokens:c.number(),maxTokens:c.number(),percentage:c.number(),level:c.enum([`ok`,`warn`,`critical`]),lastUpdatedAt:c.number()}).nullable()})},event:Y},X=c.object({includeEvents:c.boolean().default(!1),includeToolOutputs:c.boolean().default(!1),includeAncestors:c.boolean().default(!0),includeChildren:c.boolean().default(!1)}),ft=`1.0`,Z=c.object({version:c.literal(`1.0`),exportedAt:c.number(),options:X,sessions:c.array(K),agents:c.array(G),messages:c.array(N),turns:c.array(L),events:c.array(Y).optional()});function pt(e){return Z.parse(e)}function mt(e){let t=Z.safeParse(e);return t.success?{success:!0,data:t.data}:{success:!1,error:t.error}}const ht={"snapshot.export":{request:c.object({sessionId:c.string(),options:X.optional()}),response:c.object({snapshot:Z})},"snapshot.import":{request:c.object({snapshot:Z,onConflict:c.enum([`fail`,`skip`,`overwrite`]).default(`fail`)}),response:c.object({imported:c.array(c.string()),skipped:c.array(c.string()),errors:c.array(c.object({sessionId:c.string(),error:c.string()}))})},"snapshot.validate":{request:c.object({snapshot:c.unknown()}),response:c.object({valid:c.boolean(),errors:c.array(c.string())})}},gt={resolveAgentConfig:{request:c.object({selection:T,projectId:c.string().optional()}),response:c.object({adapterName:c.string(),model:c.string().optional(),providerConfigId:c.string().optional(),reasoningEffort:o.optional(),supportedReasoningLevels:te.optional(),systemPrompt:t.optional(),allowedTools:c.array(c.string()).optional(),disallowedTools:c.array(c.string()).optional(),allowedDirectories:c.array(c.string()).optional()})}},_t={resolveSystemPrompt:{request:c.object({sessionId:c.string(),personaId:c.string().optional(),profileId:c.string().optional()}),response:c.object({systemPrompt:c.string(),personaName:c.string().optional(),profileName:c.string().optional()})}},vt={enrichContext:{request:c.object({sessionId:c.string()}),response:c.record(c.string(),c.unknown())}},yt={...it,...dt,...ht,...Ze,...H,...gt,..._t,...vt},Q=c.object({adapterId:c.string(),harnessId:c.string().optional(),clientId:c.string().optional(),clientProfileName:ae.optional(),initialMessage:i.optional(),model:c.string().optional(),reasoningEffort:o.optional(),env:c.record(c.string(),c.string()).optional(),role:D,sessionContext:A.optional(),mcpSessionContext:c.union([x,S]).optional(),providerContext:E.optional(),ephemeral:c.boolean().optional()}).merge(se),bt={request:c.union([Q.extend({mode:c.literal(`fork`),sessionId:c.string(),sourceSessionId:c.string()}),Q.extend({mode:c.literal(`resume`),sessionId:c.string(),adapterSessionId:c.string()}),Q.extend({mode:c.literal(`create`).optional(),sessionId:c.string().optional()})]).superRefine((e,t)=>{let n=e.mode??`create`;e.ephemeral&&n!==`create`&&t.addIssue({code:c.ZodIssueCode.custom,path:[`ephemeral`],message:`ephemeral is only supported for create mode`}),e.ephemeral&&e.initialMessage===void 0&&t.addIssue({code:c.ZodIssueCode.custom,path:[`initialMessage`],message:`ephemeral startAgent requires initialMessage`})}),response:c.discriminatedUnion(`success`,[c.object({success:c.literal(!0),agentId:c.string(),adapterId:c.string(),adapterSessionId:c.string(),sessionId:c.string(),messageId:c.string().optional()}),c.object({success:c.literal(!1),message:c.string()})])},xt={request:c.object({adapterId:c.string(),prompt:c.string(),model:c.string().optional(),systemPrompt:c.string().optional(),providerContext:E.optional()}),response:c.object({text:c.string(),usage:c.object({inputTokens:c.number(),outputTokens:c.number()}).optional()})},St={request:c.object({adapterId:c.string()}),response:c.object({agents:c.array(c.object({agentId:c.string(),sessionId:c.string(),adapterSessionId:c.string()}))})},Ct={request:c.object({adapterId:c.string(),agentId:c.string()}),response:c.object({agent:c.object({agentId:c.string(),sessionId:c.string(),adapterSessionId:c.string()}).nullable()})},wt={request:c.object({adapterId:c.string(),agentId:c.string()}),response:c.object({success:c.boolean()})},Tt={request:c.object({adapterId:c.string(),agentId:c.string(),cwd:c.string().optional(),model:c.string().optional()}),response:c.object({})},Et={request:c.object({adapterName:c.string()}),response:c.object({found:c.boolean(),adapterName:c.string(),jsonSchema:c.record(c.string(),c.unknown()).nullable()})},Dt=l.extend({agentId:c.string(),sessionId:c.string(),adapterSessionId:c.string().optional()}),Ot=l.extend({adapterSessionId:c.string(),sessionId:c.string(),model:c.string()}),kt=l.extend({sessionId:c.string(),adapterSessionId:c.string(),totalInputTokens:c.number(),totalOutputTokens:c.number(),totalCalls:c.number()}),At=l.extend({agentId:c.string(),sessionId:c.string(),adapterSessionId:c.string(),reason:c.string().optional()}),jt=l.extend({message:c.string(),timestamp:c.number(),level:c.enum([`debug`,`info`,`warn`,`error`]).optional()}),Mt=l.extend({error:c.string(),sessionId:c.string().optional(),errorCategory:a.optional()}),Nt=l.extend({capabilities:c.array(c.string()),nativeTools:c.array(c.string()).optional()}),Pt=l.extend({provider:c.string(),quotaType:c.string(),limit:c.number(),used:c.number(),overage:c.number(),resetDate:c.string()}),$=c.object({agentId:c.string(),adapterId:c.string(),adapterName:c.string(),sessionId:c.string().optional(),adapterSessionId:c.string(),messageId:c.string().optional(),turnId:c.string().optional(),clientId:c.string().optional(),providerConfigId:c.string().optional(),occurredAt:c.number().optional()}),Ft=c.object({model:c.string().nullable(),cwd:c.string().nullable()}),It=$.merge(Ft),Lt=l.merge(Ft).extend({adapterSessionId:c.string(),title:c.string().optional(),logFilePath:c.string().nullable().optional(),startedAt:c.number().finite().optional()}).and(oe),Rt=l.extend({adapterId:c.string().optional(),adapterSessionId:c.string(),sessionId:c.string(),replay:c.boolean().optional()}),zt=c.enum([`discovered`,`imported`,`live`,`tracking`]),Bt=c.object({adapterSessionId:c.string(),status:zt});export{k as $,pt as A,U as B,vt as C,Z as D,ft as E,K as F,M as G,et as H,rt as I,L as J,j as K,q as L,Y as M,st as N,X as O,lt as P,A as Q,W as R,yt as S,gt as T,R as U,z as V,$e as W,I as X,P as Y,F as Z,wt as _,v as _t,It as a,O as at,xt as b,le as bt,Nt as c,w as ct,At as d,we as dt,Ae as et,kt as f,h as ft,Tt as g,De as gt,Et as h,S as ht,Lt as i,D as it,ut as j,mt as k,Mt as l,C as lt,Dt as m,y as mt,zt as n,Xe as nt,$ as o,Oe as ot,Ot as p,g as pt,N as q,Rt as r,ke as rt,Pt as s,E as st,Bt as t,Ye as tt,jt as u,T as ut,Ct as v,m as vt,_t as w,bt as x,se as xt,St as y,_e as yt,G as z};

package/dist/session/connector-swap-cancelled-error.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Machine-readable error code for user-cancelled connector swap operations.
+ */
+export declare const CONNECTOR_SWAP_CANCELLED_CODE = "CONNECTOR_SWAP_CANCELLED";
+/**
+ * Raised when the user cancels connector swap from the warning dialog.
+ */
+export declare class ConnectorSwapCancelledError extends Error {
+    readonly code = "CONNECTOR_SWAP_CANCELLED";
+    constructor();
+}
+/**
+ * Type guard for connector swap cancellation errors.
+ * @param error - Unknown error value
+ * @returns True when error matches connector swap cancellation contract
+ */
+export declare function isConnectorSwapCancelledError(error: unknown): error is ConnectorSwapCancelledError;
+//# sourceMappingURL=connector-swap-cancelled-error.d.ts.map

package/dist/session/connector-swap-cancelled-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-swap-cancelled-error.d.ts","sourceRoot":"","sources":["../../src/session/connector-swap-cancelled-error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,SAAgB,IAAI,8BAAiC;IAErD,cAGC;CACF;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,2BAA2B,CAKlG"}

package/dist/session/connector-swap-warning.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared connector-swap warning policy values used across orchestration and adapters.
+ */
+export declare const UI_WARNINGS_CATEGORY = "ui-warnings";
+/**
+ * Preference key for suppressing the connector-swap warning dialog globally.
+ */
+export declare const CONNECTOR_SWAP_WARNING_SUPPRESSED_KEY = "connector-swap-warning-suppressed";
+/**
+ * Timeout for interactive warning dialogs (24 hours).
+ */
+export declare const INTERACTIVE_DIALOG_TIMEOUT_MS: number;
+/**
+ * Canonical option IDs for connector-swap warning dialogs.
+ */
+export declare const CONNECTOR_SWAP_WARNING_OPTION_IDS: {
+    readonly cancel: "cancel";
+    readonly edit: "edit";
+    readonly continue: "continue";
+};
+/**
+ * Connector-swap warning option identifier.
+ */
+export type ConnectorSwapWarningOptionId = (typeof CONNECTOR_SWAP_WARNING_OPTION_IDS)[keyof typeof CONNECTOR_SWAP_WARNING_OPTION_IDS];
+//# sourceMappingURL=connector-swap-warning.d.ts.map

package/dist/session/connector-swap-warning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-swap-warning.d.ts","sourceRoot":"","sources":["../../src/session/connector-swap-warning.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,qCAAqC,sCAAsC,CAAC;AAEzF;;GAEG;AACH,eAAO,MAAM,6BAA6B,QAAsB,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;CAIpC,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,4BAA4B,GACtC,CAAC,OAAO,iCAAiC,CAAC,CAAC,MAAM,OAAO,iCAAiC,CAAC,CAAC"}