@dexto/core 1.6.27 → 1.7.0

package/dist/tools/schemas.d.ts

@@ -6,86 +6,43 @@ export type AllowedToolsStorageType = (typeof ALLOWED_TOOLS_STORAGE_TYPES)[numbe
 export declare const DEFAULT_PERMISSIONS_MODE: PermissionsMode;
 export declare const DEFAULT_ALLOWED_TOOLS_STORAGE: AllowedToolsStorageType;
 export declare const ToolPoliciesSchema: z.ZodDefault<z.ZodObject<{
-    alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-}, "strict", z.ZodTypeAny, {
-    alwaysAllow: string[];
-    alwaysDeny: string[];
-}, {
-    alwaysAllow?: string[] | undefined;
-    alwaysDeny?: string[] | undefined;
-}>>;
+    alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
 export type ToolPolicies = z.output<typeof ToolPoliciesSchema>;
 export declare const PermissionsConfigSchema: z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<["manual", "auto-approve", "auto-deny"]>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        "auto-approve": "auto-approve";
+        "auto-deny": "auto-deny";
+    }>>;
     timeout: z.ZodOptional<z.ZodNumber>;
-    allowedToolsStorage: z.ZodDefault<z.ZodEnum<["memory", "storage"]>>;
-    toolPolicies: z.ZodDefault<z.ZodObject<{
-        alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-        alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        alwaysAllow: string[];
-        alwaysDeny: string[];
-    }, {
-        alwaysAllow?: string[] | undefined;
-        alwaysDeny?: string[] | undefined;
+    allowedToolsStorage: z.ZodDefault<z.ZodEnum<{
+        storage: "storage";
+        memory: "memory";
     }>>;
-}, "strict", z.ZodTypeAny, {
-    mode: "manual" | "auto-approve" | "auto-deny";
-    allowedToolsStorage: "storage" | "memory";
-    toolPolicies: {
-        alwaysAllow: string[];
-        alwaysDeny: string[];
-    };
-    timeout?: number | undefined;
-}, {
-    timeout?: number | undefined;
-    mode?: "manual" | "auto-approve" | "auto-deny" | undefined;
-    allowedToolsStorage?: "storage" | "memory" | undefined;
-    toolPolicies?: {
-        alwaysAllow?: string[] | undefined;
-        alwaysDeny?: string[] | undefined;
-    } | undefined;
-}>;
+    toolPolicies: z.ZodDefault<z.ZodObject<{
+        alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export type PermissionsConfig = z.input<typeof PermissionsConfigSchema>;
 export type ValidatedPermissionsConfig = z.output<typeof PermissionsConfigSchema>;
 export declare const ElicitationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     timeout: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    enabled: boolean;
-    timeout?: number | undefined;
-}, {
-    timeout?: number | undefined;
-    enabled?: boolean | undefined;
-}>;
+}, z.core.$strict>;
 export type ElicitationConfig = z.input<typeof ElicitationConfigSchema>;
 export type ValidatedElicitationConfig = z.output<typeof ElicitationConfigSchema>;
 export declare const ToolLimitsSchema: z.ZodObject<{
     maxOutputChars: z.ZodOptional<z.ZodNumber>;
     maxLines: z.ZodOptional<z.ZodNumber>;
     maxLineLength: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    maxOutputChars?: number | undefined;
-    maxLines?: number | undefined;
-    maxLineLength?: number | undefined;
-}, {
-    maxOutputChars?: number | undefined;
-    maxLines?: number | undefined;
-    maxLineLength?: number | undefined;
-}>;
+}, z.core.$strict>;
 export declare const ToolsConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     maxOutputChars: z.ZodOptional<z.ZodNumber>;
     maxLines: z.ZodOptional<z.ZodNumber>;
     maxLineLength: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    maxOutputChars?: number | undefined;
-    maxLines?: number | undefined;
-    maxLineLength?: number | undefined;
-}, {
-    maxOutputChars?: number | undefined;
-    maxLines?: number | undefined;
-    maxLineLength?: number | undefined;
-}>>;
+}, z.core.$strict>>;
 export type ToolsConfig = z.output<typeof ToolsConfigSchema>;
 //# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB,kDAAmD,CAAC;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE,eAAO,MAAM,2BAA2B,gCAAiC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,eAAO,MAAM,wBAAwB,EAAE,eAAgC,CAAC;AACxE,eAAO,MAAM,6BAA6B,EAAE,uBAAmC,CAAC;AAGhF,eAAO,MAAM,kBAAkB;;;;;;;;;GAiB2B,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BwB,CAAC;AAE7D,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,uBAAuB;;;;;;;;;EAoB/B,CAAC;AAEN,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,gBAAgB;;;;;;;;;;;;EAShB,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;;;;;;;;;GAEgB,CAAC;AAE/C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB,kDAAmD,CAAC;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE,eAAO,MAAM,2BAA2B,gCAAiC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,eAAO,MAAM,wBAAwB,EAAE,eAAgC,CAAC;AACxE,eAAO,MAAM,6BAA6B,EAAE,uBAAmC,CAAC;AAGhF,eAAO,MAAM,kBAAkB;;;mBAiB2B,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;kBA2BwB,CAAC;AAE7D,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,uBAAuB;;;kBAoB/B,CAAC;AAEN,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,gBAAgB;;;;kBAShB,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;mBAEgB,CAAC;AAE/C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/tools/schemas.js

@@ -41,7 +41,7 @@ const ToolLimitsSchema = z.object({
   maxLines: z.number().optional().describe("Maximum number of lines for tool output"),
   maxLineLength: z.number().optional().describe("Maximum length of a single line")
 }).strict();
-const ToolsConfigSchema = z.record(ToolLimitsSchema).describe("Per-tool configuration limits");
+const ToolsConfigSchema = z.record(z.string(), ToolLimitsSchema).describe("Per-tool configuration limits");
 export {
   ALLOWED_TOOLS_STORAGE_TYPES,
   DEFAULT_ALLOWED_TOOLS_STORAGE,

package/dist/tools/session-tool-preferences-store.d.ts

@@ -2,15 +2,9 @@ import { z } from 'zod';
 import type { StorageManager } from '../storage/index.js';
 import type { Logger } from '../logger/v2/types.js';
 declare const SessionToolPreferencesSchema: z.ZodObject<{
-    userAutoApproveTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    disabledTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-}, "strict", z.ZodTypeAny, {
-    userAutoApproveTools: string[];
-    disabledTools: string[];
-}, {
-    userAutoApproveTools?: string[] | undefined;
-    disabledTools?: string[] | undefined;
-}>;
+    userAutoApproveTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabledTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export type SessionToolPreferences = z.output<typeof SessionToolPreferencesSchema>;
 export declare class SessionToolPreferencesStore {
     private readonly storageManager;

package/dist/tools/session-tool-preferences-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-tool-preferences-store.d.ts","sourceRoot":"","sources":["../../src/tools/session-tool-preferences-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,QAAA,MAAM,4BAA4B;;;;;;;;;EAKrB,CAAC;AAEd,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAOnF,qBAAa,2BAA2B;IAIhC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAGpB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,MAAM,EAC/B,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;IAMzC,OAAO,CAAC,QAAQ;IAIV,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAiBxD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ9C,OAAO,CAAC,gBAAgB;CAY3B"}
+{"version":3,"file":"session-tool-preferences-store.d.ts","sourceRoot":"","sources":["../../src/tools/session-tool-preferences-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,QAAA,MAAM,4BAA4B;;;kBAKrB,CAAC;AAEd,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAOnF,qBAAa,2BAA2B;IAIhC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAGpB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,MAAM,EAC/B,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;IAMzC,OAAO,CAAC,QAAQ;IAIV,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAiBxD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ9C,OAAO,CAAC,gBAAgB;CAY3B"}

package/dist/utils/result.cjs

@@ -87,13 +87,16 @@ function splitIssues(issues) {
 }
 function zodToIssues(err, severity = "error") {
   const issues = [];
-  for (const e of err.errors) {
-    if (e.code === "invalid_union" && e.unionErrors) {
-      const unionErrors = e.unionErrors;
+  const normalizePath = (path) => path.filter((segment) => {
+    return typeof segment === "string" || typeof segment === "number";
+  });
+  for (const e of err.issues) {
+    if (e.code === "invalid_union" && "errors" in e) {
+      const unionErrors = e.errors;
       let hasCollectedErrors = false;
-      for (const unionError of unionErrors) {
-        if (unionError && unionError.errors && unionError.errors.length > 0) {
-          issues.push(...zodToIssues(unionError, severity));
+      for (const unionIssueSet of unionErrors) {
+        if (unionIssueSet.length > 0) {
+          issues.push(...zodToIssues(new import_zod.ZodError(unionIssueSet), severity));
           hasCollectedErrors = true;
         }
       }
@@ -104,7 +107,7 @@ function zodToIssues(err, severity = "error") {
           message: e.message,
           scope: params.scope ?? import_types.ErrorScope.AGENT,
           type: params.type ?? import_types.ErrorType.USER,
-          path: e.path,
+          path: normalizePath(e.path),
           severity,
           context: params
         });
@@ -116,7 +119,7 @@ function zodToIssues(err, severity = "error") {
         message: e.message,
         scope: params.scope ?? import_types.ErrorScope.AGENT,
         type: params.type ?? import_types.ErrorType.USER,
-        path: e.path,
+        path: normalizePath(e.path),
         severity,
         context: params
       });

package/dist/utils/result.d.ts

@@ -1,11 +1,11 @@
-import { z, type ZodError } from 'zod';
+import { z, ZodError } from 'zod';
 import type { Issue } from '../errors/types.js';
 /** Trim and require non-empty after trim */
-export declare const NonEmptyTrimmed: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-export declare const OptionalURL: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>;
-export declare const EnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodString, string, string>;
-export declare const NonEmptyEnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-export declare const RequiredEnvURL: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const NonEmptyTrimmed: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const OptionalURL: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string | undefined, string>>>;
+export declare const EnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const NonEmptyEnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const RequiredEnvURL: (env?: Record<string, string | undefined>) => z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 /**
  * A discriminated union result type that can be either successful or failed
  * Provides type safety by ensuring data is only available on success

package/dist/utils/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/utils/result.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AACvC,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGhE,4CAA4C;AAC5C,eAAO,MAAM,eAAe,yEAG6B,CAAC;AAc1D,eAAO,MAAM,WAAW,kIAKT,CAAC;AAGhB,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,8CAUpE,CAAC;AAGP,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,4EAG5E,CAAC;AAGP,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,4EAWlE,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,SAAQ,KAAK,CAAC,CAAC,CAAC,EAAO,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAI/E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC,CAAC,EAAE,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAG3E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,WAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE;;;EAKhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EACnC,GAAG,EAAE,QAAQ,EACb,QAAQ,GAAE,OAAO,GAAG,SAAmB,GACxC,KAAK,CAAC,CAAC,CAAC,EAAE,CA8CZ"}
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/utils/result.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAClC,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGhE,4CAA4C;AAC5C,eAAO,MAAM,eAAe,wDAG6B,CAAC;AAc1D,eAAO,MAAM,WAAW,8HAKT,CAAC;AAGhB,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,2DAUpE,CAAC;AAGP,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,2DAG5E,CAAC;AAGP,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,2DAWlE,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,SAAQ,KAAK,CAAC,CAAC,CAAC,EAAO,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAI/E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC,CAAC,EAAE,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAG3E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,WAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE;;;EAKhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EACnC,GAAG,EAAE,QAAQ,EACb,QAAQ,GAAE,OAAO,GAAG,SAAmB,GACxC,KAAK,CAAC,CAAC,CAAC,EAAE,CAiDZ"}

package/dist/utils/result.js

@@ -1,5 +1,5 @@
 import "../chunk-PTJYTZNU.js";
-import { z } from "zod";
+import { z, ZodError } from "zod";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 const NonEmptyTrimmed = z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
 const ALLOWED_URL_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "codex:"]);
@@ -56,13 +56,16 @@ function splitIssues(issues) {
 }
 function zodToIssues(err, severity = "error") {
   const issues = [];
-  for (const e of err.errors) {
-    if (e.code === "invalid_union" && e.unionErrors) {
-      const unionErrors = e.unionErrors;
+  const normalizePath = (path) => path.filter((segment) => {
+    return typeof segment === "string" || typeof segment === "number";
+  });
+  for (const e of err.issues) {
+    if (e.code === "invalid_union" && "errors" in e) {
+      const unionErrors = e.errors;
       let hasCollectedErrors = false;
-      for (const unionError of unionErrors) {
-        if (unionError && unionError.errors && unionError.errors.length > 0) {
-          issues.push(...zodToIssues(unionError, severity));
+      for (const unionIssueSet of unionErrors) {
+        if (unionIssueSet.length > 0) {
+          issues.push(...zodToIssues(new ZodError(unionIssueSet), severity));
           hasCollectedErrors = true;
         }
       }
@@ -73,7 +76,7 @@ function zodToIssues(err, severity = "error") {
           message: e.message,
           scope: params.scope ?? ErrorScope.AGENT,
           type: params.type ?? ErrorType.USER,
-          path: e.path,
+          path: normalizePath(e.path),
           severity,
           context: params
         });
@@ -85,7 +88,7 @@ function zodToIssues(err, severity = "error") {
         message: e.message,
         scope: params.scope ?? ErrorScope.AGENT,
         type: params.type ?? ErrorType.USER,
-        path: e.path,
+        path: normalizePath(e.path),
         severity,
         context: params
       });

package/dist/utils/schema.cjs

@@ -21,10 +21,14 @@ __export(schema_exports, {
   convertZodSchemaToJsonSchema: () => convertZodSchemaToJsonSchema
 });
 module.exports = __toCommonJS(schema_exports);
-var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_zod = require("zod");
 function convertZodSchemaToJsonSchema(zodSchema, logger) {
   try {
-    const converted = (0, import_zod_to_json_schema.zodToJsonSchema)(zodSchema);
+    const converted = import_zod.z.toJSONSchema(zodSchema, {
+      io: "input",
+      target: "draft-07",
+      unrepresentable: "any"
+    });
     if (converted && typeof converted === "object") {
       return converted;
     }

package/dist/utils/schema.d.ts

@@ -1,14 +1,9 @@
+import { z } from 'zod';
 import type { JSONSchema7 } from 'json-schema';
-import type { ZodSchema } from 'zod';
 import type { Logger } from '../logger/v2/types.js';
 /**
  * Convert Zod schema to JSON Schema format for tool parameters
  *
- * TODO: Replace zod-to-json-schema with Zod v4 native JSON schema support
- * The zod-to-json-schema package is deprecated and adds ~19MB due to a packaging bug
- * (includes test files with full Zod copies in dist-test-v3 and dist-test-v4 folders).
- * Zod v4 has native toJsonSchema() support - migrate when upgrading to Zod v4.
- * See: https://github.com/StefanTerdell/zod-to-json-schema
  */
-export declare function convertZodSchemaToJsonSchema(zodSchema: ZodSchema, logger: Logger): JSONSchema7;
+export declare function convertZodSchemaToJsonSchema(zodSchema: z.ZodType, logger: Logger): JSONSchema7;
 //# sourceMappingURL=schema.d.ts.map

package/dist/utils/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/utils/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAoB9F"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/utils/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAuB9F"}

package/dist/utils/schema.js

@@ -1,8 +1,12 @@
 import "../chunk-PTJYTZNU.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { z } from "zod";
 function convertZodSchemaToJsonSchema(zodSchema, logger) {
   try {
-    const converted = zodToJsonSchema(zodSchema);
+    const converted = z.toJSONSchema(zodSchema, {
+      io: "input",
+      target: "draft-07",
+      unrepresentable: "any"
+    });
     if (converted && typeof converted === "object") {
       return converted;
     }

package/dist/utils/zod-schema-converter.cjs

@@ -23,84 +23,84 @@ __export(zod_schema_converter_exports, {
 });
 module.exports = __toCommonJS(zod_schema_converter_exports);
 var import_zod = require("zod");
+function isJsonSchemaObject(schema) {
+  return !!schema && typeof schema === "object" && !Array.isArray(schema);
+}
+function getJsonSchemaTypes(schema) {
+  const { type } = schema;
+  if (Array.isArray(type)) {
+    return type;
+  }
+  return type ? [type] : [];
+}
+function getJsonSchemaType(schema) {
+  const types = getJsonSchemaTypes(schema);
+  return types.find((type) => type !== "null") ?? types[0];
+}
+function hasNullableJsonSchemaType(schema) {
+  return getJsonSchemaTypes(schema).includes("null");
+}
+function getZodTypeForJsonSchemaType(propSchema, type) {
+  switch (type) {
+    case "string":
+      return import_zod.z.string();
+    case "number":
+      return import_zod.z.number();
+    case "integer":
+      return import_zod.z.number().int();
+    case "boolean":
+      return import_zod.z.boolean();
+    case "object":
+      return import_zod.z.object(jsonSchemaToZodShape(propSchema));
+    case "array": {
+      const itemSchema = getPropertySchema(propSchema.items);
+      return import_zod.z.array(itemSchema ? getZodTypeFromProperty(itemSchema) : import_zod.z.unknown());
+    }
+    case "null":
+      return import_zod.z.null();
+    default:
+      return import_zod.z.unknown();
+  }
+}
+function getPropertySchema(schema) {
+  return isJsonSchemaObject(schema) ? schema : null;
+}
 function jsonSchemaToZodShape(jsonSchema) {
-  if (!jsonSchema || typeof jsonSchema !== "object" || jsonSchema.type !== "object") {
+  if (!isJsonSchemaObject(jsonSchema) || getJsonSchemaType(jsonSchema) !== "object") {
     return {};
   }
   const shape = {};
-  if (jsonSchema.properties) {
-    for (const [key, property] of Object.entries(jsonSchema.properties)) {
-      const propSchema = property;
-      let zodType;
-      switch (propSchema.type) {
-        case "string":
-          zodType = import_zod.z.string();
-          break;
-        case "number":
-          zodType = import_zod.z.number();
-          break;
-        case "integer":
-          zodType = import_zod.z.number().int();
-          break;
-        case "boolean":
-          zodType = import_zod.z.boolean();
-          break;
-        case "array":
-          if (propSchema.items) {
-            const itemType = getZodTypeFromProperty(propSchema.items);
-            zodType = import_zod.z.array(itemType);
-          } else {
-            zodType = import_zod.z.array(import_zod.z.any());
-          }
-          break;
-        case "object":
-          zodType = import_zod.z.object(jsonSchemaToZodShape(propSchema));
-          break;
-        default:
-          zodType = import_zod.z.any();
-      }
-      if (propSchema.description) {
-        zodType._def.description = propSchema.description;
-        zodType = zodType.describe(propSchema.description);
-      }
-      if (!jsonSchema.required || !jsonSchema.required.includes(key)) {
-        zodType = zodType.optional();
-      }
-      shape[key] = zodType;
+  const properties = jsonSchema.properties ?? {};
+  for (const [key, property] of Object.entries(properties)) {
+    const propSchema = getPropertySchema(property);
+    let zodType = propSchema ? getZodTypeFromProperty(propSchema) : import_zod.z.unknown();
+    if (!Array.isArray(jsonSchema.required) || !jsonSchema.required.includes(key)) {
+      zodType = zodType.optional();
     }
+    shape[key] = zodType;
   }
   return shape;
 }
 function getZodTypeFromProperty(propSchema) {
+  const nonNullTypes = getJsonSchemaTypes(propSchema).filter(
+    (type) => type !== "null"
+  );
   let zodType;
-  switch (propSchema.type) {
-    case "string":
-      zodType = import_zod.z.string();
-      break;
-    case "number":
-      zodType = import_zod.z.number();
-      break;
-    case "integer":
-      zodType = import_zod.z.number().int();
-      break;
-    case "boolean":
-      zodType = import_zod.z.boolean();
-      break;
-    case "object":
-      zodType = import_zod.z.object(jsonSchemaToZodShape(propSchema));
-      break;
-    case "array":
-      if (propSchema.items) {
-        zodType = import_zod.z.array(getZodTypeFromProperty(propSchema.items));
-      } else {
-        zodType = import_zod.z.array(import_zod.z.any());
-      }
-      break;
-    default:
-      zodType = import_zod.z.any();
+  if (nonNullTypes.length === 0) {
+    zodType = hasNullableJsonSchemaType(propSchema) ? import_zod.z.null() : import_zod.z.unknown();
+  } else {
+    const zodTypes = nonNullTypes.map((type) => getZodTypeForJsonSchemaType(propSchema, type));
+    const [firstType, secondType, ...restTypes] = zodTypes;
+    if (!firstType) {
+      zodType = import_zod.z.unknown();
+    } else {
+      zodType = secondType ? import_zod.z.union([firstType, secondType, ...restTypes]) : firstType;
+    }
+  }
+  if (hasNullableJsonSchemaType(propSchema) && nonNullTypes.length > 0) {
+    zodType = zodType.nullable();
   }
   if (propSchema.description) {
-    zodType._def.description = propSchema.description;
     zodType = zodType.describe(propSchema.description);
   }
   return zodType;

package/dist/utils/zod-schema-converter.d.ts

@@ -1,11 +1,12 @@
 import { z } from 'zod';
+import type { JSONSchema7 } from 'json-schema';
 /**
  * Converts a JSON Schema object to a Zod raw shape.
  * This is a simplified converter that handles common MCP tool schemas.
  */
-export declare function jsonSchemaToZodShape(jsonSchema: any): z.ZodRawShape;
+export declare function jsonSchemaToZodShape(jsonSchema: unknown): z.ZodRawShape;
 /**
  * Helper function to get a Zod type from a property schema
  */
-export declare function getZodTypeFromProperty(propSchema: any): z.ZodTypeAny;
+export declare function getZodTypeFromProperty(propSchema: JSONSchema7): z.ZodType;
 //# sourceMappingURL=zod-schema-converter.d.ts.map

package/dist/utils/zod-schema-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod-schema-converter.d.ts","sourceRoot":"","sources":["../../src/utils/zod-schema-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,GAAG,GAAG,CAAC,CAAC,WAAW,CAwDnE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,GAAG,GAAG,CAAC,CAAC,UAAU,CAsCpE"}
+{"version":3,"file":"zod-schema-converter.d.ts","sourceRoot":"","sources":["../../src/utils/zod-schema-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAA8C,MAAM,aAAa,CAAC;AAuD3F;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,CAAC,CAAC,WAAW,CAoBvE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,WAAW,GAAG,CAAC,CAAC,OAAO,CA2BzE"}

package/dist/utils/zod-schema-converter.js

@@ -1,83 +1,83 @@
 import "../chunk-PTJYTZNU.js";
 import { z } from "zod";
+function isJsonSchemaObject(schema) {
+  return !!schema && typeof schema === "object" && !Array.isArray(schema);
+}
+function getJsonSchemaTypes(schema) {
+  const { type } = schema;
+  if (Array.isArray(type)) {
+    return type;
+  }
+  return type ? [type] : [];
+}
+function getJsonSchemaType(schema) {
+  const types = getJsonSchemaTypes(schema);
+  return types.find((type) => type !== "null") ?? types[0];
+}
+function hasNullableJsonSchemaType(schema) {
+  return getJsonSchemaTypes(schema).includes("null");
+}
+function getZodTypeForJsonSchemaType(propSchema, type) {
+  switch (type) {
+    case "string":
+      return z.string();
+    case "number":
+      return z.number();
+    case "integer":
+      return z.number().int();
+    case "boolean":
+      return z.boolean();
+    case "object":
+      return z.object(jsonSchemaToZodShape(propSchema));
+    case "array": {
+      const itemSchema = getPropertySchema(propSchema.items);
+      return z.array(itemSchema ? getZodTypeFromProperty(itemSchema) : z.unknown());
+    }
+    case "null":
+      return z.null();
+    default:
+      return z.unknown();
+  }
+}
+function getPropertySchema(schema) {
+  return isJsonSchemaObject(schema) ? schema : null;
+}
 function jsonSchemaToZodShape(jsonSchema) {
-  if (!jsonSchema || typeof jsonSchema !== "object" || jsonSchema.type !== "object") {
+  if (!isJsonSchemaObject(jsonSchema) || getJsonSchemaType(jsonSchema) !== "object") {
     return {};
   }
   const shape = {};
-  if (jsonSchema.properties) {
-    for (const [key, property] of Object.entries(jsonSchema.properties)) {
-      const propSchema = property;
-      let zodType;
-      switch (propSchema.type) {
-        case "string":
-          zodType = z.string();
-          break;
-        case "number":
-          zodType = z.number();
-          break;
-        case "integer":
-          zodType = z.number().int();
-          break;
-        case "boolean":
-          zodType = z.boolean();
-          break;
-        case "array":
-          if (propSchema.items) {
-            const itemType = getZodTypeFromProperty(propSchema.items);
-            zodType = z.array(itemType);
-          } else {
-            zodType = z.array(z.any());
-          }
-          break;
-        case "object":
-          zodType = z.object(jsonSchemaToZodShape(propSchema));
-          break;
-        default:
-          zodType = z.any();
-      }
-      if (propSchema.description) {
-        zodType._def.description = propSchema.description;
-        zodType = zodType.describe(propSchema.description);
-      }
-      if (!jsonSchema.required || !jsonSchema.required.includes(key)) {
-        zodType = zodType.optional();
-      }
-      shape[key] = zodType;
+  const properties = jsonSchema.properties ?? {};
+  for (const [key, property] of Object.entries(properties)) {
+    const propSchema = getPropertySchema(property);
+    let zodType = propSchema ? getZodTypeFromProperty(propSchema) : z.unknown();
+    if (!Array.isArray(jsonSchema.required) || !jsonSchema.required.includes(key)) {
+      zodType = zodType.optional();
     }
+    shape[key] = zodType;
   }
   return shape;
 }
 function getZodTypeFromProperty(propSchema) {
+  const nonNullTypes = getJsonSchemaTypes(propSchema).filter(
+    (type) => type !== "null"
+  );
   let zodType;
-  switch (propSchema.type) {
-    case "string":
-      zodType = z.string();
-      break;
-    case "number":
-      zodType = z.number();
-      break;
-    case "integer":
-      zodType = z.number().int();
-      break;
-    case "boolean":
-      zodType = z.boolean();
-      break;
-    case "object":
-      zodType = z.object(jsonSchemaToZodShape(propSchema));
-      break;
-    case "array":
-      if (propSchema.items) {
-        zodType = z.array(getZodTypeFromProperty(propSchema.items));
-      } else {
-        zodType = z.array(z.any());
-      }
-      break;
-    default:
-      zodType = z.any();
+  if (nonNullTypes.length === 0) {
+    zodType = hasNullableJsonSchemaType(propSchema) ? z.null() : z.unknown();
+  } else {
+    const zodTypes = nonNullTypes.map((type) => getZodTypeForJsonSchemaType(propSchema, type));
+    const [firstType, secondType, ...restTypes] = zodTypes;
+    if (!firstType) {
+      zodType = z.unknown();
+    } else {
+      zodType = secondType ? z.union([firstType, secondType, ...restTypes]) : firstType;
+    }
+  }
+  if (hasNullableJsonSchemaType(propSchema) && nonNullTypes.length > 0) {
+    zodType = zodType.nullable();
   }
   if (propSchema.description) {
-    zodType._def.description = propSchema.description;
     zodType = zodType.describe(propSchema.description);
   }
   return zodType;