@makaio/contracts 1.0.0-dev-1779051654000

package/dist/tool/namespace.d.ts

@@ -0,0 +1,203 @@
+export declare const ToolNamespace: import("@makaio/framework/core").BusNamespaceDefinition<"tool", {
+    list: {
+        request: import("zod").ZodObject<{
+            toolsetName: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            tools: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+                annotations: import("zod").ZodOptional<import("zod").ZodObject<{
+                    readOnly: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    destructive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    idempotent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    requiresApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                toolsetName: import("zod").ZodString;
+                inputSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+            toolsets: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+                version: import("zod").ZodString;
+                toolCount: import("zod").ZodNumber;
+                configSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    execute: {
+        request: import("zod").ZodObject<{
+            toolName: import("zod").ZodString;
+            input: import("zod").ZodUnknown;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+            contextOverrides: import("zod").ZodOptional<import("zod").ZodObject<{
+                cwd: import("zod").ZodOptional<import("zod").ZodString>;
+                env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                agentId: import("zod").ZodOptional<import("zod").ZodString>;
+                adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+                adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+                turnId: import("zod").ZodOptional<import("zod").ZodString>;
+                turnContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+                toolCallId: import("zod").ZodOptional<import("zod").ZodString>;
+                constraints: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            success: import("zod").ZodLiteral<true>;
+            data: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            success: import("zod").ZodLiteral<false>;
+            error: import("zod").ZodObject<{
+                code: import("zod").ZodString;
+                message: import("zod").ZodString;
+                details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>], "success">;
+    };
+    registered: import("zod").ZodObject<{
+        toolsetName: import("zod").ZodString;
+        toolsetVersion: import("zod").ZodString;
+        toolNames: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    started: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    completed: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+        durationMs: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    error: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    registryChanged: import("zod").ZodObject<{
+        revision: import("zod").ZodNumber;
+        reason: import("zod").ZodEnum<{
+            "plugin-loaded": "plugin-loaded";
+            "plugin-unloaded": "plugin-unloaded";
+            "toolset-registered": "toolset-registered";
+            "toolset-unregistered": "toolset-unregistered";
+        }>;
+        toolsetName: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+}>;
+export declare const ToolSubjects: import("@makaio/framework/core").BusSubjects<import("@makaio/framework/core").FlatSubjectDefinitions<"tool", {
+    list: {
+        request: import("zod").ZodObject<{
+            toolsetName: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            tools: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+                annotations: import("zod").ZodOptional<import("zod").ZodObject<{
+                    readOnly: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    destructive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    idempotent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    requiresApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                toolsetName: import("zod").ZodString;
+                inputSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+            toolsets: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+                version: import("zod").ZodString;
+                toolCount: import("zod").ZodNumber;
+                configSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    execute: {
+        request: import("zod").ZodObject<{
+            toolName: import("zod").ZodString;
+            input: import("zod").ZodUnknown;
+            adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+            contextOverrides: import("zod").ZodOptional<import("zod").ZodObject<{
+                cwd: import("zod").ZodOptional<import("zod").ZodString>;
+                env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                agentId: import("zod").ZodOptional<import("zod").ZodString>;
+                adapterId: import("zod").ZodOptional<import("zod").ZodString>;
+                adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+                turnId: import("zod").ZodOptional<import("zod").ZodString>;
+                turnContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+                toolCallId: import("zod").ZodOptional<import("zod").ZodString>;
+                constraints: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            success: import("zod").ZodLiteral<true>;
+            data: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            success: import("zod").ZodLiteral<false>;
+            error: import("zod").ZodObject<{
+                code: import("zod").ZodString;
+                message: import("zod").ZodString;
+                details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>], "success">;
+    };
+    registered: import("zod").ZodObject<{
+        toolsetName: import("zod").ZodString;
+        toolsetVersion: import("zod").ZodString;
+        toolNames: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    started: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    completed: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+        durationMs: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    error: import("zod").ZodObject<{
+        toolName: import("zod").ZodString;
+        toolsetName: import("zod").ZodString;
+        executionId: import("zod").ZodString;
+        timestamp: import("zod").ZodNumber;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    registryChanged: import("zod").ZodObject<{
+        revision: import("zod").ZodNumber;
+        reason: import("zod").ZodEnum<{
+            "plugin-loaded": "plugin-loaded";
+            "plugin-unloaded": "plugin-unloaded";
+            "toolset-registered": "toolset-registered";
+            "toolset-unregistered": "toolset-unregistered";
+        }>;
+        toolsetName: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+}>, "tool">;
+//# sourceMappingURL=namespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/tool/namespace.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC;AAErE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAyB,CAAC"}

package/dist/tool/schemas.d.ts

@@ -0,0 +1,260 @@
+import { z } from 'zod';
+/**
+ * Tool annotations schema.
+ * Hints for consumers about tool behavior and requirements.
+ */
+declare const ToolAnnotationsSchema: z.ZodObject<{
+    readOnly: z.ZodOptional<z.ZodBoolean>;
+    destructive: z.ZodOptional<z.ZodBoolean>;
+    idempotent: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Tool metadata schema for bus events and requests.
+ */
+declare const ToolMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    annotations: z.ZodOptional<z.ZodObject<{
+        readOnly: z.ZodOptional<z.ZodBoolean>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+        idempotent: z.ZodOptional<z.ZodBoolean>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    toolsetName: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tool error schema for failed executions.
+ */
+declare const ToolErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Full tool definition schema for list responses.
+ * Includes inputSchema as JSON Schema for format conversion (e.g., OpenAI).
+ */
+declare const ToolListItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    annotations: z.ZodOptional<z.ZodObject<{
+        readOnly: z.ZodOptional<z.ZodBoolean>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+        idempotent: z.ZodOptional<z.ZodBoolean>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    toolsetName: z.ZodString;
+    inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Toolset info schema for list responses.
+ * Includes metadata and optional configSchema as JSON Schema.
+ */
+declare const ToolsetListItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    toolCount: z.ZodNumber;
+    configSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Execution context overrides forwarded to the tool executor on every request.
+ *
+ * Extracted as a named schema so it can be referenced in `tool.execute`
+ * requests and in the MCP `session.register` wire contract without
+ * duplicating the field list.
+ */
+export declare const ToolExecutionContextOverridesSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    adapterId: z.ZodOptional<z.ZodString>;
+    adapterName: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    turnContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for `ToolExecutionContextOverridesSchema`. */
+export type ToolExecutionContextOverrides = z.infer<typeof ToolExecutionContextOverridesSchema>;
+/**
+ * Tool domain schemas.
+ *
+ * Subjects for tool-related bus communication.
+ * Each key becomes a subject identifier as: `tool.{key}`
+ * @example
+ * ```typescript
+ * // Register handler for tool execution requests
+ * bus.on(ToolSubjects.execute, async (context) => {
+ *   const { toolName, input } = context.payload;
+ *   // Execute tool...
+ *   context.setResult({ success: true, data: result });
+ * });
+ * ```
+ */
+export declare const ToolSchemas: {
+    /**
+     * List all registered tools.
+     *
+     * Subject: `tool.list`
+     * Type: Request (RPC)
+     * Purpose: Returns definitions for all registered tools including input schemas.
+     */
+    list: {
+        request: z.ZodObject<{
+            toolsetName: z.ZodOptional<z.ZodString>;
+            adapterId: z.ZodOptional<z.ZodString>;
+            adapterName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                annotations: z.ZodOptional<z.ZodObject<{
+                    readOnly: z.ZodOptional<z.ZodBoolean>;
+                    destructive: z.ZodOptional<z.ZodBoolean>;
+                    idempotent: z.ZodOptional<z.ZodBoolean>;
+                    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                toolsetName: z.ZodString;
+                inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            toolsets: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                version: z.ZodString;
+                toolCount: z.ZodNumber;
+                configSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Execute a tool.
+     *
+     * Subject: `tool.execute`
+     * Type: Request (RPC)
+     * Purpose: Execute a tool with given input and return the result.
+     */
+    execute: {
+        request: z.ZodObject<{
+            toolName: z.ZodString;
+            input: z.ZodUnknown;
+            adapterId: z.ZodOptional<z.ZodString>;
+            adapterName: z.ZodOptional<z.ZodString>;
+            contextOverrides: z.ZodOptional<z.ZodObject<{
+                cwd: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                agentId: z.ZodOptional<z.ZodString>;
+                adapterId: z.ZodOptional<z.ZodString>;
+                adapterName: z.ZodOptional<z.ZodString>;
+                turnId: z.ZodOptional<z.ZodString>;
+                turnContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                reasoning: z.ZodOptional<z.ZodString>;
+                toolCallId: z.ZodOptional<z.ZodString>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            success: z.ZodLiteral<true>;
+            data: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<false>;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "success">;
+    };
+    /**
+     * Toolset registered event.
+     *
+     * Subject: `tool.registered`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A toolset is registered with the registry.
+     * Emits once per toolset with all tool names.
+     */
+    registered: z.ZodObject<{
+        toolsetName: z.ZodString;
+        toolsetVersion: z.ZodString;
+        toolNames: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    /**
+     * Tool execution started.
+     *
+     * Subject: `tool.started`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A tool begins execution.
+     */
+    started: z.ZodObject<{
+        toolName: z.ZodString;
+        toolsetName: z.ZodString;
+        executionId: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * Tool execution completed successfully.
+     *
+     * Subject: `tool.completed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A tool finishes execution successfully.
+     */
+    completed: z.ZodObject<{
+        toolName: z.ZodString;
+        toolsetName: z.ZodString;
+        executionId: z.ZodString;
+        timestamp: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * Tool execution error.
+     *
+     * Subject: `tool.error`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A tool encounters an error during execution.
+     */
+    error: z.ZodObject<{
+        toolName: z.ZodString;
+        toolsetName: z.ZodString;
+        executionId: z.ZodString;
+        timestamp: z.ZodNumber;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    /**
+     * Tool registry changed event.
+     *
+     * Subject: `tool.registryChanged`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A toolset is registered or unregistered, or a plugin is loaded/unloaded.
+     * Used by consumers (e.g., MCP server) to invalidate stale tool lists.
+     */
+    registryChanged: z.ZodObject<{
+        revision: z.ZodNumber;
+        reason: z.ZodEnum<{
+            "plugin-loaded": "plugin-loaded";
+            "plugin-unloaded": "plugin-unloaded";
+            "toolset-registered": "toolset-registered";
+            "toolset-unregistered": "toolset-unregistered";
+        }>;
+        toolsetName: z.ZodString;
+    }, z.core.$strip>;
+};
+/** Type exports for external use */
+export type ToolAnnotations = z.infer<typeof ToolAnnotationsSchema>;
+export type ToolMetadata = z.infer<typeof ToolMetadataSchema>;
+export type ToolListItem = z.infer<typeof ToolListItemSchema>;
+export type ToolsetListItem = z.infer<typeof ToolsetListItemSchema>;
+export type ToolError = z.infer<typeof ToolErrorSchema>;
+export type ToolExecuteResult = z.infer<typeof ToolSchemas.execute.response>;
+export type ToolRegistryChanged = z.infer<typeof ToolSchemas.registryChanged>;
+export type ToolRegistryChangedReason = ToolRegistryChanged['reason'];
+export {};
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tool/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;iBASzB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;iBAStB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,eAAe;;;;iBAOnB,CAAC;AAaH;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;iBAGtB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;iBAWzB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;iBAgC9C,CAAC;AAEH,0EAA0E;AAC1E,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAwChG;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkBH;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAeH;;;;;;;OAOG;;;;;;IAUH;;;;;;OAMG;;;;;;;IAQH;;;;;;OAMG;;;;;;;;IAUH;;;;;;OAMG;;;;;;;;;;;;IAUH;;;;;;;OAOG;;;;;;;;;;;CASmB,CAAC;AAEzB,oCAAoC;AACpC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,eAAe,CAAC,CAAC;AAC9E,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/tool-capability/capabilities.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Tool capability taxonomy for the Makaio harness.
+ *
+ * Defines the canonical, platform-owned set of capability identifiers that
+ * tools declare at registration time. Capability data drives policy decisions
+ * (e.g. ToolApprovalService) and UI presentation without coupling adapters to
+ * one another.
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Canonical capability taxonomy. Platform-owned and adapter-agnostic.
+ * Tools map to one or more capabilities at declaration time.
+ */
+export declare const ToolCapability: {
+    /** Read the contents of a file from the local filesystem. */
+    readonly FILE_READ: "file.read";
+    /** Write or create a file on the local filesystem. */
+    readonly FILE_WRITE: "file.write";
+    /** Delete a file or directory from the local filesystem. */
+    readonly FILE_DELETE: "file.delete";
+    /** Search within file contents (grep-style). */
+    readonly SEARCH_CONTENT: "search.content";
+    /** Search for files by name or pattern (glob/find-style). */
+    readonly SEARCH_FILES: "search.files";
+    /** Perform a web or internet search. */
+    readonly SEARCH_WEB: "search.web";
+    /** Execute arbitrary shell commands. */
+    readonly SHELL_EXECUTE: "shell.execute";
+    /** Make HTTP or other network requests. */
+    readonly NETWORK_REQUEST: "network.request";
+    /** Start, stop, or otherwise manage OS processes. */
+    readonly PROCESS_MANAGE: "process.manage";
+};
+/** Union of all capability string literals. */
+export type ToolCapability = (typeof ToolCapability)[keyof typeof ToolCapability];
+/**
+ * Semantic meta-tags derived from a tool's capability set.
+ *
+ * - `'read-only'`  — the tool only reads state; it never mutates anything.
+ * - `'destructive'` — the tool can modify or destroy data/processes.
+ */
+export type ToolMetaTag = 'read-only' | 'destructive';
+/**
+ * Capabilities that are strictly read-only — they observe but never mutate
+ * files, processes, or external state.
+ *
+ * Note: {@link ToolCapability.NETWORK_REQUEST} is intentionally absent from both sets.
+ * Network calls can be read-only (GET) or mutating (POST/DELETE/webhooks).
+ * Tools with only NETWORK_REQUEST receive no meta-tag and are treated as neutral.
+ */
+export declare const READ_ONLY_CAPABILITIES: ReadonlySet<ToolCapability>;
+/**
+ * Capabilities that can mutate or destroy files, data, or OS-level resources.
+ */
+export declare const DESTRUCTIVE_CAPABILITIES: ReadonlySet<ToolCapability>;
+export declare const ToolCapabilitySchema: 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";
+}>;
+/**
+ * Derives semantic meta-tags from a tool's declared capabilities.
+ *
+ * - Returns `'read-only'` when **all** capabilities are in
+ * the read-only capability set (the tool observes only).
+ * - Returns `'destructive'` when **any** capability is in
+ * the destructive capability set (the tool can mutate/destroy).
+ * - No tags may be returned (e.g. a tool with only `NETWORK_REQUEST` receives
+ * neither {@link ToolMetaTag}).
+ * - `'read-only'` and `'destructive'` cannot both be returned in the current
+ * taxonomy because the read-only and destructive capability sets are disjoint.
+ * @param capabilities - The capability values declared by the tool.
+ * @returns An array of {@link ToolMetaTag} values that apply to the tool.
+ */
+export declare function computeMetaTags(capabilities: readonly ToolCapability[]): ToolMetaTag[];
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/tool-capability/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/tool-capability/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,6DAA6D;;IAE7D,sDAAsD;;IAEtD,4DAA4D;;IAE5D,gDAAgD;;IAEhD,6DAA6D;;IAE7D,wCAAwC;;IAExC,wCAAwC;;IAExC,2CAA2C;;IAE3C,qDAAqD;;CAE7C,CAAC;AAEX,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAElF;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,aAAa,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,cAAc,CAK7D,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,cAAc,CAK/D,CAAC;AAYH,eAAO,MAAM,oBAAoB;;;;;;;;;;EAA2B,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,SAAS,cAAc,EAAE,GAAG,WAAW,EAAE,CAYtF"}

package/dist/tool-capability/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public API for the tool-capability taxonomy module.
+ * @packageDocumentation
+ */
+export { computeMetaTags, DESTRUCTIVE_CAPABILITIES, READ_ONLY_CAPABILITIES, ToolCapability, ToolCapabilitySchema, } from './capabilities.js';
+export type { ToolMetaTag } from './capabilities.js';
+export type { CapabilityGroup, CapabilityItem, CapabilityPickerValue } from './picker-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tool-capability/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tool-capability/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/tool-capability/picker-types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Tool capability picker data contracts.
+ *
+ * Types used by the CapabilityPicker UI component for three-state
+ * capability selection and raw tool override management.
+ * @packageDocumentation
+ */
+import type { ToolCapability, ToolMetaTag } from './capabilities.js';
+/**
+ * Composite value emitted by the CapabilityPicker widget.
+ * Controls four schema fields via a single widget.
+ * @param allowedCapabilities - Capabilities explicitly allowed (present = allowed in three-state model)
+ * @param disallowedCapabilities - Capabilities explicitly disallowed (present = disallowed in three-state model)
+ * @param allowedTools - Raw tool name overrides that bypass capability filtering
+ * @param disallowedTools - Raw tool names explicitly blocked
+ */
+export interface CapabilityPickerValue {
+    /** Capabilities explicitly allowed (three-state: present = allowed). */
+    allowedCapabilities: ToolCapability[];
+    /** Capabilities explicitly disallowed (three-state: present = disallowed). */
+    disallowedCapabilities: ToolCapability[];
+    /** Raw tool name overrides that bypass capability filtering. */
+    allowedTools: string[];
+    /** Raw tool names explicitly blocked. */
+    disallowedTools: string[];
+}
+/**
+ * A capability with its resolved tools and meta-tags, ready for rendering.
+ * @param capability - Canonical capability identifier
+ * @param label - Human-readable label derived from capability
+ * @param resolvedTools - Tool names in the active harness that declare this capability
+ * @param metaTags - Computed meta-tags for tools with only this capability
+ */
+export interface CapabilityItem {
+    /** Canonical capability identifier. */
+    capability: ToolCapability;
+    /** Human-readable label (derived from capability, e.g., 'file.read' → 'File Read'). */
+    label: string;
+    /** Tool names in the active harness that declare this capability. */
+    resolvedTools: string[];
+    /** Computed meta-tags for tools with only this capability. */
+    metaTags: ToolMetaTag[];
+}
+/**
+ * Capabilities grouped by dotted-namespace prefix for rendering.
+ * @param label - Group label (e.g., 'File', 'Shell', 'Search')
+ * @param items - Capabilities in this group
+ */
+export interface CapabilityGroup {
+    /** Group label (e.g., 'File', 'Shell', 'Search', 'Network', 'Process'). */
+    label: string;
+    /** Capabilities in this group. */
+    items: CapabilityItem[];
+}
+//# sourceMappingURL=picker-types.d.ts.map

package/dist/tool-capability/picker-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-types.d.ts","sourceRoot":"","sources":["../../src/tool-capability/picker-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,8EAA8E;IAC9E,sBAAsB,EAAE,cAAc,EAAE,CAAC;IACzC,gEAAgE;IAChE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yCAAyC;IACzC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,UAAU,EAAE,cAAc,CAAC;IAC3B,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB"}

package/dist/ui-config-C1F4oDus.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";const t=e.object({value:e.string(),label:e.string()}),n=e.object({widget:e.string().optional(),delimiter:e.string().optional(),placeholder:e.string().optional(),helpText:e.string().optional(),min:e.number().finite().optional(),max:e.number().finite().optional(),step:e.number().finite().positive().optional(),options:e.array(t).optional()}).superRefine((t,n)=>{t.min!==void 0&&t.max!==void 0&&t.min>t.max&&n.addIssue({code:e.ZodIssueCode.custom,message:"`min` must be less than or equal to `max`",path:[`min`]})}),r=e.object({editMode:e.enum([`inline`,`slidePanel`,`fullPage`]).default(`fullPage`),hiddenFields:e.array(e.string()).optional(),readOnlyInEditMode:e.array(e.string()).optional(),fieldOverrides:e.record(e.string(),n).optional(),sections:e.array(e.object({id:e.string(),title:e.string(),description:e.string().optional(),fields:e.array(e.string())})).optional()});export{t as n,n as r,r as t};

package/dist/variant/index.d.ts

@@ -0,0 +1,4 @@
+export { MakaioVariantSchema, VariantSchemas, VariantUpgradeStatusSchema } from './schemas.js';
+export type { MakaioVariant, VariantGetInfoResponse, VariantRequestUpgradeRequest, VariantRequestUpgradeResponse, VariantUpgradeProgressEvent, VariantUpgradeStatus, } from './schemas.js';
+export { VariantNamespace, VariantSubjects } from './namespace.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/variant/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC/F,YAAY,EACV,aAAa,EACb,sBAAsB,EACtB,4BAA4B,EAC5B,6BAA6B,EAC7B,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}