@makaio/framework 1.0.0-dev-1779046984397

package/dist/index-DEw90pa2.d.mts

@@ -0,0 +1,183 @@
+import { MakaioContext } from "@makaio/framework/core";
+import { IMakaioBus } from "@makaio/framework/bus";
+import { AnyToolDefinition, FILE_ACCESS_RULES_KEY as FILE_ACCESS_RULES_KEY$1, FileAccessRuleProvider, FileAccessRuleProvider as FileAccessRuleProvider$1, FileAccessRules, ToolExecutionContext, ToolInfo, ToolResult, Toolset, extractToolFilePath as extractToolFilePath$1 } from "@makaio/framework/tools";
+import { ContributionProcessor } from "@makaio/framework/kernel";
+
+//#region packages/services/core/src/tools/types.d.ts
+/**
+ * Options for creating a ToolRegistry instance.
+ */
+interface ToolRegistryOptions {
+  /** Bus instance (defaults to global MakaioBus) */
+  bus?: IMakaioBus;
+  /** Priority for bus handlers (default 0) */
+  handlerPriority?: number;
+  /** Policy provider for toolset access control (SEAM) */
+  policyProvider?: ToolsetPolicyProvider;
+  /**
+   * Provider for filesystem access rules (.makaioignore + allowedDirectories).
+   * Called by execute() before dispatching to filesystem tools.
+   * SEAM: MVP reads .makaioignore files. Phase 2 composes WebUI rules.
+   */
+  fileAccessRuleProvider?: FileAccessRuleProvider;
+}
+/** Filter options for listing tools. */
+interface ListToolsFilter {
+  /** Filter by toolset name */
+  toolsetName?: string;
+  /** Adapter ID for policy-based filtering (falls back if adapterName not provided) */
+  adapterId?: string;
+  /** Adapter name for policy-based filtering (preferred over adapterId) */
+  adapterName?: string;
+}
+/** Toolset info returned from listToolsets. */
+interface ToolsetInfo {
+  name: string;
+  description: string;
+  version: string;
+  toolCount: number;
+  configSchema?: Record<string, unknown>;
+}
+/** Combined tools and toolsets listing result. */
+interface ToolsWithToolsetsResult {
+  tools: ToolInfo[];
+  toolsets: ToolsetInfo[];
+}
+/** Policy configuration for a toolset. */
+interface ToolsetPolicy {
+  /** Adapters allowed to use this toolset (empty = all allowed) */
+  allowedAdapters?: string[];
+  /** Tools disabled within this toolset */
+  disabledTools?: string[];
+}
+/**
+ * Provider function that returns policy for a given toolset.
+ * SEAM: Implement in runtime to read from settings storage.
+ */
+type ToolsetPolicyProvider = (toolsetName: string) => Promise<ToolsetPolicy | null>;
+/** Options for tool execution. */
+interface ExecuteOptions {
+  contextOverrides?: Partial<MakaioContext> & Partial<ToolExecutionContext>;
+  adapterId?: string;
+  adapterName?: string;
+}
+//#endregion
+//#region packages/services/core/src/tools/tool-registry.d.ts
+/**
+ * Central registry for tools and toolsets.
+ * Manages registration, lookup, and execution with bus integration.
+ * Emits lifecycle events (registered, started, completed, error) for observability.
+ * Emits `registryChanged` with a monotonically increasing revision whenever the set of
+ * registered toolsets changes, allowing consumers to invalidate stale tool lists.
+ */
+declare class ToolRegistry {
+  private readonly bus;
+  private readonly toolsets;
+  private readonly tools;
+  private readonly cleanupHandlers;
+  private readonly handlerPriority;
+  private readonly policyProvider?;
+  private readonly fileAccessRuleProvider?;
+  private revision;
+  /**
+   * Creates a new ToolRegistry with optional configuration.
+   * @param options - Registry configuration options
+   */
+  constructor(options?: ToolRegistryOptions);
+  /** Registers RPC handlers for tool.list and tool.execute on the bus. */
+  private registerHandlers;
+  /**
+   * Registers a toolset. All tools are indexed by name. Emits `tool.registered` event.
+   * @param toolset - Toolset to register
+   */
+  register(toolset: Toolset): Promise<void>;
+  /**
+   * Deregisters a toolset and all its tools. Emits `tool.registryChanged` event.
+   * @param toolsetName - Name of the toolset to deregister
+   * @throws Error if the toolset is not registered
+   */
+  deregister(toolsetName: string): Promise<void>;
+  /**
+   * Emit a monotonic registryChanged event for toolset lifecycle updates.
+   * @param reason - Change reason enum.
+   * @param toolsetName - Affected toolset.
+   */
+  private emitRegistryChanged;
+  /**
+   * Executes a tool by name with the given input.
+   *
+   * Validates input against the tool's schema, enforces policy, executes the tool,
+   * and emits lifecycle events (started, completed/error). Constraints are enriched
+   * with file access rules before the tool receives its context.
+   * @param toolName - Name of the tool to execute
+   * @param input - Input data (validated against tool's inputSchema)
+   * @param options - Optional execution options (context overrides, adapter identity)
+   * @returns Tool execution result (success with data or failure with error)
+   */
+  execute(toolName: string, input: unknown, options?: ExecuteOptions): Promise<ToolResult<unknown>>;
+  /**
+   * Builds a ToolExecutionContext from execute options, enriching constraints
+   * with file access rules when a provider is configured.
+   * @param options - Execution options with optional context overrides
+   * @param effectiveAdapterIdentity - Canonical adapter identity for this execution
+   * @returns Fully populated ToolExecutionContext
+   */
+  private buildExecutionContext;
+  /**
+   * Check policy for tool execution. Returns ToolFailure if denied, null if allowed.
+   * @param toolsetName - Toolset name for policy lookup
+   * @param toolName - Tool name to check
+   * @param adapterId - Adapter ID for allowedAdapters check
+   * @param adapterName - Adapter name for allowedAdapters check
+   * @returns ToolFailure if denied, null if allowed
+   */
+  private checkPolicy;
+  /**
+   * Lists all registered tools with optional filtering.
+   * @param filter - Optional filter criteria
+   * @returns Array of tool information
+   */
+  listTools(filter?: ListToolsFilter): ToolInfo[];
+  /**
+   * Lists all registered toolsets with metadata including configSchema as JSON Schema.
+   * @returns Array of toolset information
+   */
+  listToolsets(): ToolsetInfo[];
+  /**
+   * Lists tools and toolsets with optional filtering. Applies policy filtering when adapterName is provided.
+   * @param filter - Optional filter criteria
+   * @returns Object containing tools array and toolsets array
+   */
+  listToolsWithToolsets(filter?: ListToolsFilter): Promise<ToolsWithToolsetsResult>;
+  /**
+   * Gets a tool definition by name.
+   * @param name - Tool name to look up
+   * @returns Tool definition or undefined if not found
+   */
+  getTool(name: string): AnyToolDefinition | undefined;
+  /**
+   * Gets a toolset by name.
+   * @param name - Toolset name to look up
+   * @returns Toolset or undefined if not found
+   */
+  getToolset(name: string): Toolset | undefined;
+  /** Cleans up registry resources. Unsubscribes all bus handlers. */
+  dispose(): void;
+  /**
+   * Destroy this registry — alias for {@link dispose} to satisfy the package
+   * service lifecycle contract.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region packages/services/core/src/tools/tool-contribution-processor.d.ts
+/**
+ * Create a framework-owned processor for `MakaioExtension.tools`.
+ *
+ * Toolsets are registered sequentially so failures have deterministic rollback.
+ * Missing ToolRegistry is a hard composition error.
+ * @returns Awaited contribution processor for tool contributions.
+ */
+declare function createToolContributionProcessor(): ContributionProcessor;
+//#endregion
+export { createToolContributionProcessor as a, ToolRegistryOptions as c, ToolsetPolicy as d, ToolsetPolicyProvider as f, extractToolFilePath$1 as i, ToolsWithToolsetsResult as l, FileAccessRuleProvider$1 as n, ToolRegistry as o, FileAccessRules as r, ListToolsFilter as s, FILE_ACCESS_RULES_KEY$1 as t, ToolsetInfo as u };

package/dist/index-DQRsGXb5.d.mts

@@ -0,0 +1,109 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { HarnessDefinition, MakaioSessionAgent } from "@makaio/framework/contracts";
+import { BaseService } from "@makaio/framework/service-base";
+import { FileAccessRuleProvider } from "@makaio/framework/tools";
+
+//#region packages/services/core/src/tool-approval/tool-approval-types.d.ts
+/** Configuration options for {@link ToolApprovalService}. */
+interface ToolApprovalServiceOptions {
+  /**
+   * Provider for file access rules derived from `.makaioignore` files.
+   * When supplied, enforces file-access restrictions as an absolute pre-check
+   * that runs before any policy cascade — including `full-access` policies.
+   */
+  fileAccessRuleProvider?: FileAccessRuleProvider;
+}
+//#endregion
+//#region packages/services/core/src/tool-approval/tool-approval-service.d.ts
+/**
+ * Resolves and applies tool approval policies based on the
+ * persona → profile → harness → system default cascade.
+ *
+ * Replaces the blanket auto-approve handler that was previously
+ * in bus-server. Registered in the core runtime lifecycle.
+ *
+ * When a file access rule provider is configured,
+ * `.makaioignore` rules are evaluated before the policy cascade as an absolute
+ * deny layer — no policy (not even `full-access`) can bypass them.
+ */
+declare class ToolApprovalService extends BaseService {
+  /** Minimal logger seam so policy-resolution failures are observable in tests and production. */
+  private readonly logger;
+  private readonly options;
+  /**
+   * Creates a new ToolApprovalService instance.
+   * @param bus - Bus instance used to resolve policy data and register approval handlers
+   * @param options - Optional configuration including a file access rule provider
+   */
+  constructor(bus: IMakaioBus, options?: ToolApprovalServiceOptions);
+  /**
+   * Register the tool approval handler.
+   */
+  protected onInit(): Promise<void>;
+  /**
+   * Dispatch an `always-ask` approval request to the approval queue.
+   * Subscribes to the agent session-closed event so that a pending approval
+   * is automatically cancelled when the agent disconnects. The subscription is
+   * cleaned up in the `finally` block regardless of outcome.
+   * @param payload - Tool approval request payload
+   * @param setResult - Callback to set the handler result on the request context
+   * @param resolved - Pre-resolved policy context used to enrich the request
+   */
+  private dispatchAlwaysAskApproval;
+  /**
+   * Evaluate `.makaioignore` file access rules before policy cascade handling.
+   * @param payload - Incoming tool approval payload
+   * @param context - CWD and directory constraints for rule evaluation
+   * @returns Deny message when access should be blocked, otherwise undefined
+   */
+  private checkFileAccessDenyReason;
+  /**
+   * Execute the `approval.resolveEnrichedPolicy` RPC exactly once and return the
+   * raw discriminated result. Callers apply their own fail-closed semantics.
+   * Errors are logged here since this is the single call site for the RPC.
+   * @param personaId - Optional persona ID from agent metadata
+   * @param profileId - Optional profile ID from agent metadata
+   * @param toolName - Tool name forwarded to the RPC
+   * @returns Handled result with response data, or unhandled sentinel on failure
+   */
+  private fetchRawEnrichedPolicy;
+  /**
+   * Resolves the effective approval policy for a tool approval request,
+   * returning the policy alongside cached harness context.
+   *
+   * Policy cascade: persona/profile (via host-tier RPC) → harness → system default.
+   * After resolving the base policy, applies capability-based overrides from
+   * the harness using most-restrictive-wins semantics.
+   * @param request - Adapter name and tool name from the approval payload
+   * @param agent - Pre-fetched agent metadata, or null if unavailable
+   * @param rawEnrichedPolicy - Pre-fetched enriched-policy RPC result shared with the file-access check
+   * @returns Resolved policy and associated context
+   */
+  private resolvePolicyWithContext;
+  /**
+   * Look up agent metadata from storage by agentId.
+   * @param agentId - The agent identifier
+   * @param sessionId - Optional session ID for scoped lookup
+   * @returns Agent metadata, or null if not found
+   */
+  private getAgentMetadata;
+  /**
+   * Check for a session-level approval policy override.
+   * Uses `requestOptional` so that when no session storage handler is registered
+   * (e.g., in tests or lightweight runtimes) the method gracefully returns
+   * `undefined` and the existing policy cascade runs unchanged.
+   * @param sessionId - Session to check
+   * @returns Override policy or undefined when not set or unavailable
+   */
+  private resolveSessionOverride;
+  /**
+   * Resolve harness policy for the given adapter; returns undefined on failure.
+   * @param adapterName - Adapter type name
+   * @param harnessId - Explicit harness ID; overrides the default harness lookup
+   * @param clientId - Client ID for client-scoped harness resolution
+   * @returns Harness resolution carrying base policy and capability override data, or undefined when resolution fails
+   */
+  private resolveHarnessPolicy;
+}
+//#endregion
+export { ToolApprovalService as t };

package/dist/index-Dd5s4MSm.d.mts

@@ -0,0 +1,72 @@
+import * as _$zod from "zod";
+import { z } from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region packages/contracts/src/model-registry/namespace.d.ts
+/** Public model-registry namespace for SDK-safe model discovery subjects. */
+declare const ModelRegistryPublicNamespace: _$_makaio_core0.BusNamespaceDefinition<"modelRegistry:public", {
+  supportedModels: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      models: _$zod.ZodArray<_$zod.ZodObject<{
+        name: _$zod.ZodString;
+        friendlyName: _$zod.ZodOptional<_$zod.ZodString>;
+        contextWindowSize: _$zod.ZodNumber;
+        provider: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>;
+/** Typed subject accessors for SDK-safe model-registry operations. */
+declare const ModelRegistryPublicSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"modelRegistry:public", {
+  supportedModels: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      models: _$zod.ZodArray<_$zod.ZodObject<{
+        name: _$zod.ZodString;
+        friendlyName: _$zod.ZodOptional<_$zod.ZodString>;
+        contextWindowSize: _$zod.ZodNumber;
+        provider: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>, "modelRegistry:public">;
+//#endregion
+//#region packages/contracts/src/model-registry/schemas.d.ts
+/** SDK-safe model descriptor exposed by the model registry bus seam. */
+declare const ModelRegistrySupportedModelSchema: z.ZodObject<{
+  name: z.ZodString;
+  friendlyName: z.ZodOptional<z.ZodString>;
+  contextWindowSize: z.ZodNumber;
+  provider: z.ZodString;
+}, z.core.$strip>;
+/** Model registry bus schemas shared by framework services and SDK callers. */
+declare const ModelRegistrySchemas: {
+  /**
+   * List SDK-safe model descriptors across all registered providers.
+   *
+   * Subject: `modelRegistry:public.supportedModels`
+   * Type: Request/Response
+   * Handler: ModelRegistryService
+   */
+  supportedModels: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      models: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        friendlyName: z.ZodOptional<z.ZodString>;
+        contextWindowSize: z.ZodNumber;
+        provider: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+};
+/** Inferred SDK-safe supported-model descriptor. */
+type ModelRegistrySupportedModel = z.infer<typeof ModelRegistrySupportedModelSchema>;
+/** Request payload for `modelRegistry:public.supportedModels`. */
+type ModelRegistrySupportedModelsRequest = z.infer<typeof ModelRegistrySchemas.supportedModels.request>;
+/** Response payload for `modelRegistry:public.supportedModels`. */
+type ModelRegistrySupportedModelsResponse = z.infer<typeof ModelRegistrySchemas.supportedModels.response>;
+//#endregion
+export { ModelRegistrySupportedModelsResponse as a, ModelRegistrySupportedModelsRequest as i, ModelRegistrySupportedModel as n, ModelRegistryPublicNamespace as o, ModelRegistrySupportedModelSchema as r, ModelRegistryPublicSubjects as s, ModelRegistrySchemas as t };