ai-resilience 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # ai-resilience
 
-`ai-resilience` is an axios-retry++ foundation for modern AI and backend systems. It keeps axios compatibility while adding configurable retry strategies, advanced jitter, retry conditions, hooks, structured logging, and strong TypeScript types.
+`ai-resilience` is an axios-retry++ toolkit for modern AI and backend systems. It keeps axios compatibility while adding configurable retry strategies, advanced jitter, semantic recovery, JSON validation and repair, hooks, structured logging, and strong TypeScript types.
 
 ## Install
 
@@ -12,7 +12,8 @@ npm install ai-resilience axios axios-retry
 
 ```ts
 import axios from "axios";
-import { applyAiResilience, ConsoleRetryLogger } from "ai-resilience";
+import { applyAiResilience, ConsoleRetryLogger, requestWithSemanticRetry } from "ai-resilience";
+import { z } from "zod";
 
 const client = axios.create({ baseURL: "https://api.example.com" });
 
@@ -29,6 +30,13 @@ applyAiResilience(client, {
     },
   },
 });
+
+const result = await requestWithSemanticRetry(client, {
+  request: { method: "post", url: "/chat/completions", data: { prompt: "Return JSON" } },
+  schema: z.object({ answer: z.string() }),
+  repairJson: true,
+  requireJson: true,
+});
 ```
 
 ## Features
@@ -40,6 +48,10 @@ applyAiResilience(client, {
 - Async custom retry conditions
 - EventEmitter-based hooks plus direct hook callbacks
 - Structured logger interface and console logger
+- Semantic retry for valid HTTP responses with invalid AI payloads
+- JSON validation, Zod schema validation, and JSON repair
+- AI-aware failure detection for empty responses, refusals, truncation, and schema mismatches
+- AI retry policies and semantic lifecycle hooks
 - TypeScript-first public API
 
 ## API
@@ -52,6 +64,42 @@ Installs retry behavior on an existing axios instance and returns `{ axios, hook
 
 Creates a new axios instance with retry behavior already applied.
 
+### `requestWithSemanticRetry(instance, config)`
+
+Runs an axios request and retries when the response is semantically invalid, such as malformed JSON, a schema mismatch, an empty body, a refusal, or a truncated answer.
+
+```ts
+import { requestWithSemanticRetry } from "ai-resilience";
+import { z } from "zod";
+
+const data = await requestWithSemanticRetry(client, {
+  request: { url: "/generate", method: "post", data: { prompt } },
+  schema: z.object({
+    title: z.string(),
+    tags: z.array(z.string()),
+  }),
+  repairJson: true,
+  requireJson: true,
+  hooks: {
+    onSemanticRetry: ({ issue, attempt }) => {
+      console.log(`semantic retry ${attempt}: ${issue.kind}`);
+    },
+  },
+});
+```
+
+### `semanticRetry(operation, policy)`
+
+Wraps any async operation that returns either an axios response or raw data and retries until the payload passes semantic validation.
+
+### `parseJsonResponse(data, options)`
+
+Parses JSON strings, optionally repairs common model-output issues, and validates against a Zod schema.
+
+### `applySemanticRecovery(instance, policy)`
+
+Installs a response interceptor that validates and repairs successful axios responses. Use `requestWithSemanticRetry` when you also want semantic retries.
+
 ### Retry config
 
 ```ts
@@ -70,6 +118,26 @@ type AiResilienceRetryConfig = {
 };
 ```
 
+### Semantic policy
+
+```ts
+type AiRetryPolicy = {
+  maxSemanticRetries?: number;
+  retryOnFailureKinds?: Array<
+    "invalid_json" | "schema_mismatch" | "empty_response" | "refusal" | "truncated"
+  >;
+  repairJson?: boolean;
+  requireJson?: boolean;
+  detectRefusals?: boolean;
+  detectTruncation?: boolean;
+  schema?: z.ZodType;
+  validate?: (data, response) => SemanticValidationResult | Promise<SemanticValidationResult>;
+  hooks?: SemanticRetryHooks;
+  logger?: RetryLogger;
+  metadata?: Record<string, unknown>;
+};
+```
+
 ## Scripts
 
 ```sh

package/dist/index.cjs

@@ -32,18 +32,33 @@ var index_exports = {};
 __export(index_exports, {
   ConsoleRetryLogger: () => ConsoleRetryLogger,
   RetryHookEmitter: () => RetryHookEmitter,
+  SemanticRetryError: () => SemanticRetryError,
+  aiRetryPolicies: () => aiRetryPolicies,
   applyAiResilience: () => applyAiResilience,
   applyJitter: () => applyJitter,
+  applySemanticRecovery: () => applySemanticRecovery,
   calculateRetryDelay: () => calculateRetryDelay,
+  classifyAiFailure: () => classifyAiFailure,
   createAiResilienceClient: () => createAiResilienceClient,
   createLogEntry: () => createLogEntry,
+  createSemanticRetryCondition: () => createSemanticRetryCondition,
   defaultRetryConfig: () => defaultRetryConfig,
+  detectAiFailureSignals: () => detectAiFailureSignals,
   isRetryableMethod: () => isRetryableMethod,
   isRetryableStatus: () => isRetryableStatus,
+  normalizeAiRetryPolicy: () => normalizeAiRetryPolicy,
   normalizeRetryConfig: () => normalizeRetryConfig,
+  parseJsonResponse: () => parseJsonResponse,
+  repairJsonString: () => repairJsonString,
+  requestWithSemanticRetry: () => requestWithSemanticRetry,
+  resolveAiRetryPolicy: () => resolveAiRetryPolicy,
   resolveRetryStrategy: () => resolveRetryStrategy,
   retryStrategies: () => retryStrategies,
-  shouldRetry: () => shouldRetry
+  semanticRetry: () => semanticRetry,
+  shouldRetry: () => shouldRetry,
+  shouldSemanticRetry: () => shouldSemanticRetry,
+  validateSchema: () => validateSchema,
+  validateSemanticResponse: () => validateSemanticResponse
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -307,20 +322,405 @@ var retryStrategies = {
 function resolveRetryStrategy(strategy) {
   return typeof strategy === "string" ? retryStrategies[strategy] : strategy;
 }
+
+// src/ai-policies.ts
+var aiRetryPolicies = {
+  strictJson: {
+    maxSemanticRetries: 2,
+    retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "truncated"],
+    repairJson: true,
+    requireJson: true,
+    detectRefusals: true,
+    detectTruncation: true
+  },
+  toolCall: {
+    maxSemanticRetries: 3,
+    retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "refusal", "truncated"],
+    repairJson: true,
+    requireJson: true,
+    detectRefusals: true,
+    detectTruncation: true
+  },
+  permissive: {
+    maxSemanticRetries: 1,
+    retryOnFailureKinds: ["invalid_json", "empty_response"],
+    repairJson: true,
+    requireJson: false,
+    detectRefusals: false,
+    detectTruncation: true
+  }
+};
+function resolveAiRetryPolicy(policy) {
+  return typeof policy === "string" ? aiRetryPolicies[policy] : policy;
+}
+function shouldSemanticRetry(issue, policy = {}) {
+  const retryKinds = policy.retryOnFailureKinds ?? aiRetryPolicies.strictJson.retryOnFailureKinds;
+  return retryKinds.includes(issue.kind);
+}
+function createSemanticRetryCondition(policy = {}) {
+  return (issue) => shouldSemanticRetry(issue, policy);
+}
+function classifyAiFailure(error) {
+  if (error.name === "SemanticRetryError") {
+    return error.result.issues[0]?.kind ?? "unknown";
+  }
+  if (!error.response) {
+    return "network";
+  }
+  if (error.response.status === 429) {
+    return "rate_limit";
+  }
+  if (error.response.status >= 500) {
+    return "server_error";
+  }
+  return "unknown";
+}
+
+// src/repair.ts
+function repairJsonString(input) {
+  const candidates = buildCandidates(input);
+  const issues = [];
+  for (const candidate of candidates) {
+    try {
+      return {
+        ok: true,
+        value: JSON.parse(candidate),
+        repairedText: candidate,
+        issues
+      };
+    } catch (error) {
+      issues.push({
+        kind: "invalid_json",
+        message: error instanceof Error ? error.message : "Invalid JSON",
+        cause: error
+      });
+    }
+  }
+  return {
+    ok: false,
+    issues: issues.length ? issues : [
+      {
+        kind: "invalid_json",
+        message: "Unable to repair JSON response"
+      }
+    ]
+  };
+}
+function buildCandidates(input) {
+  const trimmed = stripMarkdownFence(input.trim());
+  const extracted = extractJsonCandidate(trimmed);
+  const normalized = normalizeCommonJsonIssues(extracted);
+  const balanced = balanceJson(normalized);
+  return Array.from(new Set([trimmed, extracted, normalized, balanced].filter(Boolean)));
+}
+function stripMarkdownFence(input) {
+  const fenceMatch = input.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return fenceMatch?.[1]?.trim() ?? input;
+}
+function extractJsonCandidate(input) {
+  const firstObject = input.indexOf("{");
+  const firstArray = input.indexOf("[");
+  const starts = [firstObject, firstArray].filter((index) => index >= 0);
+  if (!starts.length) {
+    return input;
+  }
+  const start = Math.min(...starts);
+  const lastObject = input.lastIndexOf("}");
+  const lastArray = input.lastIndexOf("]");
+  const end = Math.max(lastObject, lastArray);
+  return end > start ? input.slice(start, end + 1).trim() : input.slice(start).trim();
+}
+function normalizeCommonJsonIssues(input) {
+  return input.replace(/[\u201C\u201D]/g, '"').replace(/[\u2018\u2019]/g, "'").replace(/,\s*([}\]])/g, "$1");
+}
+function balanceJson(input) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (const char of input) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") stack.push("}");
+    if (char === "[") stack.push("]");
+    if ((char === "}" || char === "]") && stack.at(-1) === char) stack.pop();
+  }
+  return input + stack.reverse().join("");
+}
+
+// src/json-validation.ts
+function parseJsonResponse(input, options = {}) {
+  const issues = [];
+  let data = input;
+  let repaired = false;
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return {
+        ok: false,
+        issues: [{ kind: "empty_response", message: "Response body is empty" }],
+        raw: input
+      };
+    }
+    try {
+      data = JSON.parse(trimmed);
+    } catch (error) {
+      if (!options.repair) {
+        return {
+          ok: false,
+          issues: [
+            {
+              kind: "invalid_json",
+              message: error instanceof Error ? error.message : "Invalid JSON",
+              cause: error
+            }
+          ],
+          raw: input
+        };
+      }
+      const repairedResult = repairJsonString(trimmed);
+      if (!repairedResult.ok) {
+        return {
+          ok: false,
+          issues: repairedResult.issues,
+          raw: input
+        };
+      }
+      data = repairedResult.value;
+      repaired = repairedResult.repairedText !== trimmed;
+    }
+  } else if (options.requireJson && (input === null || typeof input !== "object")) {
+    issues.push({
+      kind: "invalid_json",
+      message: "Response data is not a JSON object or array"
+    });
+  }
+  if (issues.length) {
+    return { ok: false, issues, raw: input };
+  }
+  if (!options.schema) {
+    return {
+      ok: true,
+      data,
+      issues: [],
+      repaired,
+      raw: input
+    };
+  }
+  return validateSchema(data, options.schema, { repaired, raw: input });
+}
+function validateSchema(data, schema, metadata = {}) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) {
+    return {
+      ok: true,
+      data: parsed.data,
+      issues: [],
+      ...metadata
+    };
+  }
+  return {
+    ok: false,
+    issues: parsed.error.issues.map((issue) => ({
+      kind: "schema_mismatch",
+      message: issue.message,
+      path: issue.path,
+      cause: issue
+    })),
+    ...metadata
+  };
+}
+async function validateSemanticResponse(data, policy = {}, response) {
+  const parsed = parseJsonResponse(data, {
+    schema: policy.schema,
+    repair: policy.repairJson,
+    requireJson: policy.requireJson
+  });
+  if (!parsed.ok) {
+    return parsed;
+  }
+  const intelligenceIssues = detectAiFailureSignals(parsed.data, policy);
+  if (intelligenceIssues.length) {
+    return {
+      ...parsed,
+      ok: false,
+      issues: intelligenceIssues
+    };
+  }
+  if (policy.validate) {
+    return policy.validate(parsed.data, response);
+  }
+  return parsed;
+}
+function detectAiFailureSignals(data, policy = {}) {
+  const text = typeof data === "string" ? data : JSON.stringify(data ?? "");
+  const issues = [];
+  if (policy.detectRefusals !== false && /\b(i can't|i cannot|unable to comply|cannot assist|as an ai)\b/i.test(text)) {
+    issues.push({
+      kind: "refusal",
+      message: "Response appears to be an AI refusal instead of the requested payload"
+    });
+  }
+  if (policy.detectTruncation !== false && /\b(truncated|continues?|unfinished|cut off)\b/i.test(text)) {
+    issues.push({
+      kind: "truncated",
+      message: "Response appears to be incomplete or truncated"
+    });
+  }
+  return issues;
+}
+
+// src/semantic-types.ts
+var SemanticRetryError = class extends Error {
+  constructor(message, result, response) {
+    super(message);
+    this.result = result;
+    this.response = response;
+  }
+  result;
+  response;
+  name = "SemanticRetryError";
+};
+
+// src/semantic.ts
+function normalizeAiRetryPolicy(policy = {}) {
+  return {
+    ...aiRetryPolicies.strictJson,
+    ...policy
+  };
+}
+async function semanticRetry(operation, policy = {}) {
+  const resolved = normalizeAiRetryPolicy(policy);
+  let lastResult;
+  let lastResponse;
+  let previousDelayMs;
+  for (let attempt = 0; attempt <= resolved.maxSemanticRetries; attempt += 1) {
+    const value = await operation();
+    const response = isAxiosResponse(value) ? value : void 0;
+    const data = response ? response.data : value;
+    const finalResult = await validateSemanticResponse(data, resolved, response);
+    lastResult = finalResult;
+    lastResponse = response;
+    if (finalResult.ok) {
+      await resolved.hooks?.onSemanticRecovery?.({ result: finalResult, response });
+      return finalResult.data;
+    }
+    const issue = finalResult.issues[0] ?? {
+      kind: "unknown",
+      message: "Semantic validation failed"
+    };
+    if (attempt >= resolved.maxSemanticRetries || !shouldSemanticRetry(issue, resolved)) {
+      await resolved.hooks?.onSemanticGiveUp?.({
+        attempts: attempt + 1,
+        result: finalResult,
+        response
+      });
+      break;
+    }
+    const nextDelayMs = calculateRetryDelay(
+      {
+        retries: resolved.maxSemanticRetries,
+        strategy: "exponential",
+        baseDelayMs: 100,
+        maxDelayMs: 3e3,
+        jitter: "full"
+      },
+      { attempt: attempt + 1, previousDelayMs }
+    );
+    previousDelayMs = nextDelayMs;
+    await resolved.hooks?.onSemanticRetry?.({
+      attempt: attempt + 1,
+      maxRetries: resolved.maxSemanticRetries,
+      issue,
+      result: finalResult,
+      response,
+      nextDelayMs
+    });
+    resolved.logger?.log(
+      createLogEntry("warn", "semantic.retry", "Semantic retry scheduled", {
+        attempt: attempt + 1,
+        maxRetries: resolved.maxSemanticRetries,
+        delayMs: nextDelayMs,
+        issue: issue.kind,
+        ...resolved.metadata
+      })
+    );
+    await sleep(nextDelayMs);
+  }
+  throw new SemanticRetryError("Semantic retry attempts exhausted", lastResult ?? emptyFailure(), lastResponse);
+}
+async function requestWithSemanticRetry(instance, config) {
+  return semanticRetry(() => instance.request(config.request), config);
+}
+function applySemanticRecovery(instance, policy = {}) {
+  const resolved = normalizeAiRetryPolicy(policy);
+  instance.interceptors.response.use(async (response) => {
+    const finalResult = await validateSemanticResponse(response.data, resolved, response);
+    if (!finalResult.ok) {
+      throw new SemanticRetryError("Semantic response validation failed", finalResult, response);
+    }
+    response.data = finalResult.data;
+    await resolved.hooks?.onSemanticRecovery?.({ result: finalResult, response });
+    return response;
+  });
+  return {
+    axios: instance,
+    policy: resolved
+  };
+}
+function isAxiosResponse(value) {
+  return Boolean(value && typeof value === "object" && "status" in value && "headers" in value && "config" in value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function emptyFailure() {
+  return {
+    ok: false,
+    issues: [{ kind: "unknown", message: "Semantic validation failed before a response was captured" }]
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConsoleRetryLogger,
   RetryHookEmitter,
+  SemanticRetryError,
+  aiRetryPolicies,
   applyAiResilience,
   applyJitter,
+  applySemanticRecovery,
   calculateRetryDelay,
+  classifyAiFailure,
   createAiResilienceClient,
   createLogEntry,
+  createSemanticRetryCondition,
   defaultRetryConfig,
+  detectAiFailureSignals,
   isRetryableMethod,
   isRetryableStatus,
+  normalizeAiRetryPolicy,
   normalizeRetryConfig,
+  parseJsonResponse,
+  repairJsonString,
+  requestWithSemanticRetry,
+  resolveAiRetryPolicy,
   resolveRetryStrategy,
   retryStrategies,
-  shouldRetry
+  semanticRetry,
+  shouldRetry,
+  shouldSemanticRetry,
+  validateSchema,
+  validateSemanticResponse
 });

package/dist/index.d.cts

@@ -1,6 +1,9 @@
+import * as axios from 'axios';
 import { AxiosInstance, AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 import EventEmitter from 'eventemitter3';
 import { IAxiosRetryConfig } from 'axios-retry';
+import * as zod from 'zod';
+import { z } from 'zod';
 
 type RetryHookEvents<T = unknown> = {
     retry: (context: RetryAttemptContext<T>) => void;
@@ -141,4 +144,135 @@ declare const retryStrategies: {
 type NamedRetryStrategy = keyof typeof retryStrategies;
 declare function resolveRetryStrategy(strategy: NamedRetryStrategy | AiResilienceRetryConfig): AiResilienceRetryConfig;
 
-export { type AiResilienceClient, type AiResilienceRetryConfig, ConsoleRetryLogger, type JitterStrategy, type LogLevel, type RetryAttemptContext, type RetryGiveUpContext, RetryHookEmitter, type RetryHooks, type RetryLogger, type RetryStrategy, type RetrySuccessContext, type StructuredLogEntry, applyAiResilience, applyJitter, calculateRetryDelay, createAiResilienceClient, createLogEntry, defaultRetryConfig, isRetryableMethod, isRetryableStatus, normalizeRetryConfig, resolveRetryStrategy, retryStrategies, shouldRetry };
+type AiFailureKind = "invalid_json" | "schema_mismatch" | "empty_response" | "refusal" | "truncated" | "rate_limit" | "server_error" | "network" | "unknown";
+interface SemanticValidationIssue {
+    kind: AiFailureKind;
+    message: string;
+    path?: Array<string | number>;
+    cause?: unknown;
+}
+interface SemanticValidationResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    issues: SemanticValidationIssue[];
+    repaired?: boolean;
+    raw?: unknown;
+}
+interface JsonRepairResult {
+    ok: boolean;
+    value?: unknown;
+    repairedText?: string;
+    issues: SemanticValidationIssue[];
+}
+interface SemanticRetryContext<T = unknown> {
+    attempt: number;
+    maxRetries: number;
+    issue: SemanticValidationIssue;
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+    nextDelayMs: number;
+}
+interface SemanticRecoveryContext<T = unknown> {
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+}
+interface SemanticGiveUpContext<T = unknown> {
+    attempts: number;
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+}
+interface SemanticRetryHooks<T = unknown> {
+    onSemanticRetry?: (context: SemanticRetryContext<T>) => void | Promise<void>;
+    onSemanticRecovery?: (context: SemanticRecoveryContext<T>) => void | Promise<void>;
+    onSemanticGiveUp?: (context: SemanticGiveUpContext<T>) => void | Promise<void>;
+}
+interface AiRetryPolicy<T = unknown> {
+    maxSemanticRetries?: number;
+    retryOnFailureKinds?: AiFailureKind[];
+    repairJson?: boolean;
+    requireJson?: boolean;
+    detectRefusals?: boolean;
+    detectTruncation?: boolean;
+    schema?: z.ZodType<T>;
+    validate?: (data: unknown, response?: AxiosResponse) => SemanticValidationResult<T> | Promise<SemanticValidationResult<T>>;
+    hooks?: SemanticRetryHooks<T>;
+    logger?: RetryLogger;
+    metadata?: Record<string, unknown>;
+}
+interface SemanticRequestConfig<T = unknown> extends AiRetryPolicy<T> {
+    request: AxiosRequestConfig;
+}
+interface SemanticResilienceClient<T = unknown> {
+    axios: AxiosInstance;
+    policy: Required<Pick<AiRetryPolicy<T>, "maxSemanticRetries" | "retryOnFailureKinds" | "repairJson" | "requireJson" | "detectRefusals" | "detectTruncation">> & AiRetryPolicy<T>;
+}
+declare class SemanticRetryError<T = unknown> extends Error {
+    readonly result: SemanticValidationResult<T>;
+    readonly response?: AxiosResponse | undefined;
+    readonly name = "SemanticRetryError";
+    constructor(message: string, result: SemanticValidationResult<T>, response?: AxiosResponse | undefined);
+}
+type SemanticRetryCondition<T = unknown> = (issue: SemanticValidationIssue, error?: AxiosError | SemanticRetryError<T>) => boolean;
+
+declare const aiRetryPolicies: {
+    readonly strictJson: {
+        readonly maxSemanticRetries: 2;
+        readonly retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "truncated"];
+        readonly repairJson: true;
+        readonly requireJson: true;
+        readonly detectRefusals: true;
+        readonly detectTruncation: true;
+    };
+    readonly toolCall: {
+        readonly maxSemanticRetries: 3;
+        readonly retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "refusal", "truncated"];
+        readonly repairJson: true;
+        readonly requireJson: true;
+        readonly detectRefusals: true;
+        readonly detectTruncation: true;
+    };
+    readonly permissive: {
+        readonly maxSemanticRetries: 1;
+        readonly retryOnFailureKinds: ["invalid_json", "empty_response"];
+        readonly repairJson: true;
+        readonly requireJson: false;
+        readonly detectRefusals: false;
+        readonly detectTruncation: true;
+    };
+};
+type NamedAiRetryPolicy = keyof typeof aiRetryPolicies;
+declare function resolveAiRetryPolicy<T = unknown>(policy: NamedAiRetryPolicy | AiRetryPolicy<T>): AiRetryPolicy<T>;
+declare function shouldSemanticRetry<T = unknown>(issue: SemanticValidationIssue, policy?: AiRetryPolicy<T>): boolean;
+declare function createSemanticRetryCondition<T = unknown>(policy?: AiRetryPolicy<T>): SemanticRetryCondition<T>;
+declare function classifyAiFailure(error: AxiosError | SemanticRetryError): AiFailureKind;
+
+interface JsonValidationOptions<T = unknown> {
+    schema?: z.ZodType<T>;
+    repair?: boolean;
+    requireJson?: boolean;
+}
+declare function parseJsonResponse<T = unknown>(input: unknown, options?: JsonValidationOptions<T>): SemanticValidationResult<T>;
+declare function validateSchema<T>(data: unknown, schema: z.ZodType<T>, metadata?: Pick<SemanticValidationResult<T>, "repaired" | "raw">): SemanticValidationResult<T>;
+declare function validateSemanticResponse<T = unknown>(data: unknown, policy?: AiRetryPolicy<T>, response?: axios.AxiosResponse): Promise<SemanticValidationResult<T>>;
+declare function detectAiFailureSignals<T = unknown>(data: T | undefined, policy?: Pick<AiRetryPolicy<T>, "detectRefusals" | "detectTruncation">): SemanticValidationIssue[];
+
+declare function repairJsonString(input: string): JsonRepairResult;
+
+declare function normalizeAiRetryPolicy<T = unknown>(policy?: AiRetryPolicy<T>): {
+    maxSemanticRetries: number;
+    retryOnFailureKinds: AiFailureKind[];
+    repairJson: boolean;
+    requireJson: boolean;
+    detectRefusals: boolean;
+    detectTruncation: boolean;
+    schema?: zod.ZodType<T, zod.ZodTypeDef, T> | undefined;
+    validate?: ((data: unknown, response?: AxiosResponse) => SemanticValidationResult<T> | Promise<SemanticValidationResult<T>>) | undefined;
+    hooks?: SemanticRetryHooks<T> | undefined;
+    logger?: RetryLogger;
+    metadata?: Record<string, unknown>;
+};
+declare function semanticRetry<T = unknown>(operation: () => Promise<AxiosResponse | T>, policy?: AiRetryPolicy<T>): Promise<T>;
+declare function requestWithSemanticRetry<T = unknown>(instance: AxiosInstance, config: SemanticRequestConfig<T>): Promise<T>;
+declare function applySemanticRecovery<T = unknown>(instance: AxiosInstance, policy?: AiRetryPolicy<T>): SemanticResilienceClient<T>;
+
+export { type AiFailureKind, type AiResilienceClient, type AiResilienceRetryConfig, type AiRetryPolicy, ConsoleRetryLogger, type JitterStrategy, type JsonRepairResult, type LogLevel, type NamedAiRetryPolicy, type RetryAttemptContext, type RetryGiveUpContext, RetryHookEmitter, type RetryHooks, type RetryLogger, type RetryStrategy, type RetrySuccessContext, type SemanticGiveUpContext, type SemanticRecoveryContext, type SemanticRequestConfig, type SemanticResilienceClient, type SemanticRetryCondition, type SemanticRetryContext, SemanticRetryError, type SemanticRetryHooks, type SemanticValidationIssue, type SemanticValidationResult, type StructuredLogEntry, aiRetryPolicies, applyAiResilience, applyJitter, applySemanticRecovery, calculateRetryDelay, classifyAiFailure, createAiResilienceClient, createLogEntry, createSemanticRetryCondition, defaultRetryConfig, detectAiFailureSignals, isRetryableMethod, isRetryableStatus, normalizeAiRetryPolicy, normalizeRetryConfig, parseJsonResponse, repairJsonString, requestWithSemanticRetry, resolveAiRetryPolicy, resolveRetryStrategy, retryStrategies, semanticRetry, shouldRetry, shouldSemanticRetry, validateSchema, validateSemanticResponse };

package/dist/index.d.ts

@@ -1,6 +1,9 @@
+import * as axios from 'axios';
 import { AxiosInstance, AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 import EventEmitter from 'eventemitter3';
 import { IAxiosRetryConfig } from 'axios-retry';
+import * as zod from 'zod';
+import { z } from 'zod';
 
 type RetryHookEvents<T = unknown> = {
     retry: (context: RetryAttemptContext<T>) => void;
@@ -141,4 +144,135 @@ declare const retryStrategies: {
 type NamedRetryStrategy = keyof typeof retryStrategies;
 declare function resolveRetryStrategy(strategy: NamedRetryStrategy | AiResilienceRetryConfig): AiResilienceRetryConfig;
 
-export { type AiResilienceClient, type AiResilienceRetryConfig, ConsoleRetryLogger, type JitterStrategy, type LogLevel, type RetryAttemptContext, type RetryGiveUpContext, RetryHookEmitter, type RetryHooks, type RetryLogger, type RetryStrategy, type RetrySuccessContext, type StructuredLogEntry, applyAiResilience, applyJitter, calculateRetryDelay, createAiResilienceClient, createLogEntry, defaultRetryConfig, isRetryableMethod, isRetryableStatus, normalizeRetryConfig, resolveRetryStrategy, retryStrategies, shouldRetry };
+type AiFailureKind = "invalid_json" | "schema_mismatch" | "empty_response" | "refusal" | "truncated" | "rate_limit" | "server_error" | "network" | "unknown";
+interface SemanticValidationIssue {
+    kind: AiFailureKind;
+    message: string;
+    path?: Array<string | number>;
+    cause?: unknown;
+}
+interface SemanticValidationResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    issues: SemanticValidationIssue[];
+    repaired?: boolean;
+    raw?: unknown;
+}
+interface JsonRepairResult {
+    ok: boolean;
+    value?: unknown;
+    repairedText?: string;
+    issues: SemanticValidationIssue[];
+}
+interface SemanticRetryContext<T = unknown> {
+    attempt: number;
+    maxRetries: number;
+    issue: SemanticValidationIssue;
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+    nextDelayMs: number;
+}
+interface SemanticRecoveryContext<T = unknown> {
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+}
+interface SemanticGiveUpContext<T = unknown> {
+    attempts: number;
+    result: SemanticValidationResult<T>;
+    response?: AxiosResponse;
+}
+interface SemanticRetryHooks<T = unknown> {
+    onSemanticRetry?: (context: SemanticRetryContext<T>) => void | Promise<void>;
+    onSemanticRecovery?: (context: SemanticRecoveryContext<T>) => void | Promise<void>;
+    onSemanticGiveUp?: (context: SemanticGiveUpContext<T>) => void | Promise<void>;
+}
+interface AiRetryPolicy<T = unknown> {
+    maxSemanticRetries?: number;
+    retryOnFailureKinds?: AiFailureKind[];
+    repairJson?: boolean;
+    requireJson?: boolean;
+    detectRefusals?: boolean;
+    detectTruncation?: boolean;
+    schema?: z.ZodType<T>;
+    validate?: (data: unknown, response?: AxiosResponse) => SemanticValidationResult<T> | Promise<SemanticValidationResult<T>>;
+    hooks?: SemanticRetryHooks<T>;
+    logger?: RetryLogger;
+    metadata?: Record<string, unknown>;
+}
+interface SemanticRequestConfig<T = unknown> extends AiRetryPolicy<T> {
+    request: AxiosRequestConfig;
+}
+interface SemanticResilienceClient<T = unknown> {
+    axios: AxiosInstance;
+    policy: Required<Pick<AiRetryPolicy<T>, "maxSemanticRetries" | "retryOnFailureKinds" | "repairJson" | "requireJson" | "detectRefusals" | "detectTruncation">> & AiRetryPolicy<T>;
+}
+declare class SemanticRetryError<T = unknown> extends Error {
+    readonly result: SemanticValidationResult<T>;
+    readonly response?: AxiosResponse | undefined;
+    readonly name = "SemanticRetryError";
+    constructor(message: string, result: SemanticValidationResult<T>, response?: AxiosResponse | undefined);
+}
+type SemanticRetryCondition<T = unknown> = (issue: SemanticValidationIssue, error?: AxiosError | SemanticRetryError<T>) => boolean;
+
+declare const aiRetryPolicies: {
+    readonly strictJson: {
+        readonly maxSemanticRetries: 2;
+        readonly retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "truncated"];
+        readonly repairJson: true;
+        readonly requireJson: true;
+        readonly detectRefusals: true;
+        readonly detectTruncation: true;
+    };
+    readonly toolCall: {
+        readonly maxSemanticRetries: 3;
+        readonly retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "refusal", "truncated"];
+        readonly repairJson: true;
+        readonly requireJson: true;
+        readonly detectRefusals: true;
+        readonly detectTruncation: true;
+    };
+    readonly permissive: {
+        readonly maxSemanticRetries: 1;
+        readonly retryOnFailureKinds: ["invalid_json", "empty_response"];
+        readonly repairJson: true;
+        readonly requireJson: false;
+        readonly detectRefusals: false;
+        readonly detectTruncation: true;
+    };
+};
+type NamedAiRetryPolicy = keyof typeof aiRetryPolicies;
+declare function resolveAiRetryPolicy<T = unknown>(policy: NamedAiRetryPolicy | AiRetryPolicy<T>): AiRetryPolicy<T>;
+declare function shouldSemanticRetry<T = unknown>(issue: SemanticValidationIssue, policy?: AiRetryPolicy<T>): boolean;
+declare function createSemanticRetryCondition<T = unknown>(policy?: AiRetryPolicy<T>): SemanticRetryCondition<T>;
+declare function classifyAiFailure(error: AxiosError | SemanticRetryError): AiFailureKind;
+
+interface JsonValidationOptions<T = unknown> {
+    schema?: z.ZodType<T>;
+    repair?: boolean;
+    requireJson?: boolean;
+}
+declare function parseJsonResponse<T = unknown>(input: unknown, options?: JsonValidationOptions<T>): SemanticValidationResult<T>;
+declare function validateSchema<T>(data: unknown, schema: z.ZodType<T>, metadata?: Pick<SemanticValidationResult<T>, "repaired" | "raw">): SemanticValidationResult<T>;
+declare function validateSemanticResponse<T = unknown>(data: unknown, policy?: AiRetryPolicy<T>, response?: axios.AxiosResponse): Promise<SemanticValidationResult<T>>;
+declare function detectAiFailureSignals<T = unknown>(data: T | undefined, policy?: Pick<AiRetryPolicy<T>, "detectRefusals" | "detectTruncation">): SemanticValidationIssue[];
+
+declare function repairJsonString(input: string): JsonRepairResult;
+
+declare function normalizeAiRetryPolicy<T = unknown>(policy?: AiRetryPolicy<T>): {
+    maxSemanticRetries: number;
+    retryOnFailureKinds: AiFailureKind[];
+    repairJson: boolean;
+    requireJson: boolean;
+    detectRefusals: boolean;
+    detectTruncation: boolean;
+    schema?: zod.ZodType<T, zod.ZodTypeDef, T> | undefined;
+    validate?: ((data: unknown, response?: AxiosResponse) => SemanticValidationResult<T> | Promise<SemanticValidationResult<T>>) | undefined;
+    hooks?: SemanticRetryHooks<T> | undefined;
+    logger?: RetryLogger;
+    metadata?: Record<string, unknown>;
+};
+declare function semanticRetry<T = unknown>(operation: () => Promise<AxiosResponse | T>, policy?: AiRetryPolicy<T>): Promise<T>;
+declare function requestWithSemanticRetry<T = unknown>(instance: AxiosInstance, config: SemanticRequestConfig<T>): Promise<T>;
+declare function applySemanticRecovery<T = unknown>(instance: AxiosInstance, policy?: AiRetryPolicy<T>): SemanticResilienceClient<T>;
+
+export { type AiFailureKind, type AiResilienceClient, type AiResilienceRetryConfig, type AiRetryPolicy, ConsoleRetryLogger, type JitterStrategy, type JsonRepairResult, type LogLevel, type NamedAiRetryPolicy, type RetryAttemptContext, type RetryGiveUpContext, RetryHookEmitter, type RetryHooks, type RetryLogger, type RetryStrategy, type RetrySuccessContext, type SemanticGiveUpContext, type SemanticRecoveryContext, type SemanticRequestConfig, type SemanticResilienceClient, type SemanticRetryCondition, type SemanticRetryContext, SemanticRetryError, type SemanticRetryHooks, type SemanticValidationIssue, type SemanticValidationResult, type StructuredLogEntry, aiRetryPolicies, applyAiResilience, applyJitter, applySemanticRecovery, calculateRetryDelay, classifyAiFailure, createAiResilienceClient, createLogEntry, createSemanticRetryCondition, defaultRetryConfig, detectAiFailureSignals, isRetryableMethod, isRetryableStatus, normalizeAiRetryPolicy, normalizeRetryConfig, parseJsonResponse, repairJsonString, requestWithSemanticRetry, resolveAiRetryPolicy, resolveRetryStrategy, retryStrategies, semanticRetry, shouldRetry, shouldSemanticRetry, validateSchema, validateSemanticResponse };

package/dist/index.js

@@ -258,19 +258,404 @@ var retryStrategies = {
 function resolveRetryStrategy(strategy) {
   return typeof strategy === "string" ? retryStrategies[strategy] : strategy;
 }
+
+// src/ai-policies.ts
+var aiRetryPolicies = {
+  strictJson: {
+    maxSemanticRetries: 2,
+    retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "truncated"],
+    repairJson: true,
+    requireJson: true,
+    detectRefusals: true,
+    detectTruncation: true
+  },
+  toolCall: {
+    maxSemanticRetries: 3,
+    retryOnFailureKinds: ["invalid_json", "schema_mismatch", "empty_response", "refusal", "truncated"],
+    repairJson: true,
+    requireJson: true,
+    detectRefusals: true,
+    detectTruncation: true
+  },
+  permissive: {
+    maxSemanticRetries: 1,
+    retryOnFailureKinds: ["invalid_json", "empty_response"],
+    repairJson: true,
+    requireJson: false,
+    detectRefusals: false,
+    detectTruncation: true
+  }
+};
+function resolveAiRetryPolicy(policy) {
+  return typeof policy === "string" ? aiRetryPolicies[policy] : policy;
+}
+function shouldSemanticRetry(issue, policy = {}) {
+  const retryKinds = policy.retryOnFailureKinds ?? aiRetryPolicies.strictJson.retryOnFailureKinds;
+  return retryKinds.includes(issue.kind);
+}
+function createSemanticRetryCondition(policy = {}) {
+  return (issue) => shouldSemanticRetry(issue, policy);
+}
+function classifyAiFailure(error) {
+  if (error.name === "SemanticRetryError") {
+    return error.result.issues[0]?.kind ?? "unknown";
+  }
+  if (!error.response) {
+    return "network";
+  }
+  if (error.response.status === 429) {
+    return "rate_limit";
+  }
+  if (error.response.status >= 500) {
+    return "server_error";
+  }
+  return "unknown";
+}
+
+// src/repair.ts
+function repairJsonString(input) {
+  const candidates = buildCandidates(input);
+  const issues = [];
+  for (const candidate of candidates) {
+    try {
+      return {
+        ok: true,
+        value: JSON.parse(candidate),
+        repairedText: candidate,
+        issues
+      };
+    } catch (error) {
+      issues.push({
+        kind: "invalid_json",
+        message: error instanceof Error ? error.message : "Invalid JSON",
+        cause: error
+      });
+    }
+  }
+  return {
+    ok: false,
+    issues: issues.length ? issues : [
+      {
+        kind: "invalid_json",
+        message: "Unable to repair JSON response"
+      }
+    ]
+  };
+}
+function buildCandidates(input) {
+  const trimmed = stripMarkdownFence(input.trim());
+  const extracted = extractJsonCandidate(trimmed);
+  const normalized = normalizeCommonJsonIssues(extracted);
+  const balanced = balanceJson(normalized);
+  return Array.from(new Set([trimmed, extracted, normalized, balanced].filter(Boolean)));
+}
+function stripMarkdownFence(input) {
+  const fenceMatch = input.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return fenceMatch?.[1]?.trim() ?? input;
+}
+function extractJsonCandidate(input) {
+  const firstObject = input.indexOf("{");
+  const firstArray = input.indexOf("[");
+  const starts = [firstObject, firstArray].filter((index) => index >= 0);
+  if (!starts.length) {
+    return input;
+  }
+  const start = Math.min(...starts);
+  const lastObject = input.lastIndexOf("}");
+  const lastArray = input.lastIndexOf("]");
+  const end = Math.max(lastObject, lastArray);
+  return end > start ? input.slice(start, end + 1).trim() : input.slice(start).trim();
+}
+function normalizeCommonJsonIssues(input) {
+  return input.replace(/[\u201C\u201D]/g, '"').replace(/[\u2018\u2019]/g, "'").replace(/,\s*([}\]])/g, "$1");
+}
+function balanceJson(input) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (const char of input) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") stack.push("}");
+    if (char === "[") stack.push("]");
+    if ((char === "}" || char === "]") && stack.at(-1) === char) stack.pop();
+  }
+  return input + stack.reverse().join("");
+}
+
+// src/json-validation.ts
+function parseJsonResponse(input, options = {}) {
+  const issues = [];
+  let data = input;
+  let repaired = false;
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return {
+        ok: false,
+        issues: [{ kind: "empty_response", message: "Response body is empty" }],
+        raw: input
+      };
+    }
+    try {
+      data = JSON.parse(trimmed);
+    } catch (error) {
+      if (!options.repair) {
+        return {
+          ok: false,
+          issues: [
+            {
+              kind: "invalid_json",
+              message: error instanceof Error ? error.message : "Invalid JSON",
+              cause: error
+            }
+          ],
+          raw: input
+        };
+      }
+      const repairedResult = repairJsonString(trimmed);
+      if (!repairedResult.ok) {
+        return {
+          ok: false,
+          issues: repairedResult.issues,
+          raw: input
+        };
+      }
+      data = repairedResult.value;
+      repaired = repairedResult.repairedText !== trimmed;
+    }
+  } else if (options.requireJson && (input === null || typeof input !== "object")) {
+    issues.push({
+      kind: "invalid_json",
+      message: "Response data is not a JSON object or array"
+    });
+  }
+  if (issues.length) {
+    return { ok: false, issues, raw: input };
+  }
+  if (!options.schema) {
+    return {
+      ok: true,
+      data,
+      issues: [],
+      repaired,
+      raw: input
+    };
+  }
+  return validateSchema(data, options.schema, { repaired, raw: input });
+}
+function validateSchema(data, schema, metadata = {}) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) {
+    return {
+      ok: true,
+      data: parsed.data,
+      issues: [],
+      ...metadata
+    };
+  }
+  return {
+    ok: false,
+    issues: parsed.error.issues.map((issue) => ({
+      kind: "schema_mismatch",
+      message: issue.message,
+      path: issue.path,
+      cause: issue
+    })),
+    ...metadata
+  };
+}
+async function validateSemanticResponse(data, policy = {}, response) {
+  const parsed = parseJsonResponse(data, {
+    schema: policy.schema,
+    repair: policy.repairJson,
+    requireJson: policy.requireJson
+  });
+  if (!parsed.ok) {
+    return parsed;
+  }
+  const intelligenceIssues = detectAiFailureSignals(parsed.data, policy);
+  if (intelligenceIssues.length) {
+    return {
+      ...parsed,
+      ok: false,
+      issues: intelligenceIssues
+    };
+  }
+  if (policy.validate) {
+    return policy.validate(parsed.data, response);
+  }
+  return parsed;
+}
+function detectAiFailureSignals(data, policy = {}) {
+  const text = typeof data === "string" ? data : JSON.stringify(data ?? "");
+  const issues = [];
+  if (policy.detectRefusals !== false && /\b(i can't|i cannot|unable to comply|cannot assist|as an ai)\b/i.test(text)) {
+    issues.push({
+      kind: "refusal",
+      message: "Response appears to be an AI refusal instead of the requested payload"
+    });
+  }
+  if (policy.detectTruncation !== false && /\b(truncated|continues?|unfinished|cut off)\b/i.test(text)) {
+    issues.push({
+      kind: "truncated",
+      message: "Response appears to be incomplete or truncated"
+    });
+  }
+  return issues;
+}
+
+// src/semantic-types.ts
+var SemanticRetryError = class extends Error {
+  constructor(message, result, response) {
+    super(message);
+    this.result = result;
+    this.response = response;
+  }
+  result;
+  response;
+  name = "SemanticRetryError";
+};
+
+// src/semantic.ts
+function normalizeAiRetryPolicy(policy = {}) {
+  return {
+    ...aiRetryPolicies.strictJson,
+    ...policy
+  };
+}
+async function semanticRetry(operation, policy = {}) {
+  const resolved = normalizeAiRetryPolicy(policy);
+  let lastResult;
+  let lastResponse;
+  let previousDelayMs;
+  for (let attempt = 0; attempt <= resolved.maxSemanticRetries; attempt += 1) {
+    const value = await operation();
+    const response = isAxiosResponse(value) ? value : void 0;
+    const data = response ? response.data : value;
+    const finalResult = await validateSemanticResponse(data, resolved, response);
+    lastResult = finalResult;
+    lastResponse = response;
+    if (finalResult.ok) {
+      await resolved.hooks?.onSemanticRecovery?.({ result: finalResult, response });
+      return finalResult.data;
+    }
+    const issue = finalResult.issues[0] ?? {
+      kind: "unknown",
+      message: "Semantic validation failed"
+    };
+    if (attempt >= resolved.maxSemanticRetries || !shouldSemanticRetry(issue, resolved)) {
+      await resolved.hooks?.onSemanticGiveUp?.({
+        attempts: attempt + 1,
+        result: finalResult,
+        response
+      });
+      break;
+    }
+    const nextDelayMs = calculateRetryDelay(
+      {
+        retries: resolved.maxSemanticRetries,
+        strategy: "exponential",
+        baseDelayMs: 100,
+        maxDelayMs: 3e3,
+        jitter: "full"
+      },
+      { attempt: attempt + 1, previousDelayMs }
+    );
+    previousDelayMs = nextDelayMs;
+    await resolved.hooks?.onSemanticRetry?.({
+      attempt: attempt + 1,
+      maxRetries: resolved.maxSemanticRetries,
+      issue,
+      result: finalResult,
+      response,
+      nextDelayMs
+    });
+    resolved.logger?.log(
+      createLogEntry("warn", "semantic.retry", "Semantic retry scheduled", {
+        attempt: attempt + 1,
+        maxRetries: resolved.maxSemanticRetries,
+        delayMs: nextDelayMs,
+        issue: issue.kind,
+        ...resolved.metadata
+      })
+    );
+    await sleep(nextDelayMs);
+  }
+  throw new SemanticRetryError("Semantic retry attempts exhausted", lastResult ?? emptyFailure(), lastResponse);
+}
+async function requestWithSemanticRetry(instance, config) {
+  return semanticRetry(() => instance.request(config.request), config);
+}
+function applySemanticRecovery(instance, policy = {}) {
+  const resolved = normalizeAiRetryPolicy(policy);
+  instance.interceptors.response.use(async (response) => {
+    const finalResult = await validateSemanticResponse(response.data, resolved, response);
+    if (!finalResult.ok) {
+      throw new SemanticRetryError("Semantic response validation failed", finalResult, response);
+    }
+    response.data = finalResult.data;
+    await resolved.hooks?.onSemanticRecovery?.({ result: finalResult, response });
+    return response;
+  });
+  return {
+    axios: instance,
+    policy: resolved
+  };
+}
+function isAxiosResponse(value) {
+  return Boolean(value && typeof value === "object" && "status" in value && "headers" in value && "config" in value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function emptyFailure() {
+  return {
+    ok: false,
+    issues: [{ kind: "unknown", message: "Semantic validation failed before a response was captured" }]
+  };
+}
 export {
   ConsoleRetryLogger,
   RetryHookEmitter,
+  SemanticRetryError,
+  aiRetryPolicies,
   applyAiResilience,
   applyJitter,
+  applySemanticRecovery,
   calculateRetryDelay,
+  classifyAiFailure,
   createAiResilienceClient,
   createLogEntry,
+  createSemanticRetryCondition,
   defaultRetryConfig,
+  detectAiFailureSignals,
   isRetryableMethod,
   isRetryableStatus,
+  normalizeAiRetryPolicy,
   normalizeRetryConfig,
+  parseJsonResponse,
+  repairJsonString,
+  requestWithSemanticRetry,
+  resolveAiRetryPolicy,
   resolveRetryStrategy,
   retryStrategies,
-  shouldRetry
+  semanticRetry,
+  shouldRetry,
+  shouldSemanticRetry,
+  validateSchema,
+  validateSemanticResponse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-resilience",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Axios retry++ primitives for resilient AI and backend systems.",
   "type": "module",
   "main": "dist/index.cjs",