@dexto/core 1.1.10 → 1.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"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"}

package/dist/approval/schemas.js

@@ -0,0 +1,159 @@
+import "../chunk-C6A6W6XS.js";
+import { z } from "zod";
+import { ApprovalType, ApprovalStatus } from "./types.js";
+const ApprovalTypeSchema = z.nativeEnum(ApprovalType);
+const ApprovalStatusSchema = z.nativeEnum(ApprovalStatus);
+const ToolConfirmationMetadataSchema = z.object({
+  toolName: z.string().describe("Name of the tool to confirm"),
+  args: z.record(z.unknown()).describe("Arguments for the tool"),
+  description: z.string().optional().describe("Description of the tool")
+}).strict().describe("Tool confirmation metadata");
+const CommandConfirmationMetadataSchema = z.object({
+  toolName: z.string().describe("Name of the tool executing the command"),
+  command: z.string().describe("The normalized command to execute"),
+  originalCommand: z.string().optional().describe("The original command before normalization")
+}).strict().describe("Command confirmation metadata");
+const ElicitationMetadataSchema = z.object({
+  schema: z.record(z.unknown()).describe("JSON Schema for the form"),
+  prompt: z.string().describe("Prompt to show the user"),
+  serverName: z.string().describe("MCP server requesting input"),
+  context: z.record(z.unknown()).optional().describe("Additional context")
+}).strict().describe("Elicitation metadata");
+const CustomApprovalMetadataSchema = z.record(z.unknown()).describe("Custom metadata");
+const BaseApprovalRequestSchema = z.object({
+  approvalId: z.string().uuid().describe("Unique approval identifier"),
+  type: ApprovalTypeSchema.describe("Type of approval"),
+  sessionId: z.string().optional().describe("Session identifier"),
+  timeout: z.number().int().positive().describe("Timeout in milliseconds"),
+  timestamp: z.date().describe("When the request was created")
+}).describe("Base approval request");
+const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: z.literal(ApprovalType.TOOL_CONFIRMATION),
+  metadata: ToolConfirmationMetadataSchema
+}).strict();
+const CommandConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: z.literal(ApprovalType.COMMAND_CONFIRMATION),
+  metadata: CommandConfirmationMetadataSchema
+}).strict();
+const ElicitationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: z.literal(ApprovalType.ELICITATION),
+  metadata: ElicitationMetadataSchema
+}).strict();
+const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
+  type: z.literal(ApprovalType.CUSTOM),
+  metadata: CustomApprovalMetadataSchema
+}).strict();
+const ApprovalRequestSchema = z.discriminatedUnion("type", [
+  ToolConfirmationRequestSchema,
+  CommandConfirmationRequestSchema,
+  ElicitationRequestSchema,
+  CustomApprovalRequestSchema
+]);
+const ToolConfirmationResponseDataSchema = z.object({
+  rememberChoice: z.boolean().optional().describe("Remember this choice")
+}).strict().describe("Tool confirmation response data");
+const CommandConfirmationResponseDataSchema = z.object({
+  // Command confirmations don't have remember choice - they're per-command
+  // Could add command pattern remembering in future (e.g., "remember git push *")
+}).strict().describe("Command confirmation response data");
+const ElicitationResponseDataSchema = z.object({
+  formData: z.record(z.unknown()).describe("Form data matching schema")
+}).strict().describe("Elicitation response data");
+const CustomApprovalResponseDataSchema = z.record(z.unknown()).describe("Custom response data");
+const BaseApprovalResponseSchema = z.object({
+  approvalId: z.string().uuid().describe("Must match request approvalId"),
+  status: ApprovalStatusSchema.describe("Approval status"),
+  sessionId: z.string().optional().describe("Session identifier")
+}).describe("Base approval response");
+const ToolConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ToolConfirmationResponseDataSchema.optional()
+}).strict();
+const CommandConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: CommandConfirmationResponseDataSchema.optional()
+}).strict();
+const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ElicitationResponseDataSchema.optional()
+}).strict();
+const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
+  data: CustomApprovalResponseDataSchema.optional()
+}).strict();
+const ApprovalResponseSchema = z.union([
+  ToolConfirmationResponseSchema,
+  CommandConfirmationResponseSchema,
+  ElicitationResponseSchema,
+  CustomApprovalResponseSchema
+]);
+const ApprovalRequestDetailsSchema = z.object({
+  type: ApprovalTypeSchema,
+  sessionId: z.string().optional(),
+  timeout: z.number().int().positive(),
+  metadata: z.union([
+    ToolConfirmationMetadataSchema,
+    CommandConfirmationMetadataSchema,
+    ElicitationMetadataSchema,
+    CustomApprovalMetadataSchema
+  ])
+}).superRefine((data, ctx) => {
+  if (data.type === ApprovalType.TOOL_CONFIRMATION) {
+    const result = ToolConfirmationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metadata must match ToolConfirmationMetadataSchema for TOOL_CONFIRMATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === ApprovalType.COMMAND_CONFIRMATION) {
+    const result = CommandConfirmationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metadata must match CommandConfirmationMetadataSchema for COMMAND_CONFIRMATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === ApprovalType.ELICITATION) {
+    const result = ElicitationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metadata must match ElicitationMetadataSchema for ELICITATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === ApprovalType.CUSTOM) {
+    const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metadata must match CustomApprovalMetadataSchema for CUSTOM type",
+        path: ["metadata"]
+      });
+    }
+  }
+});
+export {
+  ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema,
+  ApprovalResponseSchema,
+  ApprovalStatusSchema,
+  ApprovalTypeSchema,
+  BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema,
+  CommandConfirmationMetadataSchema,
+  CommandConfirmationRequestSchema,
+  CommandConfirmationResponseDataSchema,
+  CommandConfirmationResponseSchema,
+  CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema,
+  ElicitationMetadataSchema,
+  ElicitationRequestSchema,
+  ElicitationResponseDataSchema,
+  ElicitationResponseSchema,
+  ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema
+};

package/dist/approval/types.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  ApprovalStatus: () => ApprovalStatus,
+  ApprovalType: () => ApprovalType
+});
+module.exports = __toCommonJS(types_exports);
+var ApprovalType = /* @__PURE__ */ ((ApprovalType2) => {
+  ApprovalType2["TOOL_CONFIRMATION"] = "tool_confirmation";
+  ApprovalType2["COMMAND_CONFIRMATION"] = "command_confirmation";
+  ApprovalType2["ELICITATION"] = "elicitation";
+  ApprovalType2["CUSTOM"] = "custom";
+  return ApprovalType2;
+})(ApprovalType || {});
+var ApprovalStatus = /* @__PURE__ */ ((ApprovalStatus2) => {
+  ApprovalStatus2["APPROVED"] = "approved";
+  ApprovalStatus2["DENIED"] = "denied";
+  ApprovalStatus2["CANCELLED"] = "cancelled";
+  return ApprovalStatus2;
+})(ApprovalStatus || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalStatus,
+  ApprovalType
+});

package/dist/approval/types.d.ts

@@ -0,0 +1,166 @@
+import type { z } from 'zod';
+import type { ToolConfirmationMetadataSchema, CommandConfirmationMetadataSchema, ElicitationMetadataSchema, CustomApprovalMetadataSchema, BaseApprovalRequestSchema, ToolConfirmationRequestSchema, CommandConfirmationRequestSchema, ElicitationRequestSchema, CustomApprovalRequestSchema, ApprovalRequestSchema, ApprovalRequestDetailsSchema, ToolConfirmationResponseDataSchema, CommandConfirmationResponseDataSchema, ElicitationResponseDataSchema, CustomApprovalResponseDataSchema, BaseApprovalResponseSchema, ToolConfirmationResponseSchema, CommandConfirmationResponseSchema, ElicitationResponseSchema, CustomApprovalResponseSchema, ApprovalResponseSchema } from './schemas.js';
+/**
+ * Types of approval requests supported by the system
+ */
+export declare enum ApprovalType {
+    /**
+     * Binary approval for tool execution
+     * Metadata contains: toolName, args, description
+     */
+    TOOL_CONFIRMATION = "tool_confirmation",
+    /**
+     * Binary approval for dangerous commands within an already-approved tool
+     * Metadata contains: toolName, command, originalCommand
+     * (sessionId is provided at the request level, not in metadata)
+     */
+    COMMAND_CONFIRMATION = "command_confirmation",
+    /**
+     * Schema-based form input from MCP servers
+     * Metadata contains: schema, prompt, serverName, context
+     */
+    ELICITATION = "elicitation",
+    /**
+     * Custom approval types for extensibility
+     * Metadata format defined by consumer
+     */
+    CUSTOM = "custom"
+}
+/**
+ * Status of an approval response
+ */
+export declare enum ApprovalStatus {
+    APPROVED = "approved",
+    DENIED = "denied",
+    CANCELLED = "cancelled"
+}
+/**
+ * Tool confirmation specific metadata
+ * Derived from ToolConfirmationMetadataSchema
+ */
+export type ToolConfirmationMetadata = z.output<typeof ToolConfirmationMetadataSchema>;
+/**
+ * Command confirmation specific metadata
+ * Derived from CommandConfirmationMetadataSchema
+ */
+export type CommandConfirmationMetadata = z.output<typeof CommandConfirmationMetadataSchema>;
+/**
+ * Elicitation specific metadata (MCP)
+ * Derived from ElicitationMetadataSchema
+ */
+export type ElicitationMetadata = z.output<typeof ElicitationMetadataSchema>;
+/**
+ * Custom approval metadata - flexible structure
+ * Derived from CustomApprovalMetadataSchema
+ */
+export type CustomApprovalMetadata = z.output<typeof CustomApprovalMetadataSchema>;
+/**
+ * Base approval request that all approvals extend
+ * Derived from BaseApprovalRequestSchema
+ */
+export type BaseApprovalRequest<_TMetadata = unknown> = z.output<typeof BaseApprovalRequestSchema>;
+/**
+ * Tool confirmation request
+ * Derived from ToolConfirmationRequestSchema
+ */
+export type ToolConfirmationRequest = z.output<typeof ToolConfirmationRequestSchema>;
+/**
+ * Command confirmation request
+ * Derived from CommandConfirmationRequestSchema
+ */
+export type CommandConfirmationRequest = z.output<typeof CommandConfirmationRequestSchema>;
+/**
+ * Elicitation request from MCP server
+ * Derived from ElicitationRequestSchema
+ */
+export type ElicitationRequest = z.output<typeof ElicitationRequestSchema>;
+/**
+ * Custom approval request
+ * Derived from CustomApprovalRequestSchema
+ */
+export type CustomApprovalRequest = z.output<typeof CustomApprovalRequestSchema>;
+/**
+ * Union of all approval request types
+ * Derived from ApprovalRequestSchema
+ */
+export type ApprovalRequest = z.output<typeof ApprovalRequestSchema>;
+/**
+ * Tool confirmation response data
+ * Derived from ToolConfirmationResponseDataSchema
+ */
+export type ToolConfirmationResponseData = z.output<typeof ToolConfirmationResponseDataSchema>;
+/**
+ * Command confirmation response data
+ * Derived from CommandConfirmationResponseDataSchema
+ */
+export type CommandConfirmationResponseData = z.output<typeof CommandConfirmationResponseDataSchema>;
+/**
+ * Elicitation response data - validated form inputs
+ * Derived from ElicitationResponseDataSchema
+ */
+export type ElicitationResponseData = z.output<typeof ElicitationResponseDataSchema>;
+/**
+ * Custom approval response data
+ * Derived from CustomApprovalResponseDataSchema
+ */
+export type CustomApprovalResponseData = z.output<typeof CustomApprovalResponseDataSchema>;
+/**
+ * Base approval response
+ * Derived from BaseApprovalResponseSchema
+ */
+export type BaseApprovalResponse<_TData = unknown> = z.output<typeof BaseApprovalResponseSchema>;
+/**
+ * Tool confirmation response
+ * Derived from ToolConfirmationResponseSchema
+ */
+export type ToolConfirmationResponse = z.output<typeof ToolConfirmationResponseSchema>;
+/**
+ * Command confirmation response
+ * Derived from CommandConfirmationResponseSchema
+ */
+export type CommandConfirmationResponse = z.output<typeof CommandConfirmationResponseSchema>;
+/**
+ * Elicitation response
+ * Derived from ElicitationResponseSchema
+ */
+export type ElicitationResponse = z.output<typeof ElicitationResponseSchema>;
+/**
+ * Custom approval response
+ * Derived from CustomApprovalResponseSchema
+ */
+export type CustomApprovalResponse = z.output<typeof CustomApprovalResponseSchema>;
+/**
+ * Union of all approval response types
+ * Derived from ApprovalResponseSchema
+ */
+export type ApprovalResponse = z.output<typeof ApprovalResponseSchema>;
+/**
+ * Details for creating an approval request
+ * Derived from ApprovalRequestDetailsSchema
+ */
+export type ApprovalRequestDetails = z.output<typeof ApprovalRequestDetailsSchema>;
+/**
+ * Interface for approval providers
+ */
+export interface ApprovalProvider {
+    /**
+     * Request approval from the user
+     * @param request The approval request details
+     * @returns Promise resolving to the approval response
+     */
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    /**
+     * Cancel a pending approval request
+     * @param approvalId The ID of the approval to cancel
+     */
+    cancelApproval(approvalId: string): void;
+    /**
+     * Cancel all pending approval requests
+     */
+    cancelAllApprovals(): void;
+    /**
+     * Get list of pending approval request IDs
+     */
+    getPendingApprovals(): string[];
+}
+//# 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":"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"}

package/dist/approval/types.js

@@ -0,0 +1,18 @@
+import "../chunk-C6A6W6XS.js";
+var ApprovalType = /* @__PURE__ */ ((ApprovalType2) => {
+  ApprovalType2["TOOL_CONFIRMATION"] = "tool_confirmation";
+  ApprovalType2["COMMAND_CONFIRMATION"] = "command_confirmation";
+  ApprovalType2["ELICITATION"] = "elicitation";
+  ApprovalType2["CUSTOM"] = "custom";
+  return ApprovalType2;
+})(ApprovalType || {});
+var ApprovalStatus = /* @__PURE__ */ ((ApprovalStatus2) => {
+  ApprovalStatus2["APPROVED"] = "approved";
+  ApprovalStatus2["DENIED"] = "denied";
+  ApprovalStatus2["CANCELLED"] = "cancelled";
+  return ApprovalStatus2;
+})(ApprovalStatus || {});
+export {
+  ApprovalStatus,
+  ApprovalType
+};

package/dist/chunk-C6A6W6XS.js

@@ -0,0 +1,53 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __decoratorStart,
+  __runInitializers,
+  __decorateElement
+};

package/dist/config/agent-resolver.d.ts

@@ -6,10 +6,9 @@
  * @returns Resolved absolute path to agent config
  * @throws DextoRuntimeError for any resolution failures
  */
-declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+export declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
 /**
  * Update default agent preference
  */
-declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
-
-export { resolveAgentPath, updateDefaultAgentPreference };
+export declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
+//# sourceMappingURL=agent-resolver.d.ts.map

package/dist/config/agent-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-resolver.d.ts","sourceRoot":"","sources":["../../src/config/agent-resolver.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC,CAyBjB;AA4HD;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBnF"}

package/dist/config/agent-resolver.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { promises as fs } from "fs";
 import path from "path";
 import { isPath } from "../utils/path.js";

package/dist/config/error-codes.d.ts

@@ -2,7 +2,7 @@
  * Config-specific error codes
  * Includes file operations, parsing, and validation errors for configuration management
  */
-declare enum ConfigErrorCode {
+export declare enum ConfigErrorCode {
     FILE_NOT_FOUND = "config_file_not_found",
     FILE_READ_ERROR = "config_file_read_error",
     FILE_WRITE_ERROR = "config_file_write_error",
@@ -13,5 +13,4 @@ declare enum ConfigErrorCode {
     BUNDLED_NOT_FOUND = "config_bundled_not_found",
     UNKNOWN_CONTEXT = "config_unknown_context"
 }
-
-export { ConfigErrorCode };
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/config/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/config/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IAEvB,cAAc,0BAA0B;IACxC,eAAe,2BAA2B;IAC1C,gBAAgB,4BAA4B;IAG5C,WAAW,uBAAuB;IAGlC,kBAAkB,8BAA8B;IAChD,qBAAqB,iCAAiC;IACtD,gBAAgB,4BAA4B;IAC5C,iBAAiB,6BAA6B;IAC9C,eAAe,2BAA2B;CAC7C"}

package/dist/config/error-codes.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 var ConfigErrorCode = /* @__PURE__ */ ((ConfigErrorCode2) => {
   ConfigErrorCode2["FILE_NOT_FOUND"] = "config_file_not_found";
   ConfigErrorCode2["FILE_READ_ERROR"] = "config_file_read_error";

package/dist/config/errors.d.ts

@@ -1,23 +1,9 @@
-import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
-import '../errors/DextoBaseError.js';
-import '../errors/types.js';
-import '../agent/error-codes.js';
-import './error-codes.js';
-import '../context/error-codes.js';
-import '../llm/error-codes.js';
-import '../mcp/error-codes.js';
-import '../session/error-codes.js';
-import '../storage/error-codes.js';
-import '../systemPrompt/error-codes.js';
-import '../tools/error-codes.js';
-import '../preferences/error-codes.js';
-import '../agent/registry/error-codes.js';
-
+import { DextoRuntimeError } from '../errors/index.js';
 /**
  * Config runtime error factory methods
  * Creates properly typed errors for configuration operations
  */
-declare class ConfigError {
+export declare class ConfigError {
     static fileNotFound(configPath: string): DextoRuntimeError<{
         configPath: string;
     }>;
@@ -45,5 +31,4 @@ declare class ConfigError {
         context: string;
     }>;
 }
-
-export { ConfigError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/config/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/config/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAIvD;;;GAGG;AACH,qBAAa,WAAW;IAEpB,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM;;;IAWtC,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAWtD,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAYvD,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAYnD,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,MAAM;;;IAW3C,MAAM,CAAC,mBAAmB;IAW1B,MAAM,CAAC,eAAe;IAWtB,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,MAAM;;;IAW1C,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM;;;CAUxC"}

package/dist/config/errors.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { DextoRuntimeError } from "../errors/index.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { ConfigErrorCode } from "./error-codes.js";

package/dist/config/index.d.ts

@@ -1,7 +1,4 @@
-export { loadAgentConfig } from './loader.js';
-export { LLMOverrides, writeConfigFile, writeLLMPreferences, writePreferencesToAgent } from './writer.js';
-export { resolveAgentPath, updateDefaultAgentPreference } from './agent-resolver.js';
-import '../agent/schemas.js';
-import 'zod';
-import '../llm/types.js';
-import '../preferences/schemas.js';
+export * from './loader.js';
+export * from './writer.js';
+export * from './agent-resolver.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC"}

package/dist/config/loader.d.ts

@@ -1,6 +1,4 @@
 import { AgentConfig } from '../agent/schemas.js';
-import 'zod';
-
 /**
  * Asynchronously loads and processes an agent configuration file.
  * This function handles file reading, YAML parsing, and template variable expansion.
@@ -14,6 +12,5 @@ import 'zod';
  * @throws {ConfigError} with FILE_READ_ERROR if file read fails (e.g., permissions issues)
  * @throws {ConfigError} with PARSE_ERROR if the content is not valid YAML or template expansion fails
  */
-declare function loadAgentConfig(configPath: string): Promise<AgentConfig>;
-
-export { loadAgentConfig };
+export declare function loadAgentConfig(configPath: string): Promise<AgentConfig>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAiErD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAuD9E"}

package/dist/config/loader.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { promises as fs } from "fs";
 import path from "path";
 import { parse as parseYaml } from "yaml";

package/dist/config/writer.d.ts

@@ -1,9 +1,7 @@
-import { LLMProvider } from '../llm/types.js';
-import { GlobalPreferences } from '../preferences/schemas.js';
-import { AgentConfig } from '../agent/schemas.js';
-import 'zod';
-
-interface LLMOverrides {
+import type { LLMProvider } from '../llm/types.js';
+import { type GlobalPreferences } from '../preferences/schemas.js';
+import { type AgentConfig } from '../agent/schemas.js';
+export interface LLMOverrides {
     provider?: LLMProvider;
     model?: string;
     apiKey?: string;
@@ -18,7 +16,7 @@ interface LLMOverrides {
  * @returns A Promise that resolves when the file has been successfully written
  * @throws {ConfigError} with FILE_WRITE_ERROR if an error occurs during YAML stringification or file writing
  */
-declare function writeConfigFile(configPath: string, config: AgentConfig): Promise<void>;
+export declare function writeConfigFile(configPath: string, config: AgentConfig): Promise<void>;
 /**
  * Write global LLM preferences to an agent config file
  * @param configPath Absolute path to agent configuration file
@@ -26,13 +24,12 @@ declare function writeConfigFile(configPath: string, config: AgentConfig): Promi
  * @param overrides Optional CLI overrides
  * @throws DextoRuntimeError for write failures
  */
-declare function writeLLMPreferences(configPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
+export declare function writeLLMPreferences(configPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
 /**
  * Write preferences to an installed agent (file or directory)
  * @param installedPath Path to installed agent file or directory
  * @param preferences Global preferences to write
  * @param overrides Optional CLI overrides
  */
-declare function writePreferencesToAgent(installedPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
-
-export { type LLMOverrides, writeConfigFile, writeLLMPreferences, writePreferencesToAgent };
+export declare function writePreferencesToAgent(installedPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/config/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/config/writer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB5F;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC,IAAI,CAAC,CAiEf;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CACzC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/config/writer.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { promises as fs } from "fs";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import * as path from "path";