@makaio/contracts 1.0.0-dev-1779051654000

package/dist/canonical-model/parser.d.ts

@@ -0,0 +1,47 @@
+import type { CanonicalModelParseError, CanonicalModelParseResult } from './types.js';
+/**
+ * Matches a valid routing segment: starts with `[a-z0-9]`, followed by
+ * `[a-z0-9._-]*`.
+ *
+ * Exported so other schema layers can share the same routing constraint.
+ */
+export declare const SEGMENT_RE: RegExp;
+/**
+ * Matches a valid virtual model name: starts with `[a-z0-9]`, followed by
+ * `[a-z0-9_-]*`.
+ *
+ * Exported so host-owned virtual-model schemas can enforce the same naming
+ * rule at write time.
+ */
+export declare const VIRTUAL_NAME_RE: RegExp;
+/**
+ * Parse a canonical model string into a structured reference.
+ *
+ * The grammar is:
+ * ```
+ * canonical          := "~" virtual_model_name
+ *                     | routing "::" model_name
+ *                     | model_name
+ *
+ * routing            := segment
+ *                     | segment "/" segment
+ *
+ * segment            := [a-z0-9][a-z0-9._-]*
+ * model_name         := <any non-empty string>
+ * virtual_model_name := [a-z0-9][a-z0-9_-]*
+ * ```
+ *
+ * Routing segments are lowercased during parsing because they are
+ * case-insensitive for matching purposes. Model names are passed through
+ * verbatim as they are provider-defined and case-sensitive.
+ * @param input - The canonical model string to parse
+ * @returns A parsed reference or a parse error
+ */
+export declare function parseCanonicalModel(input: string): CanonicalModelParseResult;
+/**
+ * Type guard for distinguishing parse errors from successful parse results.
+ * @param result - The parse result to check
+ * @returns `true` when the result is a parse error
+ */
+export declare function isCanonicalModelParseError(result: CanonicalModelParseResult): result is CanonicalModelParseError;
+//# sourceMappingURL=parser.d.ts.map

package/dist/canonical-model/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/canonical-model/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAgC,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEpH;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAA2B,CAAC;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,QAA0B,CAAC;AAavD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB,CA8E5E;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,yBAAyB,GAAG,MAAM,IAAI,wBAAwB,CAEhH"}

package/dist/canonical-model/schemas.d.ts

@@ -0,0 +1,244 @@
+import { z } from 'zod';
+/**
+ * Resolved adapter selection produced by framework canonical-model resolution.
+ *
+ * Canonical-model resolution is intentionally limited to adapter/provider/model
+ * routing. Host-only virtual-model expansion happens at the higher-level
+ * agent-resolution seam.
+ */
+export declare const CanonicalModelResolvedSelectionSchema: z.ZodObject<{
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        "extra-high": "extra-high";
+        high: "high";
+        low: "low";
+        medium: "medium";
+        none: "none";
+    }>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        mode: z.ZodLiteral<"append">;
+        content: z.ZodString;
+    }, z.core.$strip>]>>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mcpSessionContext: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodString;
+        servers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"stdio">;
+                command: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    permission_policy: z.ZodEnum<{
+                        always_allow: "always_allow";
+                        always_ask: "always_ask";
+                        always_deny: "always_deny";
+                    }>;
+                }, z.core.$strip>>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                type: z.ZodLiteral<"sse">;
+            }, z.core.$strip>, z.ZodObject<{
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    permission_policy: z.ZodEnum<{
+                        always_allow: "always_allow";
+                        always_ask: "always_ask";
+                        always_deny: "always_deny";
+                    }>;
+                }, z.core.$strip>>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                type: z.ZodLiteral<"http">;
+            }, z.core.$strip>], "type">;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+            }>;
+        }, z.core.$strip>>;
+        directTools: z.ZodArray<z.ZodObject<{
+            fullName: z.ZodString;
+            originalName: z.ZodString;
+            serverName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+                hidden: "hidden";
+            }>;
+            enabled: z.ZodBoolean;
+            enabledBy: z.ZodOptional<z.ZodEnum<{
+                discovery: "discovery";
+                toolset: "toolset";
+            }>>;
+            enabledAt: z.ZodOptional<z.ZodNumber>;
+            exposed: z.ZodBoolean;
+        }, z.core.$strip>>;
+        discoverableTools: z.ZodArray<z.ZodObject<{
+            fullName: z.ZodString;
+            originalName: z.ZodString;
+            serverName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+                hidden: "hidden";
+            }>;
+            enabled: z.ZodBoolean;
+            enabledBy: z.ZodOptional<z.ZodEnum<{
+                discovery: "discovery";
+                toolset: "toolset";
+            }>>;
+            enabledAt: z.ZodOptional<z.ZodNumber>;
+            exposed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    adapterId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"adapter">;
+    adapterName: z.ZodString;
+    providerConfigId: z.ZodString;
+    model: z.ZodString;
+}, z.core.$loose>;
+export type CanonicalModelResolvedSelection = z.infer<typeof CanonicalModelResolvedSelectionSchema>;
+/**
+ * Bus schemas for framework canonical-model resolution.
+ *
+ * Each key becomes a subject identifier as `canonicalModel.<key>`.
+ */
+export declare const CanonicalModelSchemas: {
+    resolve: {
+        request: z.ZodObject<{
+            parsed: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bare">;
+                model: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"qualified">;
+                segment1: z.ZodString;
+                segment2: z.ZodOptional<z.ZodString>;
+                model: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            context: z.ZodOptional<z.ZodObject<{
+                sessionId: z.ZodOptional<z.ZodString>;
+                projectId: z.ZodOptional<z.ZodString>;
+                promptText: z.ZodOptional<z.ZodString>;
+                sessionContext: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                "extra-high": "extra-high";
+                high: "high";
+                low: "low";
+                medium: "medium";
+                none: "none";
+            }>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                mode: z.ZodLiteral<"append">;
+                content: z.ZodString;
+            }, z.core.$strip>]>>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            mcpSessionContext: z.ZodOptional<z.ZodObject<{
+                sessionId: z.ZodString;
+                servers: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"stdio">;
+                        command: z.ZodString;
+                        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        url: z.ZodString;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            permission_policy: z.ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, z.core.$strip>>>;
+                        alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                        type: z.ZodLiteral<"sse">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        url: z.ZodString;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            permission_policy: z.ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, z.core.$strip>>>;
+                        alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                        type: z.ZodLiteral<"http">;
+                    }, z.core.$strip>], "type">;
+                    exposureMode: z.ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                    }>;
+                }, z.core.$strip>>;
+                directTools: z.ZodArray<z.ZodObject<{
+                    fullName: z.ZodString;
+                    originalName: z.ZodString;
+                    serverName: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    exposureMode: z.ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: z.ZodBoolean;
+                    enabledBy: z.ZodOptional<z.ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: z.ZodOptional<z.ZodNumber>;
+                    exposed: z.ZodBoolean;
+                }, z.core.$strip>>;
+                discoverableTools: z.ZodArray<z.ZodObject<{
+                    fullName: z.ZodString;
+                    originalName: z.ZodString;
+                    serverName: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    exposureMode: z.ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: z.ZodBoolean;
+                    enabledBy: z.ZodOptional<z.ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: z.ZodOptional<z.ZodNumber>;
+                    exposed: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            adapterId: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"adapter">;
+            adapterName: z.ZodString;
+            providerConfigId: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$loose>;
+    };
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/canonical-model/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/canonical-model/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;GAMG;AAIH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUV,CAAC"}

package/dist/canonical-model/selection.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+/**
+ * Agent selection for `kind: 'canonical-model'`.
+ *
+ * The `model` field carries the canonical model reference string verbatim.
+ * Resolution happens immediately at the `AgentResolutionSubjects.resolve`
+ * chokepoint, so this kind never persists into runtime spawn paths.
+ */
+export declare const CanonicalModelSelectionSchema: z.ZodObject<{
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        "extra-high": "extra-high";
+        high: "high";
+        low: "low";
+        medium: "medium";
+        none: "none";
+    }>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        mode: z.ZodLiteral<"append">;
+        content: z.ZodString;
+    }, z.core.$strip>]>>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mcpSessionContext: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodString;
+        servers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"stdio">;
+                command: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    permission_policy: z.ZodEnum<{
+                        always_allow: "always_allow";
+                        always_ask: "always_ask";
+                        always_deny: "always_deny";
+                    }>;
+                }, z.core.$strip>>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                type: z.ZodLiteral<"sse">;
+            }, z.core.$strip>, z.ZodObject<{
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    permission_policy: z.ZodEnum<{
+                        always_allow: "always_allow";
+                        always_ask: "always_ask";
+                        always_deny: "always_deny";
+                    }>;
+                }, z.core.$strip>>>;
+                alwaysLoad: z.ZodOptional<z.ZodBoolean>;
+                type: z.ZodLiteral<"http">;
+            }, z.core.$strip>], "type">;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+            }>;
+        }, z.core.$strip>>;
+        directTools: z.ZodArray<z.ZodObject<{
+            fullName: z.ZodString;
+            originalName: z.ZodString;
+            serverName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+                hidden: "hidden";
+            }>;
+            enabled: z.ZodBoolean;
+            enabledBy: z.ZodOptional<z.ZodEnum<{
+                discovery: "discovery";
+                toolset: "toolset";
+            }>>;
+            enabledAt: z.ZodOptional<z.ZodNumber>;
+            exposed: z.ZodBoolean;
+        }, z.core.$strip>>;
+        discoverableTools: z.ZodArray<z.ZodObject<{
+            fullName: z.ZodString;
+            originalName: z.ZodString;
+            serverName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            exposureMode: z.ZodEnum<{
+                direct: "direct";
+                discovery: "discovery";
+                hidden: "hidden";
+            }>;
+            enabled: z.ZodBoolean;
+            enabledBy: z.ZodOptional<z.ZodEnum<{
+                discovery: "discovery";
+                toolset: "toolset";
+            }>>;
+            enabledAt: z.ZodOptional<z.ZodNumber>;
+            exposed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kind: z.ZodLiteral<"canonical-model">;
+    model: z.ZodString;
+}, z.core.$loose>;
+export type CanonicalModelSelection = z.infer<typeof CanonicalModelSelectionSchema>;
+declare module '@makaio/framework/contracts' {
+    interface AgentSelectionKindMap {
+        'canonical-model': CanonicalModelSelection;
+    }
+}
+//# sourceMappingURL=selection.d.ts.map

package/dist/canonical-model/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/canonical-model/selection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,OAAO,QAAQ,mBAAmB,CAAC,CAAC;IAClC,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,uBAAuB,CAAC;KAC5C;CACF"}

package/dist/canonical-model/types.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+/** Exhaustive tuple of all {@link CanonicalModelParseErrorCode} values. */
+export declare const CANONICAL_MODEL_PARSE_ERROR_CODES: readonly ["empty", "empty-model", "empty-routing", "empty-segment", "too-many-segments", "invalid-segment", "invalid-virtual-name", "empty-virtual-name"];
+/**
+ * Error codes produced by the canonical model parser.
+ *
+ * Each code identifies a distinct malformed-input condition:
+ * - `'empty'` - empty or whitespace-only input
+ * - `'empty-model'` - `'::'` present with nothing after it
+ * - `'empty-routing'` - `'::'` present with nothing before it
+ * - `'empty-segment'` - consecutive slashes produce an empty routing segment
+ * - `'too-many-segments'` - more than two routing segments before `'::'`
+ * - `'invalid-segment'` - routing segment contains characters outside `[a-z0-9._-]`
+ * - `'invalid-virtual-name'` - virtual model name contains characters outside `[a-z0-9_-]`
+ * - `'empty-virtual-name'` - bare `'~'` sigil with no name following it
+ */
+export type CanonicalModelParseErrorCode = (typeof CANONICAL_MODEL_PARSE_ERROR_CODES)[number];
+/** Zod schema for {@link CanonicalModelParseErrorCode}. */
+export declare const CanonicalModelParseErrorCodeSchema: z.ZodEnum<{
+    empty: "empty";
+    "empty-model": "empty-model";
+    "empty-routing": "empty-routing";
+    "empty-segment": "empty-segment";
+    "empty-virtual-name": "empty-virtual-name";
+    "invalid-segment": "invalid-segment";
+    "invalid-virtual-name": "invalid-virtual-name";
+    "too-many-segments": "too-many-segments";
+}>;
+/**
+ * Parse error returned by the canonical model parser.
+ *
+ * Discriminated by `kind: 'parse-error'` so it can be combined into
+ * {@link CanonicalModelParseResult} and narrowed with a type guard.
+ */
+export interface CanonicalModelParseError {
+    readonly kind: 'parse-error';
+    /** Machine-readable error category. */
+    readonly code: CanonicalModelParseErrorCode;
+    /** Human-readable description of the problem. */
+    readonly message: string;
+    /** The verbatim input string that produced the error. */
+    readonly input: string;
+}
+/** Zod schema for {@link CanonicalModelParseError}. */
+export declare const CanonicalModelParseErrorSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"parse-error">;
+    code: z.ZodEnum<{
+        empty: "empty";
+        "empty-model": "empty-model";
+        "empty-routing": "empty-routing";
+        "empty-segment": "empty-segment";
+        "empty-virtual-name": "empty-virtual-name";
+        "invalid-segment": "invalid-segment";
+        "invalid-virtual-name": "invalid-virtual-name";
+        "too-many-segments": "too-many-segments";
+    }>;
+    message: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Bare model reference - no routing qualifier.
+ *
+ * The entire input is treated as the verbatim model name and resolved
+ * against the default adapter/provider at runtime.
+ */
+export interface BareModelRef {
+    readonly kind: 'bare';
+    /** Verbatim model name as provided by the caller (for example `'sonnet'`). */
+    readonly model: string;
+}
+/** Zod schema for {@link BareModelRef}. */
+export declare const BareModelRefSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bare">;
+    model: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Qualified model reference - one or two routing segments followed by `'::'` and a model name.
+ *
+ * Routing segments are case-normalised to lowercase during parsing.
+ * The model name is passed through verbatim.
+ */
+export interface QualifiedModelRef {
+    readonly kind: 'qualified';
+    /** First routing segment - adapter or provider slug, lowercased. */
+    readonly segment1: string;
+    /** Second routing segment - provider slug when `segment1` is an adapter, lowercased. */
+    readonly segment2?: string;
+    /** Verbatim model name appearing after `'::'`. */
+    readonly model: string;
+}
+/** Zod schema for {@link QualifiedModelRef}. */
+export declare const QualifiedModelRefSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"qualified">;
+    segment1: z.ZodString;
+    segment2: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Virtual model reference - a logical alias introduced with the `'~'` sigil.
+ *
+ * Hosts may translate this higher-level reference through the existing
+ * virtual-model resolution seam. The framework-owned canonical-model resolver
+ * intentionally does not consume this parsed form.
+ */
+export interface VirtualModelRef {
+    readonly kind: 'virtual';
+    /** Virtual model name without the leading `'~'` sigil. */
+    readonly name: string;
+}
+/** Zod schema for {@link VirtualModelRef}. */
+export declare const VirtualModelRefSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"virtual">;
+    name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Discriminated union of all successfully parsed canonical model forms.
+ *
+ * Narrow with `result.kind` or use the {@link isCanonicalModelParseError} type
+ * guard to separate success from failure.
+ */
+export type ParsedCanonicalModel = BareModelRef | QualifiedModelRef | VirtualModelRef;
+/** Zod schema for {@link ParsedCanonicalModel}. */
+export declare const ParsedCanonicalModelSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"bare">;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"qualified">;
+    segment1: z.ZodString;
+    segment2: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"virtual">;
+    name: z.ZodString;
+}, z.core.$strip>], "kind">;
+/**
+ * Framework-resolvable parsed canonical model forms.
+ *
+ * Host-only `kind: 'virtual'` expansion is intentionally excluded from the
+ * framework resolver contract.
+ */
+export type ResolvableCanonicalModel = BareModelRef | QualifiedModelRef;
+/** Zod schema for {@link ResolvableCanonicalModel}. */
+export declare const ResolvableCanonicalModelSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"bare">;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"qualified">;
+    segment1: z.ZodString;
+    segment2: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+}, z.core.$strip>], "kind">;
+/**
+ * Result of parsing a canonical model string.
+ *
+ * Either a successfully parsed {@link ParsedCanonicalModel} or a
+ * {@link CanonicalModelParseError} describing why parsing failed.
+ */
+export type CanonicalModelParseResult = ParsedCanonicalModel | CanonicalModelParseError;
+/** Zod schema for {@link CanonicalModelParseResult}. */
+export declare const CanonicalModelParseResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"bare">;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"qualified">;
+    segment1: z.ZodString;
+    segment2: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"virtual">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"parse-error">;
+    code: z.ZodEnum<{
+        empty: "empty";
+        "empty-model": "empty-model";
+        "empty-routing": "empty-routing";
+        "empty-segment": "empty-segment";
+        "empty-virtual-name": "empty-virtual-name";
+        "invalid-segment": "invalid-segment";
+        "invalid-virtual-name": "invalid-virtual-name";
+        "too-many-segments": "too-many-segments";
+    }>;
+    message: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strip>], "kind">;
+//# sourceMappingURL=types.d.ts.map

package/dist/canonical-model/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/canonical-model/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,2EAA2E;AAC3E,eAAO,MAAM,iCAAiC,2JASpC,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,iCAAiC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9F,2DAA2D;AAC3D,eAAO,MAAM,kCAAkC;;;;;;;;;EAA4C,CAAC;AAE5F;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAC5C,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,uDAAuD;AACvD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;iBAKzC,CAAC;AAIH;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,2CAA2C;AAC3C,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wFAAwF;IACxF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,gDAAgD;AAChD,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,YAAY,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAEtF,mDAAmD;AACnD,eAAO,MAAM,0BAA0B;;;;;;;;;;;2BAIrC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAExE,uDAAuD;AACvD,eAAO,MAAM,8BAA8B;;;;;;;;2BAGzC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG,oBAAoB,GAAG,wBAAwB,CAAC;AAExF,wDAAwD;AACxD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;2BAK1C,CAAC"}

package/dist/capabilities/auto-launch/index.d.ts

@@ -0,0 +1,3 @@
+export { AUTO_LAUNCH_CAPABILITY_ID, registerAutoLaunchProvider } from './register.js';
+export type { IAutoLaunchProvider } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/capabilities/auto-launch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/capabilities/auto-launch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AACtF,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/capabilities/auto-launch/register.d.ts

@@ -0,0 +1,11 @@
+import type { MakaioBusLike } from '@makaio/framework/core';
+import type { IAutoLaunchProvider } from './types.js';
+/** Capability identifier for auto-launch providers. */
+export declare const AUTO_LAUNCH_CAPABILITY_ID = "autoLaunch";
+/**
+ * Register an auto-launch provider with the capability bus.
+ * @param bus - The Makaio bus instance.
+ * @param provider - The auto-launch provider instance to register.
+ */
+export declare function registerAutoLaunchProvider(bus: MakaioBusLike, provider: IAutoLaunchProvider): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/capabilities/auto-launch/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/capabilities/auto-launch/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,uDAAuD;AACvD,eAAO,MAAM,yBAAyB,eAAe,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAKlG"}