@makaio/contracts 1.0.0-dev-1779051654000

package/dist/approval/enriched-policy.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * RPC schema for resolving a persona/profile-enriched approval policy.
+ *
+ * ToolApprovalService uses this RPC to obtain enriched approval policies
+ * without importing host-tier storage subjects. The host-tier handler
+ * performs persona/profile lookups and returns the merged policy decision.
+ */
+export declare const ResolveEnrichedPolicySchema: {
+    /**
+     * Resolve an enriched approval policy for a given tool and agent context.
+     *
+     * Subject: `approval.resolveEnrichedPolicy`
+     * Type: Request (RPC)
+     * @example
+     * ```typescript
+     * const policy = await bus.request(
+     *   ApprovalSubjects.resolveEnrichedPolicy,
+     *   { toolName: 'bash', personaId: 'persona-uuid' },
+     * );
+     * // policy.action === 'ask'
+     * // policy.riskLevel === 'destructive'
+     * ```
+     */
+    resolveEnrichedPolicy: {
+        request: z.ZodObject<{
+            toolName: z.ZodString;
+            personaId: z.ZodOptional<z.ZodString>;
+            profileId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            action: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            personaName: z.ZodOptional<z.ZodString>;
+            profileName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+/** Inferred request type for `approval.resolveEnrichedPolicy`. */
+export type ResolveEnrichedPolicyRequest = z.infer<typeof ResolveEnrichedPolicySchema.resolveEnrichedPolicy.request>;
+/** Inferred response type for `approval.resolveEnrichedPolicy`. */
+export type ResolveEnrichedPolicyResponse = z.infer<typeof ResolveEnrichedPolicySchema.resolveEnrichedPolicy.response>;
+//# sourceMappingURL=enriched-policy.d.ts.map

package/dist/approval/enriched-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enriched-policy.d.ts","sourceRoot":"","sources":["../../src/approval/enriched-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;IACtC;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;;;;;;;;;;CA0BJ,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;AAErH,mEAAmE;AACnE,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/approval/index.d.ts

@@ -0,0 +1,6 @@
+export { ApprovalSchemas } from './schemas.js';
+export type { ApprovalRequest, ApprovalResponse } from './schemas.js';
+export { ApprovalNamespace, ApprovalSubjects } from './namespace.js';
+export type { ApprovalEntry, ResolvedApprovalEntry, RiskLevel } from './types.js';
+export { ResolveEnrichedPolicySchema, type ResolveEnrichedPolicyRequest, type ResolveEnrichedPolicyResponse, } from './enriched-policy.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/approval/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACrE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGlF,OAAO,EACL,2BAA2B,EAC3B,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,GACnC,MAAM,sBAAsB,CAAC"}

package/dist/approval/namespace.d.ts

@@ -0,0 +1,127 @@
+/** Bus namespace definition for approval request/response subjects. */
+export declare const ApprovalNamespace: import("@makaio/framework/core").BusNamespaceDefinition<"approval", {
+    resolveEnrichedPolicy: {
+        request: import("zod").ZodObject<{
+            toolName: import("zod").ZodString;
+            personaId: import("zod").ZodOptional<import("zod").ZodString>;
+            profileId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            action: import("zod").ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            riskLevel: import("zod").ZodOptional<import("zod").ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            allowedDirectories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            personaName: import("zod").ZodOptional<import("zod").ZodString>;
+            profileName: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    request: {
+        request: import("zod").ZodObject<{
+            requestId: import("zod").ZodString;
+            toolCallId: import("zod").ZodString;
+            toolName: import("zod").ZodOptional<import("zod").ZodString>;
+            args: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            agentId: import("zod").ZodString;
+            sessionId: import("zod").ZodString;
+            adapterName: import("zod").ZodString;
+            personaName: import("zod").ZodOptional<import("zod").ZodString>;
+            profileName: import("zod").ZodOptional<import("zod").ZodString>;
+            capabilities: import("zod").ZodOptional<import("zod").ZodReadonly<import("zod").ZodArray<import("zod").ZodEnum<{
+                "file.delete": "file.delete";
+                "file.read": "file.read";
+                "file.write": "file.write";
+                "network.request": "network.request";
+                "process.manage": "process.manage";
+                "search.content": "search.content";
+                "search.files": "search.files";
+                "search.web": "search.web";
+                "shell.execute": "shell.execute";
+            }>>>>;
+            riskLevel: import("zod").ZodOptional<import("zod").ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+            createdAt: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"allow">;
+            updatedInput: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"deny">;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>], "action">;
+    };
+}>;
+/** Typed bus subjects for the approval namespace. */
+export declare const ApprovalSubjects: import("@makaio/framework/core").BusSubjects<import("@makaio/framework/core").FlatSubjectDefinitions<"approval", {
+    resolveEnrichedPolicy: {
+        request: import("zod").ZodObject<{
+            toolName: import("zod").ZodString;
+            personaId: import("zod").ZodOptional<import("zod").ZodString>;
+            profileId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            action: import("zod").ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            riskLevel: import("zod").ZodOptional<import("zod").ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            allowedDirectories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            personaName: import("zod").ZodOptional<import("zod").ZodString>;
+            profileName: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    request: {
+        request: import("zod").ZodObject<{
+            requestId: import("zod").ZodString;
+            toolCallId: import("zod").ZodString;
+            toolName: import("zod").ZodOptional<import("zod").ZodString>;
+            args: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            agentId: import("zod").ZodString;
+            sessionId: import("zod").ZodString;
+            adapterName: import("zod").ZodString;
+            personaName: import("zod").ZodOptional<import("zod").ZodString>;
+            profileName: import("zod").ZodOptional<import("zod").ZodString>;
+            capabilities: import("zod").ZodOptional<import("zod").ZodReadonly<import("zod").ZodArray<import("zod").ZodEnum<{
+                "file.delete": "file.delete";
+                "file.read": "file.read";
+                "file.write": "file.write";
+                "network.request": "network.request";
+                "process.manage": "process.manage";
+                "search.content": "search.content";
+                "search.files": "search.files";
+                "search.web": "search.web";
+                "shell.execute": "shell.execute";
+            }>>>>;
+            riskLevel: import("zod").ZodOptional<import("zod").ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+            createdAt: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"allow">;
+            updatedInput: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"deny">;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>], "action">;
+    };
+}>, "approval">;
+//# sourceMappingURL=namespace.d.ts.map

package/dist/approval/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/approval/namespace.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkD,CAAC;AAEjF,qDAAqD;AACrD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA6B,CAAC"}

package/dist/approval/schemas.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+/**
+ * Approval schemas for tool call approval requests.
+ *
+ * Subject: `approval.request`
+ * Type: Request (RPC)
+ *
+ * Emitted when: An agent requests approval before executing a tool call.
+ * The UI handler must keep this request open until the user responds.
+ * Bus timeouts should be set appropriately high for these requests.
+ *
+ * Response semantics:
+ * - `action: 'allow'`: Approve tool execution, optionally with modified args
+ * - `action: 'deny'`: Reject tool execution
+ */
+export declare const ApprovalSchemas: {
+    resolveEnrichedPolicy: {
+        request: z.ZodObject<{
+            toolName: z.ZodString;
+            personaId: z.ZodOptional<z.ZodString>;
+            profileId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            action: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            personaName: z.ZodOptional<z.ZodString>;
+            profileName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    request: {
+        request: z.ZodObject<{
+            requestId: z.ZodString;
+            toolCallId: z.ZodString;
+            toolName: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            agentId: z.ZodString;
+            sessionId: z.ZodString;
+            adapterName: z.ZodString;
+            personaName: z.ZodOptional<z.ZodString>;
+            profileName: z.ZodOptional<z.ZodString>;
+            capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "file.delete": "file.delete";
+                "file.read": "file.read";
+                "file.write": "file.write";
+                "network.request": "network.request";
+                "process.manage": "process.manage";
+                "search.content": "search.content";
+                "search.files": "search.files";
+                "search.web": "search.web";
+                "shell.execute": "shell.execute";
+            }>>>>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                destructive: "destructive";
+                neutral: "neutral";
+                safe: "safe";
+            }>>;
+            reasoning: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>;
+        response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            action: z.ZodLiteral<"allow">;
+            updatedInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"deny">;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "action">;
+    };
+};
+export type ApprovalRequest = z.infer<typeof ApprovalSchemas.request.request>;
+export type ApprovalResponse = z.infer<typeof ApprovalSchemas.request.response>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/approval/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CJ,CAAC;AAEzB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC"}

package/dist/approval/types.d.ts

@@ -0,0 +1,49 @@
+import type { ToolCapability } from '../tool-capability/index.js';
+/**
+ * Risk level for a tool call approval request.
+ * Derived from the agent's classification of the tool's destructive potential.
+ */
+export type RiskLevel = 'safe' | 'neutral' | 'destructive';
+/**
+ * A pending approval entry in the approval queue.
+ * Represents a tool call awaiting user review.
+ */
+export interface ApprovalEntry {
+    /** Unique approval request identifier */
+    requestId: string;
+    /** Tool call identifier from the agent */
+    toolCallId: string;
+    /** Name of the tool being called */
+    toolName?: string;
+    /** Tool call arguments */
+    args?: Record<string, unknown>;
+    /** Agent that initiated the tool call */
+    agentId: string;
+    /** Makaio session identifier */
+    sessionId?: string;
+    /** Adapter type name (e.g., 'claude-code') */
+    adapterName: string;
+    /** Persona display name */
+    personaName?: string;
+    /** Profile display name */
+    profileName?: string;
+    /** Agent capability identifiers */
+    capabilities?: readonly ToolCapability[];
+    /** Risk classification for this tool call */
+    riskLevel?: RiskLevel;
+    /** LLM reasoning/thinking that preceded this tool call (when available) */
+    reasoning?: string;
+    /** Unix timestamp (ms) when the request was created */
+    createdAt: number;
+}
+/**
+ * An approval entry that has been resolved with a user decision.
+ * Extends {@link ApprovalEntry} with the outcome and resolution timestamp.
+ */
+export interface ResolvedApprovalEntry extends ApprovalEntry {
+    /** The user's approval decision */
+    action: 'allow' | 'deny';
+    /** Unix timestamp (ms) when the decision was made */
+    resolvedAt: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/approval/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,YAAY,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IACzC,6CAA6C;IAC7C,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAC1D,mCAAmC;IACnC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IACzB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB"}

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

@@ -0,0 +1,7 @@
+export { BareModelRefSchema, CANONICAL_MODEL_PARSE_ERROR_CODES, CanonicalModelParseErrorCodeSchema, CanonicalModelParseErrorSchema, CanonicalModelParseResultSchema, ParsedCanonicalModelSchema, QualifiedModelRefSchema, ResolvableCanonicalModelSchema, VirtualModelRefSchema, } from './types.js';
+export type { BareModelRef, CanonicalModelParseError, CanonicalModelParseErrorCode, CanonicalModelParseResult, ParsedCanonicalModel, QualifiedModelRef, ResolvableCanonicalModel, VirtualModelRef, } from './types.js';
+export { parseCanonicalModel, isCanonicalModelParseError, SEGMENT_RE, VIRTUAL_NAME_RE } from './parser.js';
+export { CanonicalModelSelectionSchema, type CanonicalModelSelection } from './selection.js';
+export { CanonicalModelResolvedSelectionSchema, CanonicalModelSchemas, type CanonicalModelResolvedSelection, } from './schemas.js';
+export { CanonicalModelNamespace, CanonicalModelSubjects } from './namespace.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/canonical-model/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,iCAAiC,EACjC,kCAAkC,EAClC,8BAA8B,EAC9B,+BAA+B,EAC/B,0BAA0B,EAC1B,uBAAuB,EACvB,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EACxB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3G,OAAO,EAAE,6BAA6B,EAAE,KAAK,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EACL,qCAAqC,EACrC,qBAAqB,EACrB,KAAK,+BAA+B,GACrC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,253 @@
+/** Bus namespace definition for framework canonical-model resolution. */
+export declare const CanonicalModelNamespace: import("@makaio/framework/core").BusNamespaceDefinition<"canonicalModel", {
+    resolve: {
+        request: import("zod").ZodObject<{
+            parsed: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"bare">;
+                model: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"qualified">;
+                segment1: import("zod").ZodString;
+                segment2: import("zod").ZodOptional<import("zod").ZodString>;
+                model: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "kind">;
+            context: import("zod").ZodOptional<import("zod").ZodObject<{
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                promptText: import("zod").ZodOptional<import("zod").ZodString>;
+                sessionContext: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            reasoningEffort: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "extra-high": "extra-high";
+                high: "high";
+                low: "low";
+                medium: "medium";
+                none: "none";
+            }>>;
+            cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            systemPrompt: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"append">;
+                content: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>]>>;
+            allowedTools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            disallowedTools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            mcpSessionContext: import("zod").ZodOptional<import("zod").ZodObject<{
+                sessionId: import("zod").ZodString;
+                servers: import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    transport: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        type: import("zod").ZodLiteral<"stdio">;
+                        command: import("zod").ZodString;
+                        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            permission_policy: import("zod").ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, import("zod/v4/core").$strip>>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        type: import("zod").ZodLiteral<"sse">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            permission_policy: import("zod").ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, import("zod/v4/core").$strip>>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        type: import("zod").ZodLiteral<"http">;
+                    }, import("zod/v4/core").$strip>], "type">;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                    }>;
+                }, import("zod/v4/core").$strip>>;
+                directTools: import("zod").ZodArray<import("zod").ZodObject<{
+                    fullName: import("zod").ZodString;
+                    originalName: import("zod").ZodString;
+                    serverName: import("zod").ZodString;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    inputSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: import("zod").ZodBoolean;
+                    enabledBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    exposed: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+                discoverableTools: import("zod").ZodArray<import("zod").ZodObject<{
+                    fullName: import("zod").ZodString;
+                    originalName: import("zod").ZodString;
+                    serverName: import("zod").ZodString;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    inputSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: import("zod").ZodBoolean;
+                    enabledBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    exposed: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            allowedDirectories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            kind: import("zod").ZodLiteral<"adapter">;
+            adapterName: import("zod").ZodString;
+            providerConfigId: import("zod").ZodString;
+            model: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+    };
+}>;
+/** Typed subjects for canonical model bus operations. */
+export declare const CanonicalModelSubjects: import("@makaio/framework/core").BusSubjects<import("@makaio/framework/core").FlatSubjectDefinitions<"canonicalModel", {
+    resolve: {
+        request: import("zod").ZodObject<{
+            parsed: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"bare">;
+                model: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"qualified">;
+                segment1: import("zod").ZodString;
+                segment2: import("zod").ZodOptional<import("zod").ZodString>;
+                model: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "kind">;
+            context: import("zod").ZodOptional<import("zod").ZodObject<{
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                promptText: import("zod").ZodOptional<import("zod").ZodString>;
+                sessionContext: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            reasoningEffort: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "extra-high": "extra-high";
+                high: "high";
+                low: "low";
+                medium: "medium";
+                none: "none";
+            }>>;
+            cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            systemPrompt: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"append">;
+                content: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>]>>;
+            allowedTools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            disallowedTools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            mcpSessionContext: import("zod").ZodOptional<import("zod").ZodObject<{
+                sessionId: import("zod").ZodString;
+                servers: import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    transport: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        type: import("zod").ZodLiteral<"stdio">;
+                        command: import("zod").ZodString;
+                        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            permission_policy: import("zod").ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, import("zod/v4/core").$strip>>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        type: import("zod").ZodLiteral<"sse">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            permission_policy: import("zod").ZodEnum<{
+                                always_allow: "always_allow";
+                                always_ask: "always_ask";
+                                always_deny: "always_deny";
+                            }>;
+                        }, import("zod/v4/core").$strip>>>;
+                        alwaysLoad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        type: import("zod").ZodLiteral<"http">;
+                    }, import("zod/v4/core").$strip>], "type">;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                    }>;
+                }, import("zod/v4/core").$strip>>;
+                directTools: import("zod").ZodArray<import("zod").ZodObject<{
+                    fullName: import("zod").ZodString;
+                    originalName: import("zod").ZodString;
+                    serverName: import("zod").ZodString;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    inputSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: import("zod").ZodBoolean;
+                    enabledBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    exposed: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+                discoverableTools: import("zod").ZodArray<import("zod").ZodObject<{
+                    fullName: import("zod").ZodString;
+                    originalName: import("zod").ZodString;
+                    serverName: import("zod").ZodString;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    inputSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    exposureMode: import("zod").ZodEnum<{
+                        direct: "direct";
+                        discovery: "discovery";
+                        hidden: "hidden";
+                    }>;
+                    enabled: import("zod").ZodBoolean;
+                    enabledBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        discovery: "discovery";
+                        toolset: "toolset";
+                    }>>;
+                    enabledAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    exposed: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            allowedDirectories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            kind: import("zod").ZodLiteral<"adapter">;
+            adapterName: import("zod").ZodString;
+            providerConfigId: import("zod").ZodString;
+            model: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+    };
+}>, "canonicalModel">;
+//# sourceMappingURL=namespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/canonical-model/namespace.ts"],"names":[],"mappings":"AAGA,yEAAyE;AACzE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8D,CAAC;AAEnG,yDAAyD;AACzD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAmC,CAAC"}