@warlock.js/core 4.7.0 → 4.8.1

package/esm/ai/src/utils/extract-json-lenient.mjs

@@ -1,97 +0,0 @@
-import { extractJsonPayload } from "./extract-json-payload.mjs";
-
-//#region ../@warlock.js/ai/src/utils/extract-json-lenient.ts
-/**
-* Lenient counterpart to {@link extractJsonPayload}, tuned for the
-* structured-output judges that emit *corrupted* JSON — notably the
-* Amazon Nova family, which routinely wraps its verdict in fenced
-* ` ```json ` blocks, prepends an explanation paragraph, or trails the
-* object with commentary.
-*
-* Where `extractJsonPayload` deliberately refuses the "first `{` … last
-* `}`" heuristic (it would corrupt strict callers when prose contains
-* stray braces), this helper *opts into* that resilience: after fence
-* stripping it scans for the first balanced JSON object (`{…}`) or array
-* (`[…]`) and returns just that slice. Brace/bracket counting is
-* string-aware (it ignores braces inside JSON string literals and honors
-* `\"` escapes), so prose-embedded braces inside the JSON's own strings
-* don't throw off the balance.
-*
-* Returns the fence-stripped, trimmed text unchanged when no balanced
-* structure is found, so the caller's `JSON.parse` still fails loudly on
-* genuine garbage rather than this helper inventing a value.
-*
-* **Trade-off:** resilience over strictness. Use it only where a tolerant
-* parse is wanted (the judge preset) — for normal structured output keep
-* `extractJsonPayload`, which fails fast on malformed responses so real
-* prompt/model defects surface instead of being silently papered over.
-*
-* @example
-* extractJsonLenient('Here is my verdict:\n```json\n{"score":0.9}\n``` — done.');
-* // => '{"score":0.9}'
-*
-* @example
-* extractJsonLenient('The answer is {"verdict":"pass"} for sure.');
-* // => '{"verdict":"pass"}'
-*
-* @example
-* extractJsonLenient('{"valid":true}');
-* // => '{"valid":true}'   (clean JSON passes through)
-*/
-function extractJsonLenient(text) {
-	const stripped = extractJsonPayload(text);
-	return sliceFirstBalanced(stripped) ?? stripped;
-}
-/**
-* Scan for the first balanced JSON object or array and return its raw
-* slice. Returns `undefined` when no opening `{`/`[` is found or the
-* structure never closes (truncated / partial output) — the caller then
-* falls back to the fence-stripped text so the failure stays visible.
-*
-* String-literal aware: braces and brackets appearing *inside* a JSON
-* string are not counted toward the balance, and a backslash escapes the
-* next character so an escaped quote (`\"`) doesn't prematurely end the
-* string scan.
-*/
-function sliceFirstBalanced(text) {
-	const start = firstOpenerIndex(text);
-	if (start === -1) return;
-	const opener = text[start];
-	const closer = opener === "{" ? "}" : "]";
-	let depth = 0;
-	let inString = false;
-	let escaped = false;
-	for (let index = start; index < text.length; index++) {
-		const char = text[index];
-		if (inString) {
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			continue;
-		}
-		if (char === opener) depth++;
-		else if (char === closer) {
-			depth--;
-			if (depth === 0) return text.slice(start, index + 1);
-		}
-	}
-}
-/**
-* Index of the first JSON structure opener (`{` or `[`), whichever
-* appears earliest, or `-1` when neither is present.
-*/
-function firstOpenerIndex(text) {
-	const brace = text.indexOf("{");
-	const bracket = text.indexOf("[");
-	if (brace === -1) return bracket;
-	if (bracket === -1) return brace;
-	return Math.min(brace, bracket);
-}
-
-//#endregion
-export { extractJsonLenient };
-//# sourceMappingURL=extract-json-lenient.mjs.map

package/esm/ai/src/utils/extract-json-lenient.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-json-lenient.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/utils/extract-json-lenient.ts"],"sourcesContent":["import { extractJsonPayload } from \"./extract-json-payload\";\n\n/**\n * Lenient counterpart to {@link extractJsonPayload}, tuned for the\n * structured-output judges that emit *corrupted* JSON — notably the\n * Amazon Nova family, which routinely wraps its verdict in fenced\n * ` ```json ` blocks, prepends an explanation paragraph, or trails the\n * object with commentary.\n *\n * Where `extractJsonPayload` deliberately refuses the \"first `{` … last\n * `}`\" heuristic (it would corrupt strict callers when prose contains\n * stray braces), this helper *opts into* that resilience: after fence\n * stripping it scans for the first balanced JSON object (`{…}`) or array\n * (`[…]`) and returns just that slice. Brace/bracket counting is\n * string-aware (it ignores braces inside JSON string literals and honors\n * `\\\"` escapes), so prose-embedded braces inside the JSON's own strings\n * don't throw off the balance.\n *\n * Returns the fence-stripped, trimmed text unchanged when no balanced\n * structure is found, so the caller's `JSON.parse` still fails loudly on\n * genuine garbage rather than this helper inventing a value.\n *\n * **Trade-off:** resilience over strictness. Use it only where a tolerant\n * parse is wanted (the judge preset) — for normal structured output keep\n * `extractJsonPayload`, which fails fast on malformed responses so real\n * prompt/model defects surface instead of being silently papered over.\n *\n * @example\n * extractJsonLenient('Here is my verdict:\\n```json\\n{\"score\":0.9}\\n``` — done.');\n * // => '{\"score\":0.9}'\n *\n * @example\n * extractJsonLenient('The answer is {\"verdict\":\"pass\"} for sure.');\n * // => '{\"verdict\":\"pass\"}'\n *\n * @example\n * extractJsonLenient('{\"valid\":true}');\n * // => '{\"valid\":true}'   (clean JSON passes through)\n */\nexport function extractJsonLenient(text: string): string {\n  // First reuse the strict fence stripper. When the model produced a\n  // clean fenced block this already yields the exact payload, so the\n  // balanced scan below becomes a no-op pass-through.\n  const stripped = extractJsonPayload(text);\n\n  const sliced = sliceFirstBalanced(stripped);\n\n  return sliced ?? stripped;\n}\n\n/**\n * Scan for the first balanced JSON object or array and return its raw\n * slice. Returns `undefined` when no opening `{`/`[` is found or the\n * structure never closes (truncated / partial output) — the caller then\n * falls back to the fence-stripped text so the failure stays visible.\n *\n * String-literal aware: braces and brackets appearing *inside* a JSON\n * string are not counted toward the balance, and a backslash escapes the\n * next character so an escaped quote (`\\\"`) doesn't prematurely end the\n * string scan.\n */\nfunction sliceFirstBalanced(text: string): string | undefined {\n  const start = firstOpenerIndex(text);\n\n  if (start === -1) {\n    return undefined;\n  }\n\n  const opener = text[start];\n  const closer = opener === \"{\" ? \"}\" : \"]\";\n\n  let depth = 0;\n  let inString = false;\n  let escaped = false;\n\n  for (let index = start; index < text.length; index++) {\n    const char = text[index];\n\n    if (inString) {\n      if (escaped) {\n        escaped = false;\n      } else if (char === \"\\\\\") {\n        escaped = true;\n      } else if (char === '\"') {\n        inString = false;\n      }\n\n      continue;\n    }\n\n    if (char === '\"') {\n      inString = true;\n      continue;\n    }\n\n    if (char === opener) {\n      depth++;\n    } else if (char === closer) {\n      depth--;\n\n      if (depth === 0) {\n        return text.slice(start, index + 1);\n      }\n    }\n  }\n\n  // Opener with no matching close — truncated / partial output. Leave it\n  // to the caller's fallback (and its loud parse failure).\n  return undefined;\n}\n\n/**\n * Index of the first JSON structure opener (`{` or `[`), whichever\n * appears earliest, or `-1` when neither is present.\n */\nfunction firstOpenerIndex(text: string): number {\n  const brace = text.indexOf(\"{\");\n  const bracket = text.indexOf(\"[\");\n\n  if (brace === -1) {\n    return bracket;\n  }\n\n  if (bracket === -1) {\n    return brace;\n  }\n\n  return Math.min(brace, bracket);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,mBAAmB,MAAsB;CAIvD,MAAM,WAAW,mBAAmB,IAAI;CAIxC,OAFe,mBAAmB,QAEtB,KAAK;AACnB;;;;;;;;;;;;AAaA,SAAS,mBAAmB,MAAkC;CAC5D,MAAM,QAAQ,iBAAiB,IAAI;CAEnC,IAAI,UAAU,IACZ;CAGF,MAAM,SAAS,KAAK;CACpB,MAAM,SAAS,WAAW,MAAM,MAAM;CAEtC,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,UAAU;CAEd,KAAK,IAAI,QAAQ,OAAO,QAAQ,KAAK,QAAQ,SAAS;EACpD,MAAM,OAAO,KAAK;EAElB,IAAI,UAAU;GACZ,IAAI,SACF,UAAU;QACL,IAAI,SAAS,MAClB,UAAU;QACL,IAAI,SAAS,MAClB,WAAW;GAGb;EACF;EAEA,IAAI,SAAS,MAAK;GAChB,WAAW;GACX;EACF;EAEA,IAAI,SAAS,QACX;OACK,IAAI,SAAS,QAAQ;GAC1B;GAEA,IAAI,UAAU,GACZ,OAAO,KAAK,MAAM,OAAO,QAAQ,CAAC;EAEtC;CACF;AAKF;;;;;AAMA,SAAS,iBAAiB,MAAsB;CAC9C,MAAM,QAAQ,KAAK,QAAQ,GAAG;CAC9B,MAAM,UAAU,KAAK,QAAQ,GAAG;CAEhC,IAAI,UAAU,IACZ,OAAO;CAGT,IAAI,YAAY,IACd,OAAO;CAGT,OAAO,KAAK,IAAI,OAAO,OAAO;AAChC"}

package/esm/ai/src/utils/extract-json-payload.mjs

@@ -1,39 +0,0 @@
-//#region ../@warlock.js/ai/src/utils/extract-json-payload.ts
-/**
-* Strip markdown code fences from an LLM response before JSON parsing.
-*
-* Models — especially Claude, smaller models, and local models — routinely
-* wrap JSON output in fenced code blocks (` ```json\n{...}\n``` `) even when
-* instructed otherwise. Sometimes they also precede the fence with prose
-* ("Here you go:\n```json\n...\n```"). This helper finds the first fenced
-* block regardless of language tag and returns its trimmed contents.
-*
-* Returns the trimmed original text unchanged when no fence is present, so
-* clean JSON passes through as a no-op.
-*
-* Deliberately does NOT fall back to "find first `{` and last `}` and slice
-* between them" — that heuristic silently corrupts data when prose contains
-* stray braces. Failing loudly at `JSON.parse` is safer.
-*
-* @example
-* extractJsonPayload('```json\n{"a":1}\n```');
-* // => '{"a":1}'
-*
-* @example
-* extractJsonPayload('Here you go:\n```\n{"a":1}\n```\nHope this helps.');
-* // => '{"a":1}'
-*
-* @example
-* extractJsonPayload('{"a":1}');
-* // => '{"a":1}'   (no fence → unchanged)
-*/
-function extractJsonPayload(text) {
-	const trimmed = text.trim();
-	const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-	if (fenceMatch) return fenceMatch[1].trim();
-	return trimmed;
-}
-
-//#endregion
-export { extractJsonPayload };
-//# sourceMappingURL=extract-json-payload.mjs.map

package/esm/ai/src/utils/extract-json-payload.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-json-payload.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/utils/extract-json-payload.ts"],"sourcesContent":["/**\n * Strip markdown code fences from an LLM response before JSON parsing.\n *\n * Models — especially Claude, smaller models, and local models — routinely\n * wrap JSON output in fenced code blocks (` ```json\\n{...}\\n``` `) even when\n * instructed otherwise. Sometimes they also precede the fence with prose\n * (\"Here you go:\\n```json\\n...\\n```\"). This helper finds the first fenced\n * block regardless of language tag and returns its trimmed contents.\n *\n * Returns the trimmed original text unchanged when no fence is present, so\n * clean JSON passes through as a no-op.\n *\n * Deliberately does NOT fall back to \"find first `{` and last `}` and slice\n * between them\" — that heuristic silently corrupts data when prose contains\n * stray braces. Failing loudly at `JSON.parse` is safer.\n *\n * @example\n * extractJsonPayload('```json\\n{\"a\":1}\\n```');\n * // => '{\"a\":1}'\n *\n * @example\n * extractJsonPayload('Here you go:\\n```\\n{\"a\":1}\\n```\\nHope this helps.');\n * // => '{\"a\":1}'\n *\n * @example\n * extractJsonPayload('{\"a\":1}');\n * // => '{\"a\":1}'   (no fence → unchanged)\n */\nexport function extractJsonPayload(text: string): string {\n  const trimmed = text.trim();\n\n  const fenceMatch = trimmed.match(/```(?:json)?\\s*\\n?([\\s\\S]*?)\\n?```/);\n\n  if (fenceMatch) {\n    return fenceMatch[1].trim();\n  }\n\n  return trimmed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,mBAAmB,MAAsB;CACvD,MAAM,UAAU,KAAK,KAAK;CAE1B,MAAM,aAAa,QAAQ,MAAM,oCAAoC;CAErE,IAAI,YACF,OAAO,WAAW,EAAE,CAAC,KAAK;CAG5B,OAAO;AACT"}

package/esm/ai/src/utils/generate-run-id.mjs

@@ -1,23 +0,0 @@
-//#region ../@warlock.js/ai/src/utils/generate-run-id.ts
-/**
-* Generates a stable, human-readable run id for any execution node
-* (tool invocation, agent run, workflow run, supervisor run). Format:
-* `${prefix}_${timestamp36}_${random36}` — compact, sortable by
-* prefix, collision-resistant within a run.
-*
-* Shared helper so every primitive emits the same id shape. The
-* prefix is conventionally the primitive kind (`"tool"`, `"agent"`,
-* `"workflow"`, `"sup"`) but callers can pass anything; the id is
-* purely for correlation, never parsed.
-*
-* @example
-* const runId = generateRunId("tool");
-* // → "tool_ld8x3m_7fq2j1kp"
-*/
-function generateRunId(prefix) {
-	return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-
-//#endregion
-export { generateRunId };
-//# sourceMappingURL=generate-run-id.mjs.map

package/esm/ai/src/utils/generate-run-id.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-run-id.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/utils/generate-run-id.ts"],"sourcesContent":["/**\n * Generates a stable, human-readable run id for any execution node\n * (tool invocation, agent run, workflow run, supervisor run). Format:\n * `${prefix}_${timestamp36}_${random36}` — compact, sortable by\n * prefix, collision-resistant within a run.\n *\n * Shared helper so every primitive emits the same id shape. The\n * prefix is conventionally the primitive kind (`\"tool\"`, `\"agent\"`,\n * `\"workflow\"`, `\"sup\"`) but callers can pass anything; the id is\n * purely for correlation, never parsed.\n *\n * @example\n * const runId = generateRunId(\"tool\");\n * // → \"tool_ld8x3m_7fq2j1kp\"\n */\nexport function generateRunId(prefix: string): string {\n  return `${prefix}_${Date.now().toString(36)}_${Math.random()\n    .toString(36)\n    .slice(2, 10)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,cAAc,QAAwB;CACpD,OAAO,GAAG,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CACzD,SAAS,EAAE,CAAC,CACZ,MAAM,GAAG,EAAE;AAChB"}

package/esm/ai/src/utils/index.mjs

@@ -1,12 +0,0 @@
-import { accumulateCost, computeCost, mergeUsage } from "./compute-cost.mjs";
-import { extractJsonPayload } from "./extract-json-payload.mjs";
-import { extractJsonLenient } from "./extract-json-lenient.mjs";
-import { generateRunId } from "./generate-run-id.mjs";
-import { extractJsonSchema } from "./json-schema.mjs";
-import { resolveAttachment } from "./resolve-attachment.mjs";
-import { prepareAttachmentPart } from "./prepare-attachment-part.mjs";
-import { captureChildReport, withRunFrame, withoutRunFrame } from "./run-context.mjs";
-import { safeJsonParse } from "./safe-json-parse.mjs";
-import { stampReportLineage } from "./stamp-report-lineage.mjs";
-
-export {  };

package/esm/ai/src/utils/json-schema.mjs

@@ -1,89 +0,0 @@
-//#region ../@warlock.js/ai/src/utils/json-schema.ts
-/**
-* Best-effort JSON Schema extraction from a Standard Schema instance.
-*
-* Different libraries expose their JSON representation through different
-* paths:
-* - **Seal / Standard JSON Schema V1**: `["~standard"].jsonSchema.input({ target })`
-*   — nested under the spec object, takes a target switch. Default target
-*   is `"openai-strict"` since the primary consumer is OpenAI's native
-*   structured-output mechanism; pass `options.target` to override.
-* - **Zod / similar**: top-level `.jsonSchema` property. Zod v4 actually
-*   ships `toJSONSchema` as a module function, not a method, so it does
-*   NOT hit this probe — Zod users pass their converted schema via the
-*   `AgentExecuteOptions.responseSchema` escape hatch.
-*
-* Deliberately does NOT probe `toJSON` — that's a generic JavaScript
-* serialization hook (Seal's schemas have one that dumps internal rule
-* state) and matching it would return garbage disguised as a JSON Schema.
-*
-* Returns `undefined` when no path matches. The caller then either skips
-* native structured-output wiring or falls back to a schema-less
-* instruction.
-*
-* Shared across every SDK adapter package (OpenAI, Anthropic, Bedrock…)
-* so each provider converts schemas identically.
-*
-* @example
-* const schema = extractJsonSchema(mySealSchema);
-* // { type: "object", properties: { ... }, required: [ ... ], additionalProperties: false }
-*
-* @example
-* // Ask for a different target explicitly
-* const draft = extractJsonSchema(mySealSchema, { target: "draft-2020-12" });
-*/
-function extractJsonSchema(schema, options = {}) {
-	if (!schema) return void 0;
-	const sealJsonSchema = extractFromSealPath(schema, options.target ?? "openai-strict");
-	if (sealJsonSchema) return sealJsonSchema;
-	const topLevel = extractFromCandidateKeys(schema);
-	if (topLevel) return topLevel;
-}
-/**
-* Probe the Standard JSON Schema V1 extension path on `schema["~standard"]`.
-* The spec defines `jsonSchema.input({ target, libraryOptions? })` as a
-* function returning a JSON Schema tailored to the requested target. We
-* pass the caller's target (default `"openai-strict"`) so the library
-* produces output ready for OpenAI's native structured-output mode
-* without additional post-processing.
-*
-* Calling `.input()` without a target would throw (or return garbage) per
-* the spec — a failure here returns `undefined` so the fallback probe
-* runs.
-*/
-function extractFromSealPath(schema, target) {
-	const standardSlot = schema["~standard"];
-	if (!standardSlot || typeof standardSlot !== "object") return;
-	const jsonSchemaSlot = standardSlot["jsonSchema"];
-	if (!jsonSchemaSlot || typeof jsonSchemaSlot !== "object") return;
-	const inputFn = jsonSchemaSlot["input"];
-	if (typeof inputFn !== "function") return;
-	try {
-		const result = inputFn.call(jsonSchemaSlot, { target });
-		if (result && typeof result === "object") return result;
-	} catch {}
-}
-/**
-* Probe well-known top-level keys libraries use to expose their JSON
-* Schema. Supports both method form (rare) and property form (common).
-* Deliberately narrow — `toJSON` is NOT probed here because it's a
-* generic serialization hook that returns library-internal state for
-* many validators (Seal included), not a JSON Schema.
-*/
-function extractFromCandidateKeys(schemaRecord) {
-	for (const key of ["jsonSchema", "_jsonSchema"]) {
-		const value = schemaRecord[key];
-		if (typeof value === "function") {
-			try {
-				const result = value.call(schemaRecord);
-				if (result && typeof result === "object") return result;
-			} catch {}
-			continue;
-		}
-		if (value && typeof value === "object") return value;
-	}
-}
-
-//#endregion
-export { extractJsonSchema };
-//# sourceMappingURL=json-schema.mjs.map

package/esm/ai/src/utils/json-schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-schema.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/utils/json-schema.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Supported JSON Schema output targets per the Standard JSON Schema V1\n * spec. `openai-strict` is the richest for OpenAI structured outputs —\n * every property listed in `required`, optionals expressed as\n * `[\"T\", \"null\"]`, `additionalProperties: false` everywhere. Other\n * targets produce standards-compliant but looser output.\n */\nexport type JsonSchemaTarget = \"draft-2020-12\" | \"draft-07\" | \"openapi-3.0\" | \"openai-strict\";\n\n/**\n * Options for `extractJsonSchema`. `target` is forwarded to libraries that\n * implement the Standard JSON Schema V1 spec (Seal, and any future lib\n * that follows the spec). Libraries using their own top-level `.jsonSchema`\n * / `._jsonSchema` property ignore the target.\n */\nexport type ExtractJsonSchemaOptions = {\n  target?: JsonSchemaTarget | (string & {});\n};\n\n/**\n * Best-effort JSON Schema extraction from a Standard Schema instance.\n *\n * Different libraries expose their JSON representation through different\n * paths:\n * - **Seal / Standard JSON Schema V1**: `[\"~standard\"].jsonSchema.input({ target })`\n *   — nested under the spec object, takes a target switch. Default target\n *   is `\"openai-strict\"` since the primary consumer is OpenAI's native\n *   structured-output mechanism; pass `options.target` to override.\n * - **Zod / similar**: top-level `.jsonSchema` property. Zod v4 actually\n *   ships `toJSONSchema` as a module function, not a method, so it does\n *   NOT hit this probe — Zod users pass their converted schema via the\n *   `AgentExecuteOptions.responseSchema` escape hatch.\n *\n * Deliberately does NOT probe `toJSON` — that's a generic JavaScript\n * serialization hook (Seal's schemas have one that dumps internal rule\n * state) and matching it would return garbage disguised as a JSON Schema.\n *\n * Returns `undefined` when no path matches. The caller then either skips\n * native structured-output wiring or falls back to a schema-less\n * instruction.\n *\n * Shared across every SDK adapter package (OpenAI, Anthropic, Bedrock…)\n * so each provider converts schemas identically.\n *\n * @example\n * const schema = extractJsonSchema(mySealSchema);\n * // { type: \"object\", properties: { ... }, required: [ ... ], additionalProperties: false }\n *\n * @example\n * // Ask for a different target explicitly\n * const draft = extractJsonSchema(mySealSchema, { target: \"draft-2020-12\" });\n */\nexport function extractJsonSchema(\n  schema: StandardSchemaV1<unknown> | undefined,\n  options: ExtractJsonSchemaOptions = {},\n): Record<string, unknown> | undefined {\n  if (!schema) return undefined;\n\n  const target = options.target ?? \"openai-strict\";\n\n  // 1. Seal / Standard JSON Schema V1 pattern: [\"~standard\"].jsonSchema.input({ target })\n  const sealJsonSchema = extractFromSealPath(schema, target);\n\n  if (sealJsonSchema) {\n    return sealJsonSchema;\n  }\n\n  // 2. Top-level jsonSchema / _jsonSchema (Zod-like, property or method form)\n  const topLevel = extractFromCandidateKeys(schema as unknown as Record<string, unknown>);\n\n  if (topLevel) {\n    return topLevel;\n  }\n\n  return undefined;\n}\n\n/**\n * Probe the Standard JSON Schema V1 extension path on `schema[\"~standard\"]`.\n * The spec defines `jsonSchema.input({ target, libraryOptions? })` as a\n * function returning a JSON Schema tailored to the requested target. We\n * pass the caller's target (default `\"openai-strict\"`) so the library\n * produces output ready for OpenAI's native structured-output mode\n * without additional post-processing.\n *\n * Calling `.input()` without a target would throw (or return garbage) per\n * the spec — a failure here returns `undefined` so the fallback probe\n * runs.\n */\nfunction extractFromSealPath(\n  schema: StandardSchemaV1<unknown>,\n  target: string,\n): Record<string, unknown> | undefined {\n  const standardSlot = (schema as unknown as Record<string, unknown>)[\"~standard\"];\n\n  if (!standardSlot || typeof standardSlot !== \"object\") {\n    return undefined;\n  }\n\n  const jsonSchemaSlot = (standardSlot as Record<string, unknown>)[\"jsonSchema\"];\n\n  if (!jsonSchemaSlot || typeof jsonSchemaSlot !== \"object\") {\n    return undefined;\n  }\n\n  const inputFn = (jsonSchemaSlot as Record<string, unknown>)[\"input\"];\n\n  if (typeof inputFn !== \"function\") {\n    return undefined;\n  }\n\n  try {\n    const result = (inputFn as (options: { target: string }) => unknown).call(jsonSchemaSlot, {\n      target,\n    });\n\n    if (result && typeof result === \"object\") {\n      return result as Record<string, unknown>;\n    }\n  } catch {\n    // fall through — library didn't support the target or threw otherwise\n  }\n\n  return undefined;\n}\n\n/**\n * Probe well-known top-level keys libraries use to expose their JSON\n * Schema. Supports both method form (rare) and property form (common).\n * Deliberately narrow — `toJSON` is NOT probed here because it's a\n * generic serialization hook that returns library-internal state for\n * many validators (Seal included), not a JSON Schema.\n */\nfunction extractFromCandidateKeys(\n  schemaRecord: Record<string, unknown>,\n): Record<string, unknown> | undefined {\n  const candidateKeys = [\"jsonSchema\", \"_jsonSchema\"] as const;\n\n  for (const key of candidateKeys) {\n    const value = schemaRecord[key];\n\n    if (typeof value === \"function\") {\n      try {\n        const result = (value as () => unknown).call(schemaRecord);\n\n        if (result && typeof result === \"object\") {\n          return result as Record<string, unknown>;\n        }\n      } catch {\n        // try next candidate\n      }\n\n      continue;\n    }\n\n    if (value && typeof value === \"object\") {\n      return value as Record<string, unknown>;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,kBACd,QACA,UAAoC,CAAC,GACA;CACrC,IAAI,CAAC,QAAQ,OAAO;CAKpB,MAAM,iBAAiB,oBAAoB,QAH5B,QAAQ,UAAU,eAGwB;CAEzD,IAAI,gBACF,OAAO;CAIT,MAAM,WAAW,yBAAyB,MAA4C;CAEtF,IAAI,UACF,OAAO;AAIX;;;;;;;;;;;;;AAcA,SAAS,oBACP,QACA,QACqC;CACrC,MAAM,eAAgB,OAA8C;CAEpE,IAAI,CAAC,gBAAgB,OAAO,iBAAiB,UAC3C;CAGF,MAAM,iBAAkB,aAAyC;CAEjE,IAAI,CAAC,kBAAkB,OAAO,mBAAmB,UAC/C;CAGF,MAAM,UAAW,eAA2C;CAE5D,IAAI,OAAO,YAAY,YACrB;CAGF,IAAI;EACF,MAAM,SAAU,QAAqD,KAAK,gBAAgB,EACxF,OACF,CAAC;EAED,IAAI,UAAU,OAAO,WAAW,UAC9B,OAAO;CAEX,QAAQ,CAER;AAGF;;;;;;;;AASA,SAAS,yBACP,cACqC;CAGrC,KAAK,MAAM,OAAO,CAFK,cAAc,aAEP,GAAG;EAC/B,MAAM,QAAQ,aAAa;EAE3B,IAAI,OAAO,UAAU,YAAY;GAC/B,IAAI;IACF,MAAM,SAAU,MAAwB,KAAK,YAAY;IAEzD,IAAI,UAAU,OAAO,WAAW,UAC9B,OAAO;GAEX,QAAQ,CAER;GAEA;EACF;EAEA,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO;CAEX;AAGF"}

package/esm/ai/src/utils/prepare-attachment-part.mjs

@@ -1,232 +0,0 @@
-import { InvalidRequestError } from "../errors/invalid-request-error.mjs";
-import { OutboundPolicyError } from "../errors/outbound-policy-error.mjs";
-import "../errors/index.mjs";
-import { fetchTextWithPolicy } from "../security/outbound-policy.mjs";
-import { resolveAttachment } from "./resolve-attachment.mjs";
-import { extname, isAbsolute, relative, resolve } from "node:path";
-import { readFile } from "node:fs/promises";
-
-//#region ../@warlock.js/ai/src/utils/prepare-attachment-part.ts
-const IMAGE_EXTENSIONS_TO_MEDIA_TYPE = {
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".webp": "image/webp",
-	".gif": "image/gif"
-};
-const TEXT_EXTENSIONS = new Set([".txt"]);
-const AUDIO_EXTENSIONS_TO_MEDIA_TYPE = {
-	".mp3": "audio/mpeg",
-	".wav": "audio/wav",
-	".m4a": "audio/mp4",
-	".ogg": "audio/ogg",
-	".weba": "audio/webm"
-};
-const PDF_EXTENSIONS = new Set([".pdf"]);
-/**
-* Convert a user-supplied `Attachment` into a provider-ready
-* `ContentPart` the model adapter can consume without doing any I/O of
-* its own.
-*
-* Kind resolution:
-* - Tagged `{ type: "image", source }` / `{ type: "text", source }`
-*   trusts the caller's intent.
-* - Shorthand (raw string / `StorageFileShape`) infers from the file
-*   extension. Image extensions (`.png`/`.jpg`/`.jpeg`/`.webp`/`.gif`)
-*   map to `"image"`. `.txt` maps to `"text"`. Anything else throws
-*   `InvalidRequestError` — silent inference on ambiguous inputs
-*   causes silent bugs.
-*
-* Local paths are read from disk; images are base64-encoded inline,
-* text files are read as UTF-8 strings and returned as a `text`
-* `ContentPart`. Remote URLs for image attachments are passed through
-* unchanged; remote URLs for text attachments are fetched so the
-* adapter never needs network access.
-*
-* @example
-* await prepareAttachmentPart("./photo.png");
-* // → { type: "image", source: { base64: "...", mediaType: "image/png" } }
-*
-* @example
-* await prepareAttachmentPart({ type: "text", source: "./notes.txt" });
-* // → { type: "text", text: "<file contents>" }
-*
-* **Trust boundary (S1).** Attachment references are often user-controlled,
-* so server-side I/O is policy-gated by `policy` ({@link AttachmentPolicy}):
-* remote text fetches are default-deny and, when enabled, run through the
-* shared `OutboundPolicy` (scheme/host/private-IP/max-bytes/timeout); local
-* reads honor an `allowedRoots` sandbox; bare-string local paths warn
-* (staged deprecation). URL *image* attachments are passed to the provider
-* untouched (never fetched here).
-*/
-async function prepareAttachmentPart(attachment, policy) {
-	const kind = resolveKind(attachment);
-	const bareString = typeof attachment === "string";
-	if (kind === "text") return prepareTextPart(attachment, policy, bareString);
-	if (kind === "image") return prepareImagePart(attachment, policy, bareString);
-	return prepareBinaryPart(attachment, kind, policy, bareString);
-}
-/**
-* Decide whether the attachment is text or image. Tagged forms win
-* immediately; for shorthand we inspect the extension. Throws if the
-* shorthand doesn't look like anything we recognize.
-*/
-function resolveKind(attachment) {
-	if (isTaggedAttachment(attachment)) return attachment.type;
-	const path = extractPath(attachment);
-	const extension = path ? extname(stripQuery(path)).toLowerCase() : "";
-	if (IMAGE_EXTENSIONS_TO_MEDIA_TYPE[extension]) return "image";
-	if (TEXT_EXTENSIONS.has(extension)) return "text";
-	if (PDF_EXTENSIONS.has(extension)) return "pdf";
-	if (AUDIO_EXTENSIONS_TO_MEDIA_TYPE[extension]) return "audio";
-	throw new InvalidRequestError("Cannot infer attachment type from input — pass an explicit `{ type: 'image' | 'text' | 'pdf' | 'audio', source: ... }` or use a recognized extension (.png, .jpg, .jpeg, .webp, .gif, .txt, .pdf, .mp3, .wav, .m4a, .ogg, .weba)");
-}
-/**
-* Produce a `pdf` / `audio` ContentPart (A2). URLs pass through; local
-* paths are read and base64-encoded with a media type inferred from the
-* kind (`application/pdf`) or extension (audio); inline base64 passes
-* through. Same `AttachmentPolicy` gating as image/text reads.
-*/
-async function prepareBinaryPart(attachment, kind, policy, bareString) {
-	const resolved = resolveAttachment(attachment);
-	if (resolved.type === "url") return {
-		type: kind,
-		source: { url: resolved.value }
-	};
-	if (resolved.type === "base64") return {
-		type: kind,
-		source: {
-			base64: resolved.value,
-			mediaType: resolved.mediaType
-		}
-	};
-	const mediaType = kind === "pdf" ? "application/pdf" : inferAudioMediaType(resolved.value);
-	if (!mediaType) throw new InvalidRequestError(`Cannot infer media type for ${kind} path "${resolved.value}" — use a recognized extension or pass \`{ type: '${kind}', source: { base64, mediaType } }\``, { context: { path: resolved.value } });
-	enforceLocalPathPolicy(resolved.value, bareString, policy);
-	return {
-		type: kind,
-		source: {
-			base64: (await readFile(resolved.value)).toString("base64"),
-			mediaType
-		}
-	};
-}
-/** Infer an audio media type from a path's extension. */
-function inferAudioMediaType(path) {
-	return AUDIO_EXTENSIONS_TO_MEDIA_TYPE[extname(stripQuery(path)).toLowerCase()];
-}
-/**
-* Produce an `image` ContentPart. URLs pass through; paths are
-* read from disk and base64-encoded with an inferred media type.
-* Inline base64 attachments pass through unchanged.
-*/
-async function prepareImagePart(attachment, policy, bareString) {
-	const inferredMediaType = isTaggedAttachment(attachment) ? void 0 : inferImageMediaType(attachment);
-	const resolved = resolveAttachment(attachment);
-	if (resolved.type === "url") return {
-		type: "image",
-		source: { url: resolved.value }
-	};
-	if (resolved.type === "base64") return {
-		type: "image",
-		source: {
-			base64: resolved.value,
-			mediaType: resolved.mediaType
-		}
-	};
-	const mediaType = inferredMediaType ?? inferImageMediaType(resolved.value);
-	if (!mediaType) throw new InvalidRequestError(`Cannot infer media type for path "${resolved.value}" — use a recognized image extension or pass \`{ type: 'image', source: { base64, mediaType } }\``, { context: { path: resolved.value } });
-	enforceLocalPathPolicy(resolved.value, bareString, policy);
-	return {
-		type: "image",
-		source: {
-			base64: (await readFile(resolved.value)).toString("base64"),
-			mediaType
-		}
-	};
-}
-/**
-* Produce a `text` ContentPart. URLs are fetched as UTF-8, paths are
-* read from disk as UTF-8, inline base64 is decoded to UTF-8. The
-* result joins the conversation as an additional text part the model
-* sees before responding.
-*/
-async function prepareTextPart(attachment, policy, bareString) {
-	const resolved = resolveAttachment(attachment);
-	if (resolved.type === "url") {
-		if (!policy?.allowRemoteFetch) throw new OutboundPolicyError(`remote text attachment fetch is disabled by default — set \`attachmentPolicy.allowRemoteFetch: true\` (with an \`outbound\` policy) to fetch "${resolved.value}"`, { context: { url: resolved.value } });
-		const result = await fetchTextWithPolicy(resolved.value, policy.outbound ?? {});
-		if (!result.ok) throw new InvalidRequestError(`Failed to fetch text attachment "${resolved.value}" — status ${result.status}`, { context: {
-			url: resolved.value,
-			status: result.status
-		} });
-		return {
-			type: "text",
-			text: result.text
-		};
-	}
-	if (resolved.type === "base64") return {
-		type: "text",
-		text: Buffer.from(resolved.value, "base64").toString("utf8")
-	};
-	enforceLocalPathPolicy(resolved.value, bareString, policy);
-	return {
-		type: "text",
-		text: await readFile(resolved.value, "utf8")
-	};
-}
-/** Process-lifetime flag so the bare-string deprecation warns at most once. */
-let warnedBareLocalPath = false;
-/**
-* Enforce the local-file half of {@link AttachmentPolicy} (S1):
-*
-* - **Bare-string local paths** are staged for deprecation. With
-*   `allowBareLocalPaths: false` they hard-deny now; otherwise they warn
-*   once (outside tests) — the typed `StorageFile.absolutePath` route is
-*   the supported way to read a local file.
-* - **`allowedRoots` sandbox** — when set, the resolved path must live
-*   inside one of the roots, else the read is refused.
-*/
-function enforceLocalPathPolicy(path, bareString, policy) {
-	if (bareString) {
-		if (policy?.allowBareLocalPaths === false) throw new OutboundPolicyError(`local file attachment via a bare string path ("${path}") is disabled — pass a typed \`{ type, source: { absolutePath } }\` StorageFile, or set \`attachmentPolicy.allowBareLocalPaths: true\``, { context: { path } });
-		if (!warnedBareLocalPath && !process.env.VITEST && process.env.NODE_ENV !== "test") {
-			warnedBareLocalPath = true;
-			console.warn("[warlock-ai] reading a local file attachment from a bare string path is deprecated and will be denied by default in a future minor. Pass a typed `{ type, source: { absolutePath } }` StorageFile and confine reads with `attachmentPolicy.allowedRoots`.");
-		}
-	}
-	const roots = policy?.allowedRoots;
-	if (roots && roots.length > 0) {
-		const target = resolve(path);
-		if (!roots.some((root) => {
-			const rel = relative(resolve(root), target);
-			return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-		})) throw new OutboundPolicyError(`local file attachment "${path}" is outside the allowed roots`, { context: {
-			path,
-			allowedRoots: roots
-		} });
-	}
-}
-function isTaggedAttachment(attachment) {
-	return typeof attachment === "object" && attachment !== null && "type" in attachment;
-}
-function inferImageMediaType(input) {
-	const path = extractPath(input);
-	if (!path) return;
-	return IMAGE_EXTENSIONS_TO_MEDIA_TYPE[extname(stripQuery(path)).toLowerCase()];
-}
-function extractPath(input) {
-	if (typeof input === "string") return input;
-	if (typeof input === "object" && input !== null) {
-		const storage = input;
-		return storage.url ?? storage.absolutePath;
-	}
-}
-function stripQuery(path) {
-	const queryIndex = path.indexOf("?");
-	return queryIndex === -1 ? path : path.slice(0, queryIndex);
-}
-
-//#endregion
-export { prepareAttachmentPart };
-//# sourceMappingURL=prepare-attachment-part.mjs.map

package/esm/ai/src/utils/prepare-attachment-part.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepare-attachment-part.mjs","names":["resolvePath"],"sources":["../../../../../../../../../@warlock.js/ai/src/utils/prepare-attachment-part.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\nimport { extname, isAbsolute, relative, resolve as resolvePath } from \"node:path\";\nimport type { AttachmentPolicy } from \"../contracts/attachment-policy.type\";\nimport type { Attachment } from \"../contracts/attachment.type\";\nimport type { ContentPart } from \"../contracts/content-part.type\";\nimport { InvalidRequestError, OutboundPolicyError } from \"../errors\";\nimport { fetchTextWithPolicy } from \"../security/outbound-policy\";\nimport { resolveAttachment } from \"./resolve-attachment\";\n\nconst IMAGE_EXTENSIONS_TO_MEDIA_TYPE: Record<string, string> = {\n  \".png\": \"image/png\",\n  \".jpg\": \"image/jpeg\",\n  \".jpeg\": \"image/jpeg\",\n  \".webp\": \"image/webp\",\n  \".gif\": \"image/gif\",\n};\n\nconst TEXT_EXTENSIONS = new Set([\".txt\"]);\n\nconst AUDIO_EXTENSIONS_TO_MEDIA_TYPE: Record<string, string> = {\n  \".mp3\": \"audio/mpeg\",\n  \".wav\": \"audio/wav\",\n  \".m4a\": \"audio/mp4\",\n  \".ogg\": \"audio/ogg\",\n  \".weba\": \"audio/webm\",\n};\n\nconst PDF_EXTENSIONS = new Set([\".pdf\"]);\n\ntype AttachmentKind = \"image\" | \"text\" | \"pdf\" | \"audio\";\n\n/**\n * Convert a user-supplied `Attachment` into a provider-ready\n * `ContentPart` the model adapter can consume without doing any I/O of\n * its own.\n *\n * Kind resolution:\n * - Tagged `{ type: \"image\", source }` / `{ type: \"text\", source }`\n *   trusts the caller's intent.\n * - Shorthand (raw string / `StorageFileShape`) infers from the file\n *   extension. Image extensions (`.png`/`.jpg`/`.jpeg`/`.webp`/`.gif`)\n *   map to `\"image\"`. `.txt` maps to `\"text\"`. Anything else throws\n *   `InvalidRequestError` — silent inference on ambiguous inputs\n *   causes silent bugs.\n *\n * Local paths are read from disk; images are base64-encoded inline,\n * text files are read as UTF-8 strings and returned as a `text`\n * `ContentPart`. Remote URLs for image attachments are passed through\n * unchanged; remote URLs for text attachments are fetched so the\n * adapter never needs network access.\n *\n * @example\n * await prepareAttachmentPart(\"./photo.png\");\n * // → { type: \"image\", source: { base64: \"...\", mediaType: \"image/png\" } }\n *\n * @example\n * await prepareAttachmentPart({ type: \"text\", source: \"./notes.txt\" });\n * // → { type: \"text\", text: \"<file contents>\" }\n *\n * **Trust boundary (S1).** Attachment references are often user-controlled,\n * so server-side I/O is policy-gated by `policy` ({@link AttachmentPolicy}):\n * remote text fetches are default-deny and, when enabled, run through the\n * shared `OutboundPolicy` (scheme/host/private-IP/max-bytes/timeout); local\n * reads honor an `allowedRoots` sandbox; bare-string local paths warn\n * (staged deprecation). URL *image* attachments are passed to the provider\n * untouched (never fetched here).\n */\nexport async function prepareAttachmentPart(\n  attachment: Attachment,\n  policy?: AttachmentPolicy,\n): Promise<ContentPart> {\n  const kind = resolveKind(attachment);\n  const bareString = typeof attachment === \"string\";\n\n  if (kind === \"text\") {\n    return prepareTextPart(attachment, policy, bareString);\n  }\n\n  if (kind === \"image\") {\n    return prepareImagePart(attachment, policy, bareString);\n  }\n\n  return prepareBinaryPart(attachment, kind, policy, bareString);\n}\n\n/**\n * Decide whether the attachment is text or image. Tagged forms win\n * immediately; for shorthand we inspect the extension. Throws if the\n * shorthand doesn't look like anything we recognize.\n */\nfunction resolveKind(attachment: Attachment): AttachmentKind {\n  if (isTaggedAttachment(attachment)) {\n    return attachment.type;\n  }\n\n  const path = extractPath(attachment);\n  const extension = path ? extname(stripQuery(path)).toLowerCase() : \"\";\n\n  if (IMAGE_EXTENSIONS_TO_MEDIA_TYPE[extension]) {\n    return \"image\";\n  }\n\n  if (TEXT_EXTENSIONS.has(extension)) {\n    return \"text\";\n  }\n\n  if (PDF_EXTENSIONS.has(extension)) {\n    return \"pdf\";\n  }\n\n  if (AUDIO_EXTENSIONS_TO_MEDIA_TYPE[extension]) {\n    return \"audio\";\n  }\n\n  throw new InvalidRequestError(\n    \"Cannot infer attachment type from input — pass an explicit `{ type: 'image' | 'text' | 'pdf' | 'audio', source: ... }` or use a recognized extension (.png, .jpg, .jpeg, .webp, .gif, .txt, .pdf, .mp3, .wav, .m4a, .ogg, .weba)\",\n  );\n}\n\n/**\n * Produce a `pdf` / `audio` ContentPart (A2). URLs pass through; local\n * paths are read and base64-encoded with a media type inferred from the\n * kind (`application/pdf`) or extension (audio); inline base64 passes\n * through. Same `AttachmentPolicy` gating as image/text reads.\n */\nasync function prepareBinaryPart(\n  attachment: Attachment,\n  kind: \"pdf\" | \"audio\",\n  policy: AttachmentPolicy | undefined,\n  bareString: boolean,\n): Promise<ContentPart> {\n  const resolved = resolveAttachment(attachment);\n\n  if (resolved.type === \"url\") {\n    return { type: kind, source: { url: resolved.value } };\n  }\n\n  if (resolved.type === \"base64\") {\n    return { type: kind, source: { base64: resolved.value, mediaType: resolved.mediaType } };\n  }\n\n  const mediaType =\n    kind === \"pdf\" ? \"application/pdf\" : inferAudioMediaType(resolved.value);\n\n  if (!mediaType) {\n    throw new InvalidRequestError(\n      `Cannot infer media type for ${kind} path \"${resolved.value}\" — use a recognized extension or pass ` +\n        `\\`{ type: '${kind}', source: { base64, mediaType } }\\``,\n      { context: { path: resolved.value } },\n    );\n  }\n\n  enforceLocalPathPolicy(resolved.value, bareString, policy);\n  const bytes = await readFile(resolved.value);\n\n  return { type: kind, source: { base64: bytes.toString(\"base64\"), mediaType } };\n}\n\n/** Infer an audio media type from a path's extension. */\nfunction inferAudioMediaType(path: string): string | undefined {\n  return AUDIO_EXTENSIONS_TO_MEDIA_TYPE[extname(stripQuery(path)).toLowerCase()];\n}\n\n/**\n * Produce an `image` ContentPart. URLs pass through; paths are\n * read from disk and base64-encoded with an inferred media type.\n * Inline base64 attachments pass through unchanged.\n */\nasync function prepareImagePart(\n  attachment: Attachment,\n  policy: AttachmentPolicy | undefined,\n  bareString: boolean,\n): Promise<ContentPart> {\n  const inferredMediaType = isTaggedAttachment(attachment)\n    ? undefined\n    : inferImageMediaType(attachment);\n\n  const resolved = resolveAttachment(attachment);\n\n  if (resolved.type === \"url\") {\n    // URL images are handed to the provider as a URL — the provider\n    // fetches them, not us — so there's no server-side SSRF surface here.\n    return { type: \"image\", source: { url: resolved.value } };\n  }\n\n  if (resolved.type === \"base64\") {\n    return {\n      type: \"image\",\n      source: { base64: resolved.value, mediaType: resolved.mediaType },\n    };\n  }\n\n  const mediaType = inferredMediaType ?? inferImageMediaType(resolved.value);\n\n  if (!mediaType) {\n    throw new InvalidRequestError(\n      `Cannot infer media type for path \"${resolved.value}\" — use a recognized image extension or pass ` +\n        \"`{ type: 'image', source: { base64, mediaType } }`\",\n      { context: { path: resolved.value } },\n    );\n  }\n\n  enforceLocalPathPolicy(resolved.value, bareString, policy);\n  const bytes = await readFile(resolved.value);\n\n  return {\n    type: \"image\",\n    source: { base64: bytes.toString(\"base64\"), mediaType },\n  };\n}\n\n/**\n * Produce a `text` ContentPart. URLs are fetched as UTF-8, paths are\n * read from disk as UTF-8, inline base64 is decoded to UTF-8. The\n * result joins the conversation as an additional text part the model\n * sees before responding.\n */\nasync function prepareTextPart(\n  attachment: Attachment,\n  policy: AttachmentPolicy | undefined,\n  bareString: boolean,\n): Promise<ContentPart> {\n  const resolved = resolveAttachment(attachment);\n\n  if (resolved.type === \"url\") {\n    // Default-deny: a remote text attachment is a server-side fetch of\n    // user-controlled input — refuse unless the app explicitly opted in,\n    // then run it through the shared OutboundPolicy (scheme/host/private-\n    // IP/max-bytes/timeout).\n    if (!policy?.allowRemoteFetch) {\n      throw new OutboundPolicyError(\n        `remote text attachment fetch is disabled by default — set \\`attachmentPolicy.allowRemoteFetch: true\\` (with an \\`outbound\\` policy) to fetch \"${resolved.value}\"`,\n        { context: { url: resolved.value } },\n      );\n    }\n\n    const result = await fetchTextWithPolicy(resolved.value, policy.outbound ?? {});\n\n    if (!result.ok) {\n      throw new InvalidRequestError(\n        `Failed to fetch text attachment \"${resolved.value}\" — status ${result.status}`,\n        { context: { url: resolved.value, status: result.status } },\n      );\n    }\n\n    return { type: \"text\", text: result.text };\n  }\n\n  if (resolved.type === \"base64\") {\n    const decoded = Buffer.from(resolved.value, \"base64\").toString(\"utf8\");\n\n    return { type: \"text\", text: decoded };\n  }\n\n  enforceLocalPathPolicy(resolved.value, bareString, policy);\n  const bytes = await readFile(resolved.value, \"utf8\");\n\n  return { type: \"text\", text: bytes };\n}\n\n/** Process-lifetime flag so the bare-string deprecation warns at most once. */\nlet warnedBareLocalPath = false;\n\n/**\n * Enforce the local-file half of {@link AttachmentPolicy} (S1):\n *\n * - **Bare-string local paths** are staged for deprecation. With\n *   `allowBareLocalPaths: false` they hard-deny now; otherwise they warn\n *   once (outside tests) — the typed `StorageFile.absolutePath` route is\n *   the supported way to read a local file.\n * - **`allowedRoots` sandbox** — when set, the resolved path must live\n *   inside one of the roots, else the read is refused.\n */\nfunction enforceLocalPathPolicy(\n  path: string,\n  bareString: boolean,\n  policy: AttachmentPolicy | undefined,\n): void {\n  if (bareString) {\n    if (policy?.allowBareLocalPaths === false) {\n      throw new OutboundPolicyError(\n        `local file attachment via a bare string path (\"${path}\") is disabled — pass a typed \\`{ type, source: { absolutePath } }\\` StorageFile, or set \\`attachmentPolicy.allowBareLocalPaths: true\\``,\n        { context: { path } },\n      );\n    }\n\n    if (!warnedBareLocalPath && !process.env.VITEST && process.env.NODE_ENV !== \"test\") {\n      warnedBareLocalPath = true;\n      console.warn(\n        \"[warlock-ai] reading a local file attachment from a bare string path is deprecated and will be denied by default in a future minor. \" +\n          \"Pass a typed `{ type, source: { absolutePath } }` StorageFile and confine reads with `attachmentPolicy.allowedRoots`.\",\n      );\n    }\n  }\n\n  const roots = policy?.allowedRoots;\n  if (roots && roots.length > 0) {\n    const target = resolvePath(path);\n    const inside = roots.some(root => {\n      const rel = relative(resolvePath(root), target);\n      return rel === \"\" || (!rel.startsWith(\"..\") && !isAbsolute(rel));\n    });\n\n    if (!inside) {\n      throw new OutboundPolicyError(\n        `local file attachment \"${path}\" is outside the allowed roots`,\n        { context: { path, allowedRoots: roots } },\n      );\n    }\n  }\n}\n\nfunction isTaggedAttachment(\n  attachment: Attachment,\n): attachment is Extract<Attachment, { type: string }> {\n  return (\n    typeof attachment === \"object\" &&\n    attachment !== null &&\n    \"type\" in attachment\n  );\n}\n\nfunction inferImageMediaType(input: unknown): string | undefined {\n  const path = extractPath(input);\n\n  if (!path) {\n    return undefined;\n  }\n\n  const extension = extname(stripQuery(path)).toLowerCase();\n\n  return IMAGE_EXTENSIONS_TO_MEDIA_TYPE[extension];\n}\n\nfunction extractPath(input: unknown): string | undefined {\n  if (typeof input === \"string\") {\n    return input;\n  }\n\n  if (typeof input === \"object\" && input !== null) {\n    const storage = input as { url?: string; absolutePath?: string };\n    return storage.url ?? storage.absolutePath;\n  }\n\n  return undefined;\n}\n\nfunction stripQuery(path: string): string {\n  const queryIndex = path.indexOf(\"?\");\n\n  return queryIndex === -1 ? path : path.slice(0, queryIndex);\n}\n"],"mappings":"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"}

package/esm/ai/src/utils/resolve-attachment.mjs

@@ -1,74 +0,0 @@
-import { InvalidRequestError } from "../errors/invalid-request-error.mjs";
-import "../errors/index.mjs";
-
-//#region ../@warlock.js/ai/src/utils/resolve-attachment.ts
-const REMOTE_URL_PATTERN = /^https?:\/\//i;
-/**
-* Normalize a user-supplied `Attachment` (or bare `AttachmentSource`)
-* into a `ResolvedAttachment` the agent can hand to file-reading code
-* without re-discriminating the input variant.
-*
-* Resolution rules:
-* - `{ base64, mediaType }` → `{ type: "base64", value, mediaType }`.
-* - `StorageFileShape` (`{ url?, absolutePath? }`) → `absolutePath` wins
-*   over `url` when both are present (prefer the local file over an extra
-*   remote hop). Absolute path becomes `{ type: "path" }`; url becomes
-*   `{ type: "url" }`.
-* - String starting with `http://` / `https://` → `{ type: "url" }`.
-* - Any other string → `{ type: "path" }`.
-* - Tagged `{ type: "image" | "text", source }` → recurses into `source`.
-*
-* Throws `InvalidRequestError` on obviously invalid input (empty
-* string, storage object with neither url nor absolutePath, missing
-* source field).
-*
-* @example
-* resolveAttachment("https://cdn.example.com/doc.pdf");
-* // → { type: "url", value: "https://cdn.example.com/doc.pdf" }
-*
-* @example
-* resolveAttachment({ type: "image", source: "/tmp/x.png" });
-* // → { type: "path", value: "/tmp/x.png" }
-*/
-function resolveAttachment(attachment) {
-	if (typeof attachment === "object" && attachment !== null && "type" in attachment) return resolveSource(attachment.source);
-	return resolveSource(attachment);
-}
-function resolveSource(source) {
-	if (typeof source === "string") {
-		if (!source) throw new InvalidRequestError("Cannot resolve empty attachment string");
-		if (REMOTE_URL_PATTERN.test(source)) return {
-			type: "url",
-			value: source
-		};
-		return {
-			type: "path",
-			value: source
-		};
-	}
-	if ("url" in source || "absolutePath" in source) {
-		const storage = source;
-		if (storage.absolutePath) return {
-			type: "path",
-			value: storage.absolutePath
-		};
-		if (storage.url) return {
-			type: "url",
-			value: storage.url
-		};
-		throw new InvalidRequestError("Storage attachment has neither url nor absolutePath");
-	}
-	if ("base64" in source) {
-		if (!source.base64 || !source.mediaType) throw new InvalidRequestError("Inline attachment requires both `base64` and `mediaType`");
-		return {
-			type: "base64",
-			value: source.base64,
-			mediaType: source.mediaType
-		};
-	}
-	throw new InvalidRequestError("Unrecognized attachment source — expected a string path/URL, a StorageFile, or `{ base64, mediaType }`");
-}
-
-//#endregion
-export { resolveAttachment };
-//# sourceMappingURL=resolve-attachment.mjs.map