wiki-graph-core 0.3.1

package/dist/gc.d.cts

@@ -0,0 +1,10 @@
+import { G as GcRunReport } from './types-FVIqiLC9.cjs';
+export { a as GcContext, b as GcJob, c as GcJobReport, d as GcJobResult } from './types-FVIqiLC9.cjs';
+
+declare function tryRunWikiGraphGc(options?: {
+    readonly dryRun?: boolean;
+    readonly force?: boolean;
+    readonly opportunistic?: boolean;
+}): Promise<GcRunReport>;
+
+export { GcRunReport, tryRunWikiGraphGc };

package/dist/gc.d.ts

@@ -0,0 +1,2 @@
+export { tryRunWikiGraphGc } from './gc/runner.js';
+export { GcContext, GcJob, GcJobReport, GcJobResult, GcRunReport } from './gc/types.js';

package/dist/gc.js

@@ -0,0 +1,5 @@
+import { tryRunWikiGraphGc } from "./gc/index.js";
+export {
+  tryRunWikiGraphGc
+};
+//# sourceMappingURL=gc.js.map

package/dist/gc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/gc.ts"],"sourcesContent":["export { tryRunWikiGraphGc } from \"./gc/index.js\";\nexport type {\n  GcContext,\n  GcJob,\n  GcJobReport,\n  GcJobResult,\n  GcRunReport,\n} from \"./gc/index.js\";\n"],"mappings":"AAAA,SAAS,yBAAyB;","names":[]}

package/dist/guaranteed/classifier.d.ts

@@ -0,0 +1,10 @@
+import { LLMessage } from '../llm/types.js';
+import 'ai';
+
+declare const RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE = "guaranteed/response_intent_classifier";
+type GuaranteedResponseIntent = "ambiguous" | "malformed_json" | "natural_language";
+declare function buildResponseIntentClassificationMessages(systemPrompt: string, response: string): readonly LLMessage[];
+declare function classifyResponseIntentLocally(response: string): GuaranteedResponseIntent;
+declare function parseResponseIntentClassification(response: string): GuaranteedResponseIntent;
+
+export { type GuaranteedResponseIntent, RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE, buildResponseIntentClassificationMessages, classifyResponseIntentLocally, parseResponseIntentClassification };

package/dist/guaranteed/classifier.js

@@ -0,0 +1,88 @@
+const RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE = "guaranteed/response_intent_classifier";
+const NATURAL_LANGUAGE_PATTERNS = [
+  /\b(?:sorry|apologies)\b/i,
+  /\b(?:i\s+can(?:not|'t)|unable\s+to|do\s+not\s+understand)\b/i,
+  /\b(?:cannot\s+answer|can't\s+answer|can't\s+help)\b/i,
+  /\bno\s+relevant\s+result/i,
+  /抱歉/,
+  /无法回答/,
+  /无法识别/,
+  /无法给到/,
+  /没有找到相关的结果/
+];
+function buildResponseIntentClassificationMessages(systemPrompt, response) {
+  return [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    {
+      role: "user",
+      content: response
+    }
+  ];
+}
+function classifyResponseIntentLocally(response) {
+  const trimmed = response.trim();
+  if (trimmed === "") {
+    return "ambiguous";
+  }
+  if (hasStrongMalformedJsonSignal(trimmed)) {
+    return "malformed_json";
+  }
+  if (looksLikeNaturalLanguage(trimmed)) {
+    return "natural_language";
+  }
+  if (hasWeakMalformedJsonSignal(trimmed)) {
+    return "ambiguous";
+  }
+  if (looksLikePlainSentence(trimmed)) {
+    return "natural_language";
+  }
+  return "ambiguous";
+}
+function parseResponseIntentClassification(response) {
+  const normalized = response.trim().toLowerCase();
+  if (normalized.includes("malformed_json")) {
+    return "malformed_json";
+  }
+  if (normalized.includes("natural_language")) {
+    return "natural_language";
+  }
+  if (normalized.includes("ambiguous")) {
+    return "ambiguous";
+  }
+  return "ambiguous";
+}
+function hasStrongMalformedJsonSignal(text) {
+  return /^(?:```json\b|```|{|\[)/i.test(text) || /"[^"\r\n]+"\s*:/.test(text) || hasWeakMalformedJsonSignal(text) && endsWithLikelyTruncationToken(text);
+}
+function hasWeakMalformedJsonSignal(text) {
+  const punctuationCount = (text.match(/[{}[\]:,]/g) ?? []).length + (text.match(/"/g) ?? []).length;
+  return /:\s/.test(text) || punctuationCount >= 3 || hasUnbalancedBrackets(text) || /[:,]\s*$/.test(text);
+}
+function hasUnbalancedBrackets(text) {
+  return count(text, "{") !== count(text, "}") || count(text, "[") !== count(text, "]") ? true : false;
+}
+function endsWithLikelyTruncationToken(text) {
+  return /[:, "{[]\s*$/.test(text);
+}
+function looksLikeNaturalLanguage(text) {
+  if (NATURAL_LANGUAGE_PATTERNS.some((pattern) => pattern.test(text))) {
+    return true;
+  }
+  return !hasWeakMalformedJsonSignal(text) && looksLikePlainSentence(text);
+}
+function looksLikePlainSentence(text) {
+  return /[\p{Script=Han}A-Za-z]/u.test(text) && !/^[{[]/.test(text) && !/"[^"\r\n]+"\s*:/.test(text);
+}
+function count(text, character) {
+  return text.split(character).length - 1;
+}
+export {
+  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+  buildResponseIntentClassificationMessages,
+  classifyResponseIntentLocally,
+  parseResponseIntentClassification
+};
+//# sourceMappingURL=classifier.js.map

package/dist/guaranteed/classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guaranteed/classifier.ts"],"sourcesContent":["import type { LLMessage } from \"../llm/index.js\";\n\nexport const RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE =\n  \"guaranteed/response_intent_classifier\";\n\nexport type GuaranteedResponseIntent =\n  | \"ambiguous\"\n  | \"malformed_json\"\n  | \"natural_language\";\n\nconst NATURAL_LANGUAGE_PATTERNS = [\n  /\\b(?:sorry|apologies)\\b/i,\n  /\\b(?:i\\s+can(?:not|'t)|unable\\s+to|do\\s+not\\s+understand)\\b/i,\n  /\\b(?:cannot\\s+answer|can't\\s+answer|can't\\s+help)\\b/i,\n  /\\bno\\s+relevant\\s+result/i,\n  /抱歉/,\n  /无法回答/,\n  /无法识别/,\n  /无法给到/,\n  /没有找到相关的结果/,\n];\n\nexport function buildResponseIntentClassificationMessages(\n  systemPrompt: string,\n  response: string,\n): readonly LLMessage[] {\n  return [\n    {\n      role: \"system\",\n      content: systemPrompt,\n    },\n    {\n      role: \"user\",\n      content: response,\n    },\n  ];\n}\n\nexport function classifyResponseIntentLocally(\n  response: string,\n): GuaranteedResponseIntent {\n  const trimmed = response.trim();\n\n  if (trimmed === \"\") {\n    return \"ambiguous\";\n  }\n\n  if (hasStrongMalformedJsonSignal(trimmed)) {\n    return \"malformed_json\";\n  }\n\n  if (looksLikeNaturalLanguage(trimmed)) {\n    return \"natural_language\";\n  }\n\n  if (hasWeakMalformedJsonSignal(trimmed)) {\n    return \"ambiguous\";\n  }\n\n  if (looksLikePlainSentence(trimmed)) {\n    return \"natural_language\";\n  }\n\n  return \"ambiguous\";\n}\n\nexport function parseResponseIntentClassification(\n  response: string,\n): GuaranteedResponseIntent {\n  const normalized = response.trim().toLowerCase();\n\n  if (normalized.includes(\"malformed_json\")) {\n    return \"malformed_json\";\n  }\n\n  if (normalized.includes(\"natural_language\")) {\n    return \"natural_language\";\n  }\n\n  if (normalized.includes(\"ambiguous\")) {\n    return \"ambiguous\";\n  }\n\n  return \"ambiguous\";\n}\n\nfunction hasStrongMalformedJsonSignal(text: string): boolean {\n  return (\n    /^(?:```json\\b|```|{|\\[)/i.test(text) ||\n    /\"[^\"\\r\\n]+\"\\s*:/.test(text) ||\n    (hasWeakMalformedJsonSignal(text) && endsWithLikelyTruncationToken(text))\n  );\n}\n\nfunction hasWeakMalformedJsonSignal(text: string): boolean {\n  const punctuationCount =\n    (text.match(/[{}[\\]:,]/g) ?? []).length + (text.match(/\"/g) ?? []).length;\n\n  return (\n    /:\\s/.test(text) ||\n    punctuationCount >= 3 ||\n    hasUnbalancedBrackets(text) ||\n    /[:,]\\s*$/.test(text)\n  );\n}\n\nfunction hasUnbalancedBrackets(text: string): boolean {\n  return count(text, \"{\") !== count(text, \"}\") ||\n    count(text, \"[\") !== count(text, \"]\")\n    ? true\n    : false;\n}\n\nfunction endsWithLikelyTruncationToken(text: string): boolean {\n  return /[:, \"{[]\\s*$/.test(text);\n}\n\nfunction looksLikeNaturalLanguage(text: string): boolean {\n  if (NATURAL_LANGUAGE_PATTERNS.some((pattern) => pattern.test(text))) {\n    return true;\n  }\n\n  return !hasWeakMalformedJsonSignal(text) && looksLikePlainSentence(text);\n}\n\nfunction looksLikePlainSentence(text: string): boolean {\n  return (\n    /[\\p{Script=Han}A-Za-z]/u.test(text) &&\n    !/^[{[]/.test(text) &&\n    !/\"[^\"\\r\\n]+\"\\s*:/.test(text)\n  );\n}\n\nfunction count(text: string, character: string): number {\n  return text.split(character).length - 1;\n}\n"],"mappings":"AAEO,MAAM,6CACX;AAOF,MAAM,4BAA4B;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,SAAS,0CACd,cACA,UACsB;AACtB,SAAO;AAAA,IACL;AAAA,MACE,MAAM;AAAA,MACN,SAAS;AAAA,IACX;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,SAAS;AAAA,IACX;AAAA,EACF;AACF;AAEO,SAAS,8BACd,UAC0B;AAC1B,QAAM,UAAU,SAAS,KAAK;AAE9B,MAAI,YAAY,IAAI;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,6BAA6B,OAAO,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,MAAI,yBAAyB,OAAO,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,MAAI,2BAA2B,OAAO,GAAG;AACvC,WAAO;AAAA,EACT;AAEA,MAAI,uBAAuB,OAAO,GAAG;AACnC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,SAAS,kCACd,UAC0B;AAC1B,QAAM,aAAa,SAAS,KAAK,EAAE,YAAY;AAE/C,MAAI,WAAW,SAAS,gBAAgB,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,SAAS,kBAAkB,GAAG;AAC3C,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,SAAS,WAAW,GAAG;AACpC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,SAAS,6BAA6B,MAAuB;AAC3D,SACE,2BAA2B,KAAK,IAAI,KACpC,kBAAkB,KAAK,IAAI,KAC1B,2BAA2B,IAAI,KAAK,8BAA8B,IAAI;AAE3E;AAEA,SAAS,2BAA2B,MAAuB;AACzD,QAAM,oBACH,KAAK,MAAM,YAAY,KAAK,CAAC,GAAG,UAAU,KAAK,MAAM,IAAI,KAAK,CAAC,GAAG;AAErE,SACE,MAAM,KAAK,IAAI,KACf,oBAAoB,KACpB,sBAAsB,IAAI,KAC1B,WAAW,KAAK,IAAI;AAExB;AAEA,SAAS,sBAAsB,MAAuB;AACpD,SAAO,MAAM,MAAM,GAAG,MAAM,MAAM,MAAM,GAAG,KACzC,MAAM,MAAM,GAAG,MAAM,MAAM,MAAM,GAAG,IAClC,OACA;AACN;AAEA,SAAS,8BAA8B,MAAuB;AAC5D,SAAO,eAAe,KAAK,IAAI;AACjC;AAEA,SAAS,yBAAyB,MAAuB;AACvD,MAAI,0BAA0B,KAAK,CAAC,YAAY,QAAQ,KAAK,IAAI,CAAC,GAAG;AACnE,WAAO;AAAA,EACT;AAEA,SAAO,CAAC,2BAA2B,IAAI,KAAK,uBAAuB,IAAI;AACzE;AAEA,SAAS,uBAAuB,MAAuB;AACrD,SACE,0BAA0B,KAAK,IAAI,KACnC,CAAC,QAAQ,KAAK,IAAI,KAClB,CAAC,kBAAkB,KAAK,IAAI;AAEhC;AAEA,SAAS,MAAM,MAAc,WAA2B;AACtD,SAAO,KAAK,MAAM,SAAS,EAAE,SAAS;AACxC;","names":[]}

package/dist/guaranteed/errors.d.ts

@@ -0,0 +1,38 @@
+declare class ParsedJsonError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+declare abstract class GuaranteedRequestFailureError extends Error {
+    readonly attempts: number;
+    readonly maxRetries: number;
+    protected constructor(message: string, attempts: number, maxRetries: number);
+}
+declare class GuaranteedEmptyResponseError extends GuaranteedRequestFailureError {
+    constructor(attempts: number, maxRetries: number);
+}
+declare class SuspectedModelRefusalError extends GuaranteedRequestFailureError {
+    readonly response: string;
+    readonly reason: string;
+    constructor(attempts: number, maxRetries: number, input: {
+        response: string;
+        reason: string;
+    });
+}
+declare class GuaranteedSchemaValidationError extends GuaranteedRequestFailureError {
+    readonly issues: readonly string[];
+    readonly response: string;
+    constructor(attempts: number, maxRetries: number, input: {
+        issues: readonly string[];
+        response: string;
+    }, cause: unknown);
+}
+declare class GuaranteedParseValidationError extends GuaranteedRequestFailureError {
+    readonly issues: readonly string[];
+    readonly response: string;
+    constructor(attempts: number, maxRetries: number, input: {
+        issues: readonly string[];
+        response: string;
+    }, cause: unknown);
+}
+
+export { GuaranteedEmptyResponseError, GuaranteedParseValidationError, GuaranteedRequestFailureError, GuaranteedSchemaValidationError, ParsedJsonError, SuspectedModelRefusalError };

package/dist/guaranteed/errors.js

@@ -0,0 +1,73 @@
+class ParsedJsonError extends Error {
+  issues;
+  constructor(issues) {
+    super(`Parse failed with ${issues.length} issue(s)`);
+    this.name = "ParsedJsonError";
+    this.issues = [...issues];
+  }
+}
+class GuaranteedRequestFailureError extends Error {
+  attempts;
+  maxRetries;
+  constructor(message, attempts, maxRetries) {
+    super(message);
+    this.name = "GuaranteedRequestFailureError";
+    this.attempts = attempts;
+    this.maxRetries = maxRetries;
+  }
+}
+class GuaranteedEmptyResponseError extends GuaranteedRequestFailureError {
+  constructor(attempts, maxRetries) {
+    super(
+      "LLM returned empty response after all retries",
+      attempts,
+      maxRetries
+    );
+    this.name = "GuaranteedEmptyResponseError";
+  }
+}
+class SuspectedModelRefusalError extends GuaranteedRequestFailureError {
+  response;
+  reason;
+  constructor(attempts, maxRetries, input) {
+    super(
+      `Suspected model refusal after ${attempts} JSON syntax error attempt(s): ${input.reason}. Last response: ${JSON.stringify(input.response)}`,
+      attempts,
+      maxRetries
+    );
+    this.name = "SuspectedModelRefusalError";
+    this.response = input.response;
+    this.reason = input.reason;
+  }
+}
+class GuaranteedSchemaValidationError extends GuaranteedRequestFailureError {
+  issues;
+  response;
+  constructor(attempts, maxRetries, input, cause) {
+    super("Schema validation failed after all retries", attempts, maxRetries);
+    this.name = "GuaranteedSchemaValidationError";
+    this.issues = [...input.issues];
+    this.response = input.response;
+    this.cause = cause;
+  }
+}
+class GuaranteedParseValidationError extends GuaranteedRequestFailureError {
+  issues;
+  response;
+  constructor(attempts, maxRetries, input, cause) {
+    super("Parse validation failed after all retries", attempts, maxRetries);
+    this.name = "GuaranteedParseValidationError";
+    this.issues = [...input.issues];
+    this.response = input.response;
+    this.cause = cause;
+  }
+}
+export {
+  GuaranteedEmptyResponseError,
+  GuaranteedParseValidationError,
+  GuaranteedRequestFailureError,
+  GuaranteedSchemaValidationError,
+  ParsedJsonError,
+  SuspectedModelRefusalError
+};
+//# sourceMappingURL=errors.js.map

package/dist/guaranteed/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guaranteed/errors.ts"],"sourcesContent":["export class ParsedJsonError extends Error {\n  public readonly issues: readonly string[];\n\n  public constructor(issues: readonly string[]) {\n    super(`Parse failed with ${issues.length} issue(s)`);\n    this.name = \"ParsedJsonError\";\n    this.issues = [...issues];\n  }\n}\n\nexport abstract class GuaranteedRequestFailureError extends Error {\n  public readonly attempts: number;\n  public readonly maxRetries: number;\n\n  protected constructor(message: string, attempts: number, maxRetries: number) {\n    super(message);\n    this.name = \"GuaranteedRequestFailureError\";\n    this.attempts = attempts;\n    this.maxRetries = maxRetries;\n  }\n}\n\nexport class GuaranteedEmptyResponseError extends GuaranteedRequestFailureError {\n  public constructor(attempts: number, maxRetries: number) {\n    super(\n      \"LLM returned empty response after all retries\",\n      attempts,\n      maxRetries,\n    );\n    this.name = \"GuaranteedEmptyResponseError\";\n  }\n}\n\nexport class SuspectedModelRefusalError extends GuaranteedRequestFailureError {\n  public readonly response: string;\n  public readonly reason: string;\n\n  public constructor(\n    attempts: number,\n    maxRetries: number,\n    input: {\n      response: string;\n      reason: string;\n    },\n  ) {\n    super(\n      `Suspected model refusal after ${attempts} JSON syntax error attempt(s): ${input.reason}. Last response: ${JSON.stringify(input.response)}`,\n      attempts,\n      maxRetries,\n    );\n    this.name = \"SuspectedModelRefusalError\";\n    this.response = input.response;\n    this.reason = input.reason;\n  }\n}\n\nexport class GuaranteedSchemaValidationError extends GuaranteedRequestFailureError {\n  public readonly issues: readonly string[];\n  public readonly response: string;\n\n  public constructor(\n    attempts: number,\n    maxRetries: number,\n    input: {\n      issues: readonly string[];\n      response: string;\n    },\n    cause: unknown,\n  ) {\n    super(\"Schema validation failed after all retries\", attempts, maxRetries);\n    this.name = \"GuaranteedSchemaValidationError\";\n    this.issues = [...input.issues];\n    this.response = input.response;\n    this.cause = cause;\n  }\n}\n\nexport class GuaranteedParseValidationError extends GuaranteedRequestFailureError {\n  public readonly issues: readonly string[];\n  public readonly response: string;\n\n  public constructor(\n    attempts: number,\n    maxRetries: number,\n    input: {\n      issues: readonly string[];\n      response: string;\n    },\n    cause: unknown,\n  ) {\n    super(\"Parse validation failed after all retries\", attempts, maxRetries);\n    this.name = \"GuaranteedParseValidationError\";\n    this.issues = [...input.issues];\n    this.response = input.response;\n    this.cause = cause;\n  }\n}\n"],"mappings":"AAAO,MAAM,wBAAwB,MAAM;AAAA,EACzB;AAAA,EAET,YAAY,QAA2B;AAC5C,UAAM,qBAAqB,OAAO,MAAM,WAAW;AACnD,SAAK,OAAO;AACZ,SAAK,SAAS,CAAC,GAAG,MAAM;AAAA,EAC1B;AACF;AAEO,MAAe,sCAAsC,MAAM;AAAA,EAChD;AAAA,EACA;AAAA,EAEN,YAAY,SAAiB,UAAkB,YAAoB;AAC3E,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,aAAa;AAAA,EACpB;AACF;AAEO,MAAM,qCAAqC,8BAA8B;AAAA,EACvE,YAAY,UAAkB,YAAoB;AACvD;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,mCAAmC,8BAA8B;AAAA,EAC5D;AAAA,EACA;AAAA,EAET,YACL,UACA,YACA,OAIA;AACA;AAAA,MACE,iCAAiC,QAAQ,kCAAkC,MAAM,MAAM,oBAAoB,KAAK,UAAU,MAAM,QAAQ,CAAC;AAAA,MACzI;AAAA,MACA;AAAA,IACF;AACA,SAAK,OAAO;AACZ,SAAK,WAAW,MAAM;AACtB,SAAK,SAAS,MAAM;AAAA,EACtB;AACF;AAEO,MAAM,wCAAwC,8BAA8B;AAAA,EACjE;AAAA,EACA;AAAA,EAET,YACL,UACA,YACA,OAIA,OACA;AACA,UAAM,8CAA8C,UAAU,UAAU;AACxE,SAAK,OAAO;AACZ,SAAK,SAAS,CAAC,GAAG,MAAM,MAAM;AAC9B,SAAK,WAAW,MAAM;AACtB,SAAK,QAAQ;AAAA,EACf;AACF;AAEO,MAAM,uCAAuC,8BAA8B;AAAA,EAChE;AAAA,EACA;AAAA,EAET,YACL,UACA,YACA,OAIA,OACA;AACA,UAAM,6CAA6C,UAAU,UAAU;AACvE,SAAK,OAAO;AACZ,SAAK,SAAS,CAAC,GAAG,MAAM,MAAM;AAC9B,SAAK,WAAW,MAAM;AACtB,SAAK,QAAQ;AAAA,EACf;AACF;","names":[]}

package/dist/guaranteed/index.d.ts

@@ -0,0 +1,7 @@
+export { GuaranteedEmptyResponseError, GuaranteedParseValidationError, GuaranteedRequestFailureError, GuaranteedSchemaValidationError, ParsedJsonError, SuspectedModelRefusalError } from './errors.js';
+export { RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE } from './classifier.js';
+export { requestGuaranteedJson } from './request.js';
+export { GuaranteedLazyRequest, GuaranteedParser, GuaranteedRequest, GuaranteedRequestController, GuaranteedRequestOptions } from './types.js';
+import '../llm/types.js';
+import 'ai';
+import 'zod';

package/dist/guaranteed/index.js

@@ -0,0 +1,21 @@
+import {
+  GuaranteedEmptyResponseError,
+  GuaranteedRequestFailureError,
+  GuaranteedParseValidationError,
+  GuaranteedSchemaValidationError,
+  ParsedJsonError,
+  SuspectedModelRefusalError
+} from "./errors.js";
+import { RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE } from "./classifier.js";
+import { requestGuaranteedJson } from "./request.js";
+export {
+  GuaranteedEmptyResponseError,
+  GuaranteedParseValidationError,
+  GuaranteedRequestFailureError,
+  GuaranteedSchemaValidationError,
+  ParsedJsonError,
+  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+  SuspectedModelRefusalError,
+  requestGuaranteedJson
+};
+//# sourceMappingURL=index.js.map

package/dist/guaranteed/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guaranteed/index.ts"],"sourcesContent":["export {\n  GuaranteedEmptyResponseError,\n  GuaranteedRequestFailureError,\n  GuaranteedParseValidationError,\n  GuaranteedSchemaValidationError,\n  ParsedJsonError,\n  SuspectedModelRefusalError,\n} from \"./errors.js\";\nexport { RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE } from \"./classifier.js\";\nexport { requestGuaranteedJson } from \"./request.js\";\nexport type {\n  GuaranteedLazyRequest,\n  GuaranteedParser,\n  GuaranteedRequest,\n  GuaranteedRequestController,\n  GuaranteedRequestOptions,\n} from \"./types.js\";\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kDAAkD;AAC3D,SAAS,6BAA6B;","names":[]}

package/dist/guaranteed/request.d.ts

@@ -0,0 +1,8 @@
+import { GuaranteedRequestOptions } from './types.js';
+import '../llm/types.js';
+import 'ai';
+import 'zod';
+
+declare function requestGuaranteedJson<TData, TResult>(options: GuaranteedRequestOptions<TData, TResult>): Promise<TResult>;
+
+export { requestGuaranteedJson };

package/dist/guaranteed/request.js

@@ -0,0 +1,206 @@
+import {
+  buildResponseIntentClassificationMessages,
+  classifyResponseIntentLocally,
+  parseResponseIntentClassification
+} from "./classifier.js";
+import {
+  GuaranteedEmptyResponseError,
+  GuaranteedParseValidationError,
+  GuaranteedSchemaValidationError,
+  ParsedJsonError,
+  SuspectedModelRefusalError
+} from "./errors.js";
+import {
+  buildMalformedJsonMessage,
+  buildNaturalLanguageMessage,
+  buildBusinessErrorMessage,
+  buildSchemaErrorMessage,
+  buildSyntaxErrorMessage,
+  extractJsonText,
+  listSchemaIssues,
+  repairJsonText
+} from "./response.js";
+const DEFAULT_MAX_RETRIES = 12;
+const MAX_MALFORMED_JSON_REPAIR_HISTORY_ATTEMPTS = 3;
+async function requestGuaranteedJson(options) {
+  const initialMessages = [...options.messages];
+  let currentMessages = [...options.messages];
+  let consecutiveProtocolDerailments = 0;
+  let consecutiveMalformedJsonFailures = 0;
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  for (let index = 0; index <= maxRetries; index += 1) {
+    const response = await options.request(currentMessages, index, maxRetries);
+    if (response === void 0 || response.trim() === "") {
+      if (index >= maxRetries) {
+        throw new GuaranteedEmptyResponseError(index + 1, maxRetries);
+      }
+      continue;
+    }
+    let parsedData;
+    try {
+      const extractedJsonText = extractJsonText(response);
+      const repairedJsonText = repairJsonText(extractedJsonText);
+      parsedData = JSON.parse(repairedJsonText);
+    } catch (error) {
+      const intent = await classifyResponseIntent(options, response, index);
+      if (intent === "natural_language") {
+        consecutiveProtocolDerailments += 1;
+        consecutiveMalformedJsonFailures = 0;
+        if (consecutiveProtocolDerailments >= 2 || index >= maxRetries) {
+          const reason = index >= maxRetries ? "last retry still returned natural-language content" : "two consecutive retries returned natural-language content";
+          throw new SuspectedModelRefusalError(index + 1, maxRetries, {
+            response,
+            reason
+          });
+        }
+        currentMessages = buildRetryMessages(
+          initialMessages,
+          response,
+          buildNaturalLanguageMessage(),
+          false
+        );
+        continue;
+      }
+      consecutiveProtocolDerailments = 0;
+      consecutiveMalformedJsonFailures += 1;
+      currentMessages = buildRetryMessages(
+        initialMessages,
+        response,
+        intent === "malformed_json" ? buildMalformedJsonMessage(asSyntaxError(error)) : buildSyntaxErrorMessage(asSyntaxError(error)),
+        consecutiveMalformedJsonFailures < MAX_MALFORMED_JSON_REPAIR_HISTORY_ATTEMPTS
+      );
+      continue;
+    }
+    consecutiveProtocolDerailments = 0;
+    consecutiveMalformedJsonFailures = 0;
+    const validation = await options.schema.safeParseAsync(parsedData);
+    if (!validation.success) {
+      if (shouldTreatSchemaFailureAsNaturalLanguage(validation.error, parsedData)) {
+        const intent = await classifyResponseIntent(options, response, index);
+        if (intent === "natural_language") {
+          consecutiveProtocolDerailments += 1;
+          consecutiveMalformedJsonFailures = 0;
+          if (consecutiveProtocolDerailments >= 2 || index >= maxRetries) {
+            const reason = index >= maxRetries ? "last retry still returned natural-language content" : "two consecutive retries returned natural-language content";
+            throw new SuspectedModelRefusalError(index + 1, maxRetries, {
+              response,
+              reason
+            });
+          }
+          currentMessages = buildRetryMessages(
+            initialMessages,
+            response,
+            buildNaturalLanguageMessage(),
+            false
+          );
+          continue;
+        }
+      }
+      consecutiveProtocolDerailments = 0;
+      const feedback = buildSchemaErrorMessage(validation.error);
+      if (index >= maxRetries) {
+        throw new GuaranteedSchemaValidationError(
+          index + 1,
+          maxRetries,
+          {
+            issues: listSchemaIssues(validation.error),
+            response
+          },
+          validation.error
+        );
+      }
+      currentMessages = buildRetryMessages(
+        initialMessages,
+        response,
+        feedback,
+        true
+      );
+      continue;
+    }
+    try {
+      return await options.parse(validation.data, index, maxRetries);
+    } catch (error) {
+      if (!(error instanceof ParsedJsonError)) {
+        throw error;
+      }
+      const feedback = buildBusinessErrorMessage(error.issues);
+      if (index >= maxRetries) {
+        throw new GuaranteedParseValidationError(
+          index + 1,
+          maxRetries,
+          {
+            issues: error.issues,
+            response
+          },
+          error
+        );
+      }
+      currentMessages = buildRetryMessages(
+        initialMessages,
+        response,
+        feedback,
+        true
+      );
+    }
+  }
+  throw new Error("requestGuaranteedJson failed unexpectedly");
+}
+function buildRetryMessages(initialMessages, response, feedback, includeAssistantResponse) {
+  return [
+    ...initialMessages,
+    ...includeAssistantResponse ? [
+      {
+        role: "assistant",
+        content: response
+      }
+    ] : [],
+    {
+      role: "user",
+      content: feedback
+    }
+  ];
+}
+function asSyntaxError(error) {
+  if (error instanceof SyntaxError) {
+    return error;
+  }
+  return new SyntaxError(String(error));
+}
+async function classifyResponseIntent(options, response, index) {
+  const localIntent = classifyResponseIntentLocally(response);
+  if (localIntent !== "ambiguous") {
+    return localIntent;
+  }
+  try {
+    const classifierResponse = await options.request(
+      buildResponseIntentClassificationMessages(
+        options.responseIntentClassifierPrompt,
+        response
+      ),
+      index,
+      options.maxRetries ?? DEFAULT_MAX_RETRIES
+    );
+    if (classifierResponse === void 0 || classifierResponse.trim() === "") {
+      return "natural_language";
+    }
+    const classifierIntent = parseResponseIntentClassification(classifierResponse);
+    return classifierIntent === "ambiguous" ? "natural_language" : classifierIntent;
+  } catch {
+    return "natural_language";
+  }
+}
+function shouldTreatSchemaFailureAsNaturalLanguage(error, parsedData) {
+  if (!isPrimitiveJsonValue(parsedData)) {
+    return false;
+  }
+  return error.issues.some(
+    (issue) => issue.code === "invalid_type" && issue.path.length === 0 && (issue.expected === "object" || issue.expected === "array")
+  );
+}
+function isPrimitiveJsonValue(value) {
+  return value === null || typeof value !== "object" && typeof value !== "function";
+}
+export {
+  requestGuaranteedJson
+};
+//# sourceMappingURL=request.js.map

package/dist/guaranteed/request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guaranteed/request.ts"],"sourcesContent":["import type { LLMessage } from \"../llm/index.js\";\nimport {\n  buildResponseIntentClassificationMessages,\n  classifyResponseIntentLocally,\n  parseResponseIntentClassification,\n  type GuaranteedResponseIntent,\n} from \"./classifier.js\";\nimport {\n  GuaranteedEmptyResponseError,\n  GuaranteedParseValidationError,\n  GuaranteedSchemaValidationError,\n  ParsedJsonError,\n  SuspectedModelRefusalError,\n} from \"./errors.js\";\nimport {\n  buildMalformedJsonMessage,\n  buildNaturalLanguageMessage,\n  buildBusinessErrorMessage,\n  buildSchemaErrorMessage,\n  buildSyntaxErrorMessage,\n  extractJsonText,\n  listSchemaIssues,\n  repairJsonText,\n} from \"./response.js\";\nimport type { GuaranteedRequestOptions } from \"./types.js\";\n\nconst DEFAULT_MAX_RETRIES = 12;\nconst MAX_MALFORMED_JSON_REPAIR_HISTORY_ATTEMPTS = 3;\n\nexport async function requestGuaranteedJson<TData, TResult>(\n  options: GuaranteedRequestOptions<TData, TResult>,\n): Promise<TResult> {\n  const initialMessages = [...options.messages];\n  let currentMessages = [...options.messages];\n  let consecutiveProtocolDerailments = 0;\n  let consecutiveMalformedJsonFailures = 0;\n  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;\n\n  for (let index = 0; index <= maxRetries; index += 1) {\n    const response = await options.request(currentMessages, index, maxRetries);\n    if (response === undefined || response.trim() === \"\") {\n      if (index >= maxRetries) {\n        throw new GuaranteedEmptyResponseError(index + 1, maxRetries);\n      }\n      continue;\n    }\n    let parsedData: unknown;\n\n    try {\n      const extractedJsonText = extractJsonText(response);\n      const repairedJsonText = repairJsonText(extractedJsonText);\n\n      parsedData = JSON.parse(repairedJsonText);\n    } catch (error) {\n      const intent = await classifyResponseIntent(options, response, index);\n\n      if (intent === \"natural_language\") {\n        consecutiveProtocolDerailments += 1;\n        consecutiveMalformedJsonFailures = 0;\n\n        if (consecutiveProtocolDerailments >= 2 || index >= maxRetries) {\n          const reason =\n            index >= maxRetries\n              ? \"last retry still returned natural-language content\"\n              : \"two consecutive retries returned natural-language content\";\n          throw new SuspectedModelRefusalError(index + 1, maxRetries, {\n            response,\n            reason,\n          });\n        }\n\n        currentMessages = buildRetryMessages(\n          initialMessages,\n          response,\n          buildNaturalLanguageMessage(),\n          false,\n        );\n        continue;\n      }\n\n      consecutiveProtocolDerailments = 0;\n      consecutiveMalformedJsonFailures += 1;\n      currentMessages = buildRetryMessages(\n        initialMessages,\n        response,\n        intent === \"malformed_json\"\n          ? buildMalformedJsonMessage(asSyntaxError(error))\n          : buildSyntaxErrorMessage(asSyntaxError(error)),\n        consecutiveMalformedJsonFailures <\n          MAX_MALFORMED_JSON_REPAIR_HISTORY_ATTEMPTS,\n      );\n      continue;\n    }\n    consecutiveProtocolDerailments = 0;\n    consecutiveMalformedJsonFailures = 0;\n\n    const validation = await options.schema.safeParseAsync(parsedData);\n\n    if (!validation.success) {\n      if (\n        shouldTreatSchemaFailureAsNaturalLanguage(validation.error, parsedData)\n      ) {\n        const intent = await classifyResponseIntent(options, response, index);\n\n        if (intent === \"natural_language\") {\n          consecutiveProtocolDerailments += 1;\n          consecutiveMalformedJsonFailures = 0;\n\n          if (consecutiveProtocolDerailments >= 2 || index >= maxRetries) {\n            const reason =\n              index >= maxRetries\n                ? \"last retry still returned natural-language content\"\n                : \"two consecutive retries returned natural-language content\";\n            throw new SuspectedModelRefusalError(index + 1, maxRetries, {\n              response,\n              reason,\n            });\n          }\n\n          currentMessages = buildRetryMessages(\n            initialMessages,\n            response,\n            buildNaturalLanguageMessage(),\n            false,\n          );\n          continue;\n        }\n      }\n\n      consecutiveProtocolDerailments = 0;\n      const feedback = buildSchemaErrorMessage(validation.error);\n\n      if (index >= maxRetries) {\n        throw new GuaranteedSchemaValidationError(\n          index + 1,\n          maxRetries,\n          {\n            issues: listSchemaIssues(validation.error),\n            response,\n          },\n          validation.error,\n        );\n      }\n      currentMessages = buildRetryMessages(\n        initialMessages,\n        response,\n        feedback,\n        true,\n      );\n      continue;\n    }\n\n    try {\n      return await options.parse(validation.data, index, maxRetries);\n    } catch (error) {\n      if (!(error instanceof ParsedJsonError)) {\n        throw error;\n      }\n      const feedback = buildBusinessErrorMessage(error.issues);\n\n      if (index >= maxRetries) {\n        throw new GuaranteedParseValidationError(\n          index + 1,\n          maxRetries,\n          {\n            issues: error.issues,\n            response,\n          },\n          error,\n        );\n      }\n      currentMessages = buildRetryMessages(\n        initialMessages,\n        response,\n        feedback,\n        true,\n      );\n    }\n  }\n  throw new Error(\"requestGuaranteedJson failed unexpectedly\");\n}\n\nfunction buildRetryMessages(\n  initialMessages: readonly LLMessage[],\n  response: string,\n  feedback: string,\n  includeAssistantResponse: boolean,\n): LLMessage[] {\n  return [\n    ...initialMessages,\n    ...(includeAssistantResponse\n      ? [\n          {\n            role: \"assistant\" as const,\n            content: response,\n          },\n        ]\n      : []),\n    {\n      role: \"user\",\n      content: feedback,\n    },\n  ];\n}\n\nfunction asSyntaxError(error: unknown): SyntaxError {\n  if (error instanceof SyntaxError) {\n    return error;\n  }\n\n  return new SyntaxError(String(error));\n}\n\nasync function classifyResponseIntent<TData, TResult>(\n  options: GuaranteedRequestOptions<TData, TResult>,\n  response: string,\n  index: number,\n): Promise<GuaranteedResponseIntent> {\n  const localIntent = classifyResponseIntentLocally(response);\n\n  if (localIntent !== \"ambiguous\") {\n    return localIntent;\n  }\n\n  try {\n    const classifierResponse = await options.request(\n      buildResponseIntentClassificationMessages(\n        options.responseIntentClassifierPrompt,\n        response,\n      ),\n      index,\n      options.maxRetries ?? DEFAULT_MAX_RETRIES,\n    );\n\n    if (classifierResponse === undefined || classifierResponse.trim() === \"\") {\n      return \"natural_language\";\n    }\n\n    const classifierIntent =\n      parseResponseIntentClassification(classifierResponse);\n\n    return classifierIntent === \"ambiguous\"\n      ? \"natural_language\"\n      : classifierIntent;\n  } catch {\n    return \"natural_language\";\n  }\n}\n\nfunction shouldTreatSchemaFailureAsNaturalLanguage(\n  error: {\n    issues: readonly {\n      code?: string;\n      path: readonly PropertyKey[];\n      expected?: unknown;\n    }[];\n  },\n  parsedData: unknown,\n): boolean {\n  if (!isPrimitiveJsonValue(parsedData)) {\n    return false;\n  }\n\n  return error.issues.some(\n    (issue) =>\n      issue.code === \"invalid_type\" &&\n      issue.path.length === 0 &&\n      (issue.expected === \"object\" || issue.expected === \"array\"),\n  );\n}\n\nfunction isPrimitiveJsonValue(value: unknown): boolean {\n  return (\n    value === null || (typeof value !== \"object\" && typeof value !== \"function\")\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/guaranteed/response.d.ts

@@ -0,0 +1,12 @@
+import { ZodError } from 'zod';
+
+declare function extractJsonText(response: string): string;
+declare function repairJsonText(jsonText: string): string;
+declare function buildSyntaxErrorMessage(error: SyntaxError): string;
+declare function buildMalformedJsonMessage(error: SyntaxError): string;
+declare function buildNaturalLanguageMessage(): string;
+declare function buildSchemaErrorMessage(error: ZodError): string;
+declare function listSchemaIssues(error: ZodError): readonly string[];
+declare function buildBusinessErrorMessage(issues: readonly string[]): string;
+
+export { buildBusinessErrorMessage, buildMalformedJsonMessage, buildNaturalLanguageMessage, buildSchemaErrorMessage, buildSyntaxErrorMessage, extractJsonText, listSchemaIssues, repairJsonText };

package/dist/guaranteed/response.js

@@ -0,0 +1,98 @@
+import { jsonrepair } from "jsonrepair";
+function extractJsonText(response) {
+  const withoutCodeFence = response.replace(
+    /```(?:json)?\s*\n(.*?)\n```/gs,
+    "$1"
+  );
+  const matchedArray = withoutCodeFence.match(/\[[\s\S]*\]/);
+  const matchedObject = withoutCodeFence.match(/\{[\s\S]*\}/);
+  if (matchedArray?.index !== void 0 && matchedArray[0] !== void 0 && (matchedObject?.index === void 0 || matchedArray.index < matchedObject.index)) {
+    return matchedArray[0];
+  }
+  if (matchedObject?.[0] !== void 0) {
+    return matchedObject[0];
+  }
+  return withoutCodeFence.trim();
+}
+function repairJsonText(jsonText) {
+  try {
+    return jsonrepair(jsonText);
+  } catch {
+    return jsonText;
+  }
+}
+function buildSyntaxErrorMessage(error) {
+  const lines = [
+    "Your JSON has a syntax error.",
+    `Error: ${error.message}`,
+    "",
+    "Common issues:",
+    "- Trailing commas in arrays or objects",
+    '- Unescaped quotes in strings, for example: "He said \\"hi\\""',
+    '- Single quotes instead of double quotes, for example: {"key": "value"}',
+    "- Missing commas between items",
+    "",
+    "Regenerate the complete and valid JSON directly. Do not add explanations or markdown fences."
+  ];
+  return lines.join("\n");
+}
+function buildMalformedJsonMessage(error) {
+  const lines = [
+    "Your previous reply looked like malformed JSON.",
+    `Error: ${error.message}`,
+    "",
+    "Return complete and valid JSON directly.",
+    "Do not answer conversationally.",
+    "Do not add explanations or markdown fences."
+  ];
+  return lines.join("\n");
+}
+function buildNaturalLanguageMessage() {
+  const lines = [
+    "Your previous reply was plain natural language, not a JSON object or array.",
+    "",
+    "Do not apologize or explain.",
+    "Do not answer conversationally.",
+    "Return complete and valid JSON directly."
+  ];
+  return lines.join("\n");
+}
+function buildSchemaErrorMessage(error) {
+  const issues = error.issues.map(formatZodIssue);
+  const lines = [
+    "Your JSON has structural issues.",
+    "",
+    ...issues,
+    "",
+    "Regenerate the complete and valid JSON directly. Do not add explanations."
+  ];
+  return lines.join("\n");
+}
+function listSchemaIssues(error) {
+  return error.issues.map(formatZodIssue);
+}
+function buildBusinessErrorMessage(issues) {
+  const lines = [
+    "Your JSON has the following issues.",
+    "",
+    ...issues.map((issue) => `- ${issue}`),
+    "",
+    "Regenerate the complete and valid JSON directly. Do not add explanations."
+  ];
+  return lines.join("\n");
+}
+function formatZodIssue(issue) {
+  const location = issue.path.length === 0 ? "<root>" : issue.path.join(".");
+  return `- **${location}**: ${issue.message}`;
+}
+export {
+  buildBusinessErrorMessage,
+  buildMalformedJsonMessage,
+  buildNaturalLanguageMessage,
+  buildSchemaErrorMessage,
+  buildSyntaxErrorMessage,
+  extractJsonText,
+  listSchemaIssues,
+  repairJsonText
+};
+//# sourceMappingURL=response.js.map