@dexto/core 1.1.9 → 1.1.11

package/dist/mcp/schemas.cjs

@@ -18,7 +18,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schemas_exports = {};
 __export(schemas_exports, {
+  DEFAULT_MCP_CONNECTION_MODE: () => DEFAULT_MCP_CONNECTION_MODE,
   HttpServerConfigSchema: () => HttpServerConfigSchema,
+  MCP_CONNECTION_MODES: () => MCP_CONNECTION_MODES,
+  MCP_SERVER_TYPES: () => MCP_SERVER_TYPES,
   McpServerConfigSchema: () => McpServerConfigSchema,
   ServerConfigsSchema: () => ServerConfigsSchema,
   SseServerConfigSchema: () => SseServerConfigSchema,
@@ -29,6 +32,9 @@ var import_error_codes = require("./error-codes.js");
 var import_types = require("../errors/types.cjs");
 var import_result = require("../utils/result.cjs");
 var import_zod = require("zod");
+const MCP_SERVER_TYPES = ["stdio", "sse", "http"];
+const MCP_CONNECTION_MODES = ["strict", "lenient"];
+const DEFAULT_MCP_CONNECTION_MODE = "lenient";
 const StdioServerConfigSchema = import_zod.z.object({
   type: import_zod.z.literal("stdio"),
   // allow env in command & args if you want; remove EnvExpandedString if not desired
@@ -41,29 +47,28 @@ const StdioServerConfigSchema = import_zod.z.object({
           code: import_error_codes.MCPErrorCode.COMMAND_MISSING,
           scope: import_types.ErrorScope.MCP,
           type: import_types.ErrorType.USER
-        },
-        path: ["command"]
+        }
       });
     }
   }),
   args: import_zod.z.array((0, import_result.EnvExpandedString)()).default([]).describe("Array of arguments for the command (e.g., ['script.js'])"),
   env: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}).describe("Optional environment variables for the server process"),
   timeout: import_zod.z.coerce.number().int().positive().default(3e4),
-  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: import_zod.z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const SseServerConfigSchema = import_zod.z.object({
   type: import_zod.z.literal("sse"),
   url: (0, import_result.RequiredEnvURL)(process.env).describe("URL for the SSE server endpoint"),
   headers: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}),
   timeout: import_zod.z.coerce.number().int().positive().default(3e4),
-  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: import_zod.z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const HttpServerConfigSchema = import_zod.z.object({
   type: import_zod.z.literal("http"),
   url: (0, import_result.RequiredEnvURL)(process.env).describe("URL for the HTTP server"),
   headers: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}),
   timeout: import_zod.z.coerce.number().int().positive().default(3e4),
-  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: import_zod.z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const McpServerConfigSchema = import_zod.z.discriminatedUnion("type", [
   StdioServerConfigSchema,
@@ -74,7 +79,10 @@ const McpServerConfigSchema = import_zod.z.discriminatedUnion("type", [
 const ServerConfigsSchema = import_zod.z.record(McpServerConfigSchema).describe("A dictionary of server configurations, keyed by server name").brand();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_MCP_CONNECTION_MODE,
   HttpServerConfigSchema,
+  MCP_CONNECTION_MODES,
+  MCP_SERVER_TYPES,
   McpServerConfigSchema,
   ServerConfigsSchema,
   SseServerConfigSchema,

package/dist/mcp/schemas.d.ts

@@ -1,6 +1,10 @@
 import { z } from 'zod';
-
-declare const StdioServerConfigSchema: z.ZodObject<{
+export declare const MCP_SERVER_TYPES: readonly ["stdio", "sse", "http"];
+export type McpServerType = (typeof MCP_SERVER_TYPES)[number];
+export declare const MCP_CONNECTION_MODES: readonly ["strict", "lenient"];
+export type McpConnectionMode = (typeof MCP_CONNECTION_MODES)[number];
+export declare const DEFAULT_MCP_CONNECTION_MODE: McpConnectionMode;
+export declare const StdioServerConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"stdio">;
     command: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     args: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
@@ -22,9 +26,9 @@ declare const StdioServerConfigSchema: z.ZodObject<{
     env?: Record<string, string> | undefined;
     connectionMode?: "strict" | "lenient" | undefined;
 }>;
-type StdioServerConfig = z.input<typeof StdioServerConfigSchema>;
-type ValidatedStdioServerConfig = z.output<typeof StdioServerConfigSchema>;
-declare const SseServerConfigSchema: z.ZodObject<{
+export type StdioServerConfig = z.input<typeof StdioServerConfigSchema>;
+export type ValidatedStdioServerConfig = z.output<typeof StdioServerConfigSchema>;
+export declare const SseServerConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"sse">;
     url: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, string, string>>>;
@@ -33,8 +37,8 @@ declare const SseServerConfigSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "sse";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "sse";
@@ -43,9 +47,9 @@ declare const SseServerConfigSchema: z.ZodObject<{
     connectionMode?: "strict" | "lenient" | undefined;
     headers?: Record<string, string> | undefined;
 }>;
-type SseServerConfig = z.input<typeof SseServerConfigSchema>;
-type ValidatedSseServerConfig = z.output<typeof SseServerConfigSchema>;
-declare const HttpServerConfigSchema: z.ZodObject<{
+export type SseServerConfig = z.input<typeof SseServerConfigSchema>;
+export type ValidatedSseServerConfig = z.output<typeof SseServerConfigSchema>;
+export declare const HttpServerConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"http">;
     url: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, string, string>>>;
@@ -54,8 +58,8 @@ declare const HttpServerConfigSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "http";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "http";
@@ -64,9 +68,9 @@ declare const HttpServerConfigSchema: z.ZodObject<{
     connectionMode?: "strict" | "lenient" | undefined;
     headers?: Record<string, string> | undefined;
 }>;
-type HttpServerConfig = z.input<typeof HttpServerConfigSchema>;
-type ValidatedHttpServerConfig = z.output<typeof HttpServerConfigSchema>;
-declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export type HttpServerConfig = z.input<typeof HttpServerConfigSchema>;
+export type ValidatedHttpServerConfig = z.output<typeof HttpServerConfigSchema>;
+export declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"stdio">;
     command: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     args: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
@@ -96,8 +100,8 @@ declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminate
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "sse";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "sse";
@@ -114,8 +118,8 @@ declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminate
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "http";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "http";
@@ -133,14 +137,14 @@ declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminate
 } | {
     timeout: number;
     type: "sse";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 } | {
     timeout: number;
     type: "http";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "stdio";
@@ -162,9 +166,9 @@ declare const McpServerConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodDiscriminate
     connectionMode?: "strict" | "lenient" | undefined;
     headers?: Record<string, string> | undefined;
 }>, "ValidatedMcpServerConfig">;
-type McpServerConfig = z.input<typeof McpServerConfigSchema>;
-type ValidatedMcpServerConfig = z.output<typeof McpServerConfigSchema>;
-declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBranded<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export type McpServerConfig = z.input<typeof McpServerConfigSchema>;
+export type ValidatedMcpServerConfig = z.output<typeof McpServerConfigSchema>;
+export declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBranded<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"stdio">;
     command: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     args: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
@@ -194,8 +198,8 @@ declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBr
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "sse";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "sse";
@@ -212,8 +216,8 @@ declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBr
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     type: "http";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "http";
@@ -231,14 +235,14 @@ declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBr
 } | {
     timeout: number;
     type: "sse";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 } | {
     timeout: number;
     type: "http";
-    url: string;
     connectionMode: "strict" | "lenient";
+    url: string;
     headers: Record<string, string>;
 }, {
     type: "stdio";
@@ -260,7 +264,6 @@ declare const ServerConfigsSchema: z.ZodBranded<z.ZodRecord<z.ZodString, z.ZodBr
     connectionMode?: "strict" | "lenient" | undefined;
     headers?: Record<string, string> | undefined;
 }>, "ValidatedMcpServerConfig">>, "ValidatedServerConfigs">;
-type ServerConfigs = z.input<typeof ServerConfigsSchema>;
-type ValidatedServerConfigs = z.output<typeof ServerConfigsSchema>;
-
-export { type HttpServerConfig, HttpServerConfigSchema, type McpServerConfig, McpServerConfigSchema, type ServerConfigs, ServerConfigsSchema, type SseServerConfig, SseServerConfigSchema, type StdioServerConfig, StdioServerConfigSchema, type ValidatedHttpServerConfig, type ValidatedMcpServerConfig, type ValidatedServerConfigs, type ValidatedSseServerConfig, type ValidatedStdioServerConfig };
+export type ServerConfigs = z.input<typeof ServerConfigsSchema>;
+export type ValidatedServerConfigs = z.output<typeof ServerConfigsSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,mCAAoC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D,eAAO,MAAM,oBAAoB,gCAAiC,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,eAAO,MAAM,2BAA2B,EAAE,iBAA6B,CAAC;AAIxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;EA4BvB,CAAC;AAEd,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAGlF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAQrB,CAAC;AAEd,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAG9E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAQtB,CAAC;AAEd,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAGhF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BASM,CAAC;AAEzC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE9E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DAGM,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/mcp/schemas.js

@@ -2,6 +2,9 @@ import { MCPErrorCode } from "./error-codes.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { EnvExpandedString, RequiredEnvURL } from "../utils/result.js";
 import { z } from "zod";
+const MCP_SERVER_TYPES = ["stdio", "sse", "http"];
+const MCP_CONNECTION_MODES = ["strict", "lenient"];
+const DEFAULT_MCP_CONNECTION_MODE = "lenient";
 const StdioServerConfigSchema = z.object({
   type: z.literal("stdio"),
   // allow env in command & args if you want; remove EnvExpandedString if not desired
@@ -14,29 +17,28 @@ const StdioServerConfigSchema = z.object({
           code: MCPErrorCode.COMMAND_MISSING,
           scope: ErrorScope.MCP,
           type: ErrorType.USER
-        },
-        path: ["command"]
+        }
       });
     }
   }),
   args: z.array(EnvExpandedString()).default([]).describe("Array of arguments for the command (e.g., ['script.js'])"),
   env: z.record(EnvExpandedString()).default({}).describe("Optional environment variables for the server process"),
   timeout: z.coerce.number().int().positive().default(3e4),
-  connectionMode: z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const SseServerConfigSchema = z.object({
   type: z.literal("sse"),
   url: RequiredEnvURL(process.env).describe("URL for the SSE server endpoint"),
   headers: z.record(EnvExpandedString()).default({}),
   timeout: z.coerce.number().int().positive().default(3e4),
-  connectionMode: z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const HttpServerConfigSchema = z.object({
   type: z.literal("http"),
   url: RequiredEnvURL(process.env).describe("URL for the HTTP server"),
   headers: z.record(EnvExpandedString()).default({}),
   timeout: z.coerce.number().int().positive().default(3e4),
-  connectionMode: z.enum(["strict", "lenient"]).default("lenient")
+  connectionMode: z.enum(MCP_CONNECTION_MODES).default(DEFAULT_MCP_CONNECTION_MODE)
 }).strict();
 const McpServerConfigSchema = z.discriminatedUnion("type", [
   StdioServerConfigSchema,
@@ -46,7 +48,10 @@ const McpServerConfigSchema = z.discriminatedUnion("type", [
 }).brand();
 const ServerConfigsSchema = z.record(McpServerConfigSchema).describe("A dictionary of server configurations, keyed by server name").brand();
 export {
+  DEFAULT_MCP_CONNECTION_MODE,
   HttpServerConfigSchema,
+  MCP_CONNECTION_MODES,
+  MCP_SERVER_TYPES,
   McpServerConfigSchema,
   ServerConfigsSchema,
   SseServerConfigSchema,

package/dist/mcp/types.d.ts

@@ -1,21 +1,29 @@
 import { ValidatedMcpServerConfig } from './schemas.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { ToolProvider } from '../tools/types.js';
-import { GetPromptResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'json-schema';
-
+import type { ToolProvider } from '../tools/types.js';
+import { GetPromptResult, ReadResourceResult, Prompt } from '@modelcontextprotocol/sdk/types.js';
+import { EventEmitter } from 'events';
+export interface MCPResourceSummary {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface MCPResolvedResource {
+    key: string;
+    serverName: string;
+    summary: MCPResourceSummary;
+}
 /**
  * Interface for MCP clients specifically, that can provide tools
  */
-interface IMCPClient extends ToolProvider {
+export interface IMCPClient extends ToolProvider, EventEmitter {
     connect(config: ValidatedMcpServerConfig, serverName: string): Promise<Client>;
     disconnect?(): Promise<void>;
-    listPrompts(): Promise<string[]>;
+    listPrompts(): Promise<Prompt[]>;
     getPrompt(name: string, args?: Record<string, unknown>): Promise<GetPromptResult>;
-    listResources(): Promise<string[]>;
+    listResources(): Promise<MCPResourceSummary[]>;
     readResource(uri: string): Promise<ReadResourceResult>;
     getConnectedClient(): Promise<Client>;
 }
-
-export type { IMCPClient };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/mcp/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AACjG,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,MAAM,WAAW,kBAAkB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,kBAAkB,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,YAAY,EAAE,YAAY;IAE1D,OAAO,CAAC,MAAM,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/E,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAG7B,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACjC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAGlF,aAAa,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAC/C,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAGvD,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC"}

package/dist/memory/error-codes.cjs

@@ -0,0 +1,39 @@
+"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 error_codes_exports = {};
+__export(error_codes_exports, {
+  MemoryErrorCode: () => MemoryErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var MemoryErrorCode = /* @__PURE__ */ ((MemoryErrorCode2) => {
+  MemoryErrorCode2["MEMORY_NOT_FOUND"] = "MEMORY_NOT_FOUND";
+  MemoryErrorCode2["MEMORY_ALREADY_EXISTS"] = "MEMORY_ALREADY_EXISTS";
+  MemoryErrorCode2["MEMORY_CONTENT_REQUIRED"] = "MEMORY_CONTENT_REQUIRED";
+  MemoryErrorCode2["MEMORY_CONTENT_TOO_LONG"] = "MEMORY_CONTENT_TOO_LONG";
+  MemoryErrorCode2["MEMORY_INVALID_ID"] = "MEMORY_INVALID_ID";
+  MemoryErrorCode2["MEMORY_INVALID_TAGS"] = "MEMORY_INVALID_TAGS";
+  MemoryErrorCode2["MEMORY_STORAGE_ERROR"] = "MEMORY_STORAGE_ERROR";
+  MemoryErrorCode2["MEMORY_RETRIEVAL_ERROR"] = "MEMORY_RETRIEVAL_ERROR";
+  MemoryErrorCode2["MEMORY_DELETE_ERROR"] = "MEMORY_DELETE_ERROR";
+  return MemoryErrorCode2;
+})(MemoryErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryErrorCode
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Error codes for memory operations
+ */
+export declare enum MemoryErrorCode {
+    MEMORY_NOT_FOUND = "MEMORY_NOT_FOUND",
+    MEMORY_ALREADY_EXISTS = "MEMORY_ALREADY_EXISTS",
+    MEMORY_CONTENT_REQUIRED = "MEMORY_CONTENT_REQUIRED",
+    MEMORY_CONTENT_TOO_LONG = "MEMORY_CONTENT_TOO_LONG",
+    MEMORY_INVALID_ID = "MEMORY_INVALID_ID",
+    MEMORY_INVALID_TAGS = "MEMORY_INVALID_TAGS",
+    MEMORY_STORAGE_ERROR = "MEMORY_STORAGE_ERROR",
+    MEMORY_RETRIEVAL_ERROR = "MEMORY_RETRIEVAL_ERROR",
+    MEMORY_DELETE_ERROR = "MEMORY_DELETE_ERROR"
+}
+//# sourceMappingURL=error-codes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/memory/error-codes.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,eAAe;IAEvB,gBAAgB,qBAAqB;IACrC,qBAAqB,0BAA0B;IAG/C,uBAAuB,4BAA4B;IACnD,uBAAuB,4BAA4B;IACnD,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAG3C,oBAAoB,yBAAyB;IAC7C,sBAAsB,2BAA2B;IACjD,mBAAmB,wBAAwB;CAC9C"}

package/dist/memory/error-codes.js

@@ -0,0 +1,15 @@
+var MemoryErrorCode = /* @__PURE__ */ ((MemoryErrorCode2) => {
+  MemoryErrorCode2["MEMORY_NOT_FOUND"] = "MEMORY_NOT_FOUND";
+  MemoryErrorCode2["MEMORY_ALREADY_EXISTS"] = "MEMORY_ALREADY_EXISTS";
+  MemoryErrorCode2["MEMORY_CONTENT_REQUIRED"] = "MEMORY_CONTENT_REQUIRED";
+  MemoryErrorCode2["MEMORY_CONTENT_TOO_LONG"] = "MEMORY_CONTENT_TOO_LONG";
+  MemoryErrorCode2["MEMORY_INVALID_ID"] = "MEMORY_INVALID_ID";
+  MemoryErrorCode2["MEMORY_INVALID_TAGS"] = "MEMORY_INVALID_TAGS";
+  MemoryErrorCode2["MEMORY_STORAGE_ERROR"] = "MEMORY_STORAGE_ERROR";
+  MemoryErrorCode2["MEMORY_RETRIEVAL_ERROR"] = "MEMORY_RETRIEVAL_ERROR";
+  MemoryErrorCode2["MEMORY_DELETE_ERROR"] = "MEMORY_DELETE_ERROR";
+  return MemoryErrorCode2;
+})(MemoryErrorCode || {});
+export {
+  MemoryErrorCode
+};

package/dist/memory/errors.cjs

@@ -0,0 +1,112 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  MemoryError: () => MemoryError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoRuntimeError = require("../errors/DextoRuntimeError.js");
+var import_types = require("../errors/types.js");
+var import_error_codes = require("./error-codes.js");
+class MemoryError {
+  static notFound(id) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_NOT_FOUND,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.NOT_FOUND,
+      `Memory not found: ${id}`,
+      { id }
+    );
+  }
+  static alreadyExists(id) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_ALREADY_EXISTS,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.USER,
+      `Memory already exists: ${id}`,
+      { id }
+    );
+  }
+  static contentRequired() {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_CONTENT_REQUIRED,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.USER,
+      "Memory content is required"
+    );
+  }
+  static contentTooLong(length, maxLength) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_CONTENT_TOO_LONG,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.USER,
+      `Memory content too long: ${length} characters (max: ${maxLength})`,
+      { length, maxLength }
+    );
+  }
+  static invalidId(id) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_INVALID_ID,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.USER,
+      `Invalid memory ID: ${id}`,
+      { id }
+    );
+  }
+  static invalidTags(tags) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_INVALID_TAGS,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.USER,
+      `Invalid tags format: ${JSON.stringify(tags)}`,
+      { tags }
+    );
+  }
+  static storageError(message, cause) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_STORAGE_ERROR,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.SYSTEM,
+      `Memory storage error: ${message}`,
+      { cause }
+    );
+  }
+  static retrievalError(message, cause) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_RETRIEVAL_ERROR,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.SYSTEM,
+      `Memory retrieval error: ${message}`,
+      { cause }
+    );
+  }
+  static deleteError(message, cause) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MemoryErrorCode.MEMORY_DELETE_ERROR,
+      import_types.ErrorScope.MEMORY,
+      import_types.ErrorType.SYSTEM,
+      `Memory deletion error: ${message}`,
+      { cause }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryError
+});

package/dist/memory/errors.d.ts

@@ -0,0 +1,16 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
+/**
+ * Memory error factory following the error pattern from config/errors.ts
+ */
+export declare class MemoryError {
+    static notFound(id: string): DextoRuntimeError;
+    static alreadyExists(id: string): DextoRuntimeError;
+    static contentRequired(): DextoRuntimeError;
+    static contentTooLong(length: number, maxLength: number): DextoRuntimeError;
+    static invalidId(id: string): DextoRuntimeError;
+    static invalidTags(tags: unknown): DextoRuntimeError;
+    static storageError(message: string, cause?: Error): DextoRuntimeError;
+    static retrievalError(message: string, cause?: Error): DextoRuntimeError;
+    static deleteError(message: string, cause?: Error): DextoRuntimeError;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/memory/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE;;GAEG;AACH,qBAAa,WAAW;IACpB,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB;IAU9C,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB;IAUnD,MAAM,CAAC,eAAe,IAAI,iBAAiB;IAS3C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB;IAU3E,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB;IAU/C,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB;IAUpD,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,iBAAiB;IAUtE,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,iBAAiB;IAUxE,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,iBAAiB;CASxE"}

package/dist/memory/errors.js

@@ -0,0 +1,88 @@
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { MemoryErrorCode } from "./error-codes.js";
+class MemoryError {
+  static notFound(id) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_NOT_FOUND,
+      ErrorScope.MEMORY,
+      ErrorType.NOT_FOUND,
+      `Memory not found: ${id}`,
+      { id }
+    );
+  }
+  static alreadyExists(id) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_ALREADY_EXISTS,
+      ErrorScope.MEMORY,
+      ErrorType.USER,
+      `Memory already exists: ${id}`,
+      { id }
+    );
+  }
+  static contentRequired() {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_CONTENT_REQUIRED,
+      ErrorScope.MEMORY,
+      ErrorType.USER,
+      "Memory content is required"
+    );
+  }
+  static contentTooLong(length, maxLength) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_CONTENT_TOO_LONG,
+      ErrorScope.MEMORY,
+      ErrorType.USER,
+      `Memory content too long: ${length} characters (max: ${maxLength})`,
+      { length, maxLength }
+    );
+  }
+  static invalidId(id) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_INVALID_ID,
+      ErrorScope.MEMORY,
+      ErrorType.USER,
+      `Invalid memory ID: ${id}`,
+      { id }
+    );
+  }
+  static invalidTags(tags) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_INVALID_TAGS,
+      ErrorScope.MEMORY,
+      ErrorType.USER,
+      `Invalid tags format: ${JSON.stringify(tags)}`,
+      { tags }
+    );
+  }
+  static storageError(message, cause) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_STORAGE_ERROR,
+      ErrorScope.MEMORY,
+      ErrorType.SYSTEM,
+      `Memory storage error: ${message}`,
+      { cause }
+    );
+  }
+  static retrievalError(message, cause) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_RETRIEVAL_ERROR,
+      ErrorScope.MEMORY,
+      ErrorType.SYSTEM,
+      `Memory retrieval error: ${message}`,
+      { cause }
+    );
+  }
+  static deleteError(message, cause) {
+    return new DextoRuntimeError(
+      MemoryErrorCode.MEMORY_DELETE_ERROR,
+      ErrorScope.MEMORY,
+      ErrorType.SYSTEM,
+      `Memory deletion error: ${message}`,
+      { cause }
+    );
+  }
+}
+export {
+  MemoryError
+};