@redstone-md/mapr 0.0.1-alpha → 0.0.2-alpha

package/README.md

@@ -1,69 +1,116 @@
 # Mapr
 
-Mapr is a Bun-native CLI/TUI for reverse-engineering frontend websites and build outputs. It crawls a target site, downloads related code artifacts, formats them for readability, runs a communicating AI swarm over chunked artifact content, and produces a Markdown analysis report with entry points, initialization flow, inferred call graph edges, restored names, investigation tips, and artifact summaries.
+Mapr is a Bun-native CLI/TUI for reverse-engineering frontend websites and build outputs. It crawls a target site, collects analyzable frontend artifacts, runs a multi-agent AI analysis pipeline over chunked code, and writes a Markdown report with entry points, initialization flow, inferred call graph edges, restored names, artifact summaries, and investigation tips.
+
+This repository is public for source visibility and collaboration. The license remains source-available and restricted. Read the contribution and license sections before reusing or contributing to the codebase.
+
+## Highlights
+
+- Bun-only CLI/TUI with interactive setup through `@clack/prompts`
+- OpenAI and OpenAI-compatible provider support
+- Built-in provider presets for BlackBox AI, Nvidia NIM, and OnlySQ
+- Model discovery with searchable selection
+- Automatic context-window detection from provider model metadata when available
+- Same-origin crawler with bounded page count and crawl depth
+- JS bundle, worker, service worker, WASM, and source-map discovery
+- Iframe-aware crawling for same-origin embedded pages
+- Local RAG mode for multi-megabyte bundles
+- Partial-report persistence when analysis fails mid-run
+- Headless automation mode for CI or batch workflows
 
 ## What It Analyzes
 
-- HTML entry pages and linked same-origin pages
-- JavaScript bundles and imported chunks
+- HTML entry pages and linked same-origin pages for discovery
+- JavaScript bundles, imported chunks, and inline bootstraps
 - Service workers and worker scripts
-- Stylesheets and manifests
-- Referenced WASM modules through binary summaries
-- Cross-linked website artifacts discovered from page code
+- WASM modules through binary summaries
+- Source maps and extracted original sources when available
+- Same-origin iframe pages and the JS/WASM artifacts discovered inside them
 - Optional local lexical RAG for oversized artifacts such as multi-megabyte bundles
 
+Mapr does not analyze images, fonts, audio, video, PDFs, archives, or other presentation/binary assets.
+
 ## Runtime
 
 - Bun only
 - TypeScript in strict mode
 - Interactive terminal UX with `@clack/prompts`
 - AI analysis through Vercel AI SDK using OpenAI or OpenAI-compatible providers
+- Built-in OpenAI-compatible presets for BlackBox AI, Nvidia NIM, and OnlySQ
+- Automatic model context-size detection from provider model metadata when available
 - Headless CLI mode for automation
-- Live swarm progress with agent-level tracking and progress bars
+- Live crawler and swarm progress with agent-level tracking and progress bars
+
+## Install
+
+Local development:
+
+```bash
+bun install
+bun run index.ts
+```
+
+Published package usage:
+
+```bash
+npx @redstone-md/mapr --help
+```
 
 ## Workflow
 
 1. Load or configure AI provider settings from `~/.mapr/config.json`
-2. Discover models from the provider `/models` endpoint
-3. Let the user search and select a model, then save the model context size
-4. Crawl the target website and fetch related artifacts
+2. Discover models from the provider catalog endpoint
+3. Let the user search and select a model, auto-detect the model context size when possible, and fall back to a manual prompt when needed
+4. Crawl the target website, same-origin iframe pages, and discovered code artifacts with bounded page count and crawl depth
 5. Format analyzable content where possible
 6. Optionally build a local lexical RAG index for oversized artifacts
-7. Run a communicating swarm of analysis agents over chunked artifact content
+7. Run a communicating swarm of analysis agents over chunked artifact content with structured-output fallback for providers that only support plain text
 8. Generate a Markdown report in the current working directory
 
-## Quick Start
+## Provider Presets
 
-```bash
-bun install
-bun run index.ts
-```
+- `blackbox` -> `https://api.blackbox.ai`
+- `nvidia-nim` -> `https://integrate.api.nvidia.com/v1`
+- `onlysq` -> `https://api.onlysq.ru/ai/openai`
+- `custom` -> any other OpenAI-compatible endpoint
+
+## Usage
 
-If the package is published and Bun is installed locally:
+Interactive:
 
 ```bash
-npx @redstone-md/mapr --help
+bun start
 ```
 
-## Headless Examples
+Headless:
 
 ```bash
 npx @redstone-md/mapr \
   --headless \
   --url http://localhost:5178 \
-  --provider-type openai-compatible \
-  --provider-name "Local vLLM" \
+  --provider-preset onlysq \
   --api-key secret \
-  --base-url http://localhost:8000/v1 \
-  --model qwen2.5-coder \
+  --model mistralai/devstral-small-2507 \
   --context-size 512000 \
-  --local-rag
+  --local-rag \
+  --max-depth 3
 ```
 
+List models with detected context sizes when available:
+
 ```bash
-npx @redstone-md/mapr --list-models --headless --provider-type openai-compatible --api-key secret --base-url http://localhost:8000/v1
+npx @redstone-md/mapr --list-models --headless --provider-preset nvidia-nim --api-key secret
 ```
 
+Useful flags:
+
+- `--max-pages <n>` limits same-origin HTML pages
+- `--max-artifacts <n>` limits total fetched analyzable artifacts
+- `--max-depth <n>` limits crawler hop depth from the entry page
+- `--local-rag` enables local lexical retrieval for oversized bundles
+- `--verbose-agents` prints swarm completion events as they finish
+- `--reconfigure` forces provider setup even if config already exists
+
 ## Swarm Design
 
 Mapr uses a communicating agent swarm per chunk:
@@ -74,22 +121,32 @@ Mapr uses a communicating agent swarm per chunk:
 - `security`: identifies risks, persistence, caching, and operator tips
 - `synthesizer`: merges the upstream notes into the final chunk analysis
 
-Progress is shown as a task progress bar plus agent/chunk status updates.
+Progress is shown directly in the TUI for crawler fetches, depth skips, discovered nested artifacts, and swarm agent/chunk execution.
 
 ## Large Bundle Handling
 
 - Mapr stores the selected model context size and derives a larger chunk budget from it.
+- When a provider exposes context metadata in its model catalog, Mapr saves that value automatically.
 - Optional `--local-rag` mode builds a local lexical retrieval index so very large artifacts such as 5 MB bundles can feed more relevant sibling segments into the swarm without forcing the whole file into one prompt.
 - Formatting no longer has a hard artifact-size cutoff. If formatting fails, Mapr falls back to raw content instead of skipping by size.
 
 ## Output
 
-Each run writes a file named like:
+Each run writes a Markdown file named like:
 
 ```text
 report-example.com-2026-03-15T12-34-56-789Z.md
 ```
 
+If analysis fails after artifact discovery or formatting has already completed, Mapr still writes a partial report and includes the analysis error in the document.
+
+## Limitations
+
+- AI-generated call graphs and symbol renames are inferred, not authoritative.
+- WASM analysis is summary-based unless deeper lifting/disassembly is added.
+- Crawl scope is intentionally bounded by same-origin policy, page limits, artifact limits, and depth limits.
+- Very large or heavily obfuscated bundles still depend on model quality and provider behavior.
+
 ## Disclaimer
 
 - Mapr produces assisted reverse-engineering output, not a formal proof of program behavior.
@@ -99,7 +156,7 @@ report-example.com-2026-03-15T12-34-56-789Z.md
 
 ## Contribution Terms
 
-- This project is source-available and closed-license, not open source.
+- This project is public and source-available, but it is not open source.
 - Contributions are accepted only under the repository owner’s terms.
 - By submitting a contribution, you agree that the maintainer may use, modify, relicense, and redistribute your contribution as part of Mapr without compensation.
 - Do not submit code unless you have the rights to contribute it.

package/index.ts

@@ -4,8 +4,9 @@ import { cancel, confirm, intro, isCancel, log, outro, spinner, text } from "@cl
 import pc from "picocolors";
 import packageJson from "./package.json";
 
-import { AiBundleAnalyzer, PartialAnalysisError, buildAnalysisSnapshot, chunkTextByBytes, deriveChunkSizeBytes } from "./lib/ai-analyzer";
-import { parseCliArgs, getConfigOverrides, renderHelpText } from "./lib/cli-args";
+import { buildAnalysisSnapshot, PartialAnalysisError } from "./lib/analysis-schema";
+import { AiBundleAnalyzer, chunkTextByBytes, deriveChunkSizeBytes } from "./lib/ai-analyzer";
+import { getConfigOverrides, parseCliArgs, renderHelpText } from "./lib/cli-args";
 import { ConfigManager } from "./lib/config";
 import { BundleFormatter } from "./lib/formatter";
 import { renderProgressBar } from "./lib/progress";
@@ -98,8 +99,12 @@ async function run(): Promise<void> {
   }
 
   if (args.listModels) {
-    const models = await configManager.listModels(await configManager.resolveConfigDraft(configOverrides));
-    console.log(models.join("\n"));
+    const models = await configManager.listModelCatalog(await configManager.resolveConfigDraft(configOverrides));
+    console.log(
+      models
+        .map((model) => (model.contextSize ? `${model.id}\t${model.contextSize}` : model.id))
+        .join("\n"),
+    );
     return;
   }
 
@@ -116,6 +121,10 @@ async function run(): Promise<void> {
   const scraper = new BundleScraper(fetch, {
     maxPages: args.maxPages,
     maxArtifacts: args.maxArtifacts,
+    maxDepth: args.maxDepth,
+    onProgress(event) {
+      scrapeStep.message(event.message);
+    },
   });
   const scrapeResult = await scraper.scrape(targetUrl);
   scrapeStep.stop(

package/lib/ai-analyzer.ts

@@ -1,7 +1,19 @@
-import { generateText, Output } from "ai";
-import { Buffer } from "buffer";
 import { z } from "zod";
+import { Buffer } from "buffer";
 
+import {
+  agentMemoSchema,
+  artifactSummarySchema,
+  buildAnalysisSnapshot,
+  chunkAnalysisSchema,
+  finalAnalysisSchema,
+  type AgentMemo,
+  type ArtifactSummary,
+  type BundleAnalysis,
+  type ChunkAnalysis,
+  PartialAnalysisError,
+} from "./analysis-schema";
+import { generateObjectWithTextFallback } from "./ai-json";
 import { artifactTypeSchema } from "./artifacts";
 import type { FormattedArtifact } from "./formatter";
 import { LocalArtifactRag } from "./local-rag";
@@ -10,63 +22,6 @@ import { SWARM_AGENT_ORDER, getGlobalMissionPrompt, getSwarmAgentPrompt, type Sw
 
 export const DEFAULT_CHUNK_SIZE_BYTES = 80 * 1024;
 
-const entryPointSchema = z.object({
-  symbol: z.string().min(1),
-  description: z.string().min(1),
-  evidence: z.string().min(1),
-});
-
-const callGraphEdgeSchema = z.object({
-  caller: z.string().min(1),
-  callee: z.string().min(1),
-  rationale: z.string().min(1),
-});
-
-const renamedSymbolSchema = z.object({
-  originalName: z.string().min(1),
-  suggestedName: z.string().min(1),
-  justification: z.string().min(1),
-});
-
-const agentMemoSchema = z.object({
-  role: z.string().min(1),
-  summary: z.string().min(1),
-  observations: z.array(z.string().min(1)).default([]),
-  evidence: z.array(z.string().min(1)).default([]),
-  nextQuestions: z.array(z.string().min(1)).default([]),
-});
-
-const chunkAnalysisSchema = z.object({
-  entryPoints: z.array(entryPointSchema).default([]),
-  initializationFlow: z.array(z.string().min(1)).default([]),
-  callGraph: z.array(callGraphEdgeSchema).default([]),
-  restoredNames: z.array(renamedSymbolSchema).default([]),
-  summary: z.string().min(1),
-  notableLibraries: z.array(z.string().min(1)).default([]),
-  investigationTips: z.array(z.string().min(1)).default([]),
-  risks: z.array(z.string().min(1)).default([]),
-});
-
-const artifactSummarySchema = z.object({
-  url: z.string().url(),
-  type: artifactTypeSchema,
-  chunkCount: z.number().int().nonnegative(),
-  summary: z.string().min(1),
-});
-
-const finalAnalysisSchema = z.object({
-  overview: z.string().min(1),
-  entryPoints: z.array(entryPointSchema).default([]),
-  initializationFlow: z.array(z.string().min(1)).default([]),
-  callGraph: z.array(callGraphEdgeSchema).default([]),
-  restoredNames: z.array(renamedSymbolSchema).default([]),
-  notableLibraries: z.array(z.string().min(1)).default([]),
-  investigationTips: z.array(z.string().min(1)).default([]),
-  risks: z.array(z.string().min(1)).default([]),
-  artifactSummaries: z.array(artifactSummarySchema),
-  analyzedChunkCount: z.number().int().nonnegative(),
-});
-
 const analyzeInputSchema = z.object({
   pageUrl: z.string().url(),
   artifacts: z.array(
@@ -82,8 +37,6 @@ const analyzeInputSchema = z.object({
     }),
   ),
 });
-
-export type BundleAnalysis = z.infer<typeof finalAnalysisSchema>;
 export type AnalysisProgressStage = "artifact" | "chunk" | "agent";
 export type AnalysisProgressState = "started" | "completed";
 
@@ -106,16 +59,6 @@ interface AnalyzerOptions {
   onProgress?: (event: AnalysisProgressEvent) => void;
 }
 
-export class PartialAnalysisError extends Error {
-  public readonly partialAnalysis: BundleAnalysis;
-
-  public constructor(message: string, partialAnalysis: BundleAnalysis) {
-    super(message);
-    this.name = "PartialAnalysisError";
-    this.partialAnalysis = partialAnalysis;
-  }
-}
-
 function createPromptEnvelope(input: {
   pageUrl: string;
   artifact: FormattedArtifact;
@@ -193,23 +136,6 @@ export function chunkTextByBytes(source: string, maxBytes = DEFAULT_CHUNK_SIZE_B
   return chunks;
 }
 
-function deduplicate<T>(items: T[], keySelector: (item: T) => string): T[] {
-  const seen = new Set<string>();
-  const deduplicated: T[] = [];
-
-  for (const item of items) {
-    const key = keySelector(item);
-    if (seen.has(key)) {
-      continue;
-    }
-
-    seen.add(key);
-    deduplicated.push(item);
-  }
-
-  return deduplicated;
-}
-
 function normalizeAiError(error: unknown): Error {
   if (!(error instanceof Error)) {
     return new Error("AI analysis failed with an unknown error.");
@@ -227,49 +153,6 @@ function normalizeAiError(error: unknown): Error {
   return error;
 }
 
-export function buildAnalysisSnapshot(input: {
-  overview: string;
-  artifactSummaries?: Array<z.infer<typeof artifactSummarySchema>>;
-  chunkAnalyses?: Array<z.infer<typeof chunkAnalysisSchema>>;
-}): BundleAnalysis {
-  const artifactSummaries = input.artifactSummaries ?? [];
-  const chunkAnalyses = input.chunkAnalyses ?? [];
-
-  return finalAnalysisSchema.parse({
-    overview: input.overview,
-    entryPoints: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.entryPoints),
-      (entryPoint) => `${entryPoint.symbol}:${entryPoint.description}`,
-    ),
-    initializationFlow: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.initializationFlow),
-      (step) => step,
-    ),
-    callGraph: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.callGraph),
-      (edge) => `${edge.caller}->${edge.callee}`,
-    ),
-    restoredNames: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.restoredNames),
-      (entry) => `${entry.originalName}:${entry.suggestedName}`,
-    ),
-    notableLibraries: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.notableLibraries),
-      (library) => library,
-    ),
-    investigationTips: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.investigationTips),
-      (tip) => tip,
-    ),
-    risks: deduplicate(
-      chunkAnalyses.flatMap((analysis) => analysis.risks),
-      (risk) => risk,
-    ),
-    artifactSummaries,
-    analyzedChunkCount: chunkAnalyses.length,
-  });
-}
-
 export class AiBundleAnalyzer {
   private readonly providerClient: AiProviderClient;
   private readonly chunkSizeBytes: number;
@@ -301,8 +184,8 @@ export class AiBundleAnalyzer {
       });
     }
 
-    const chunkAnalyses: Array<z.infer<typeof chunkAnalysisSchema>> = [];
-    const artifactSummaries: Array<z.infer<typeof artifactSummarySchema>> = [];
+    const chunkAnalyses: ChunkAnalysis[] = [];
+    const artifactSummaries: ArtifactSummary[] = [];
 
     try {
       const localRag = this.localRagEnabled ? new LocalArtifactRag(validatedInput.artifacts) : null;
@@ -310,7 +193,7 @@ export class AiBundleAnalyzer {
       for (let artifactIndex = 0; artifactIndex < validatedInput.artifacts.length; artifactIndex += 1) {
         const artifact = validatedInput.artifacts[artifactIndex]!;
         const chunks = chunkTextByBytes(artifact.formattedContent || artifact.content, this.chunkSizeBytes);
-        const perArtifactChunkAnalyses: Array<z.infer<typeof chunkAnalysisSchema>> = [];
+        const perArtifactChunkAnalyses: ChunkAnalysis[] = [];
 
         this.emitProgress({
           stage: "artifact",
@@ -401,8 +284,8 @@ export class AiBundleAnalyzer {
     artifactIndex: number;
     artifactCount: number;
     localRag: LocalArtifactRag | null;
-  }): Promise<z.infer<typeof chunkAnalysisSchema>> {
-    const memory: Partial<Record<SwarmAgentName, z.infer<typeof agentMemoSchema> | z.infer<typeof chunkAnalysisSchema>>> = {};
+  }): Promise<ChunkAnalysis> {
+    const memory: Partial<Record<SwarmAgentName, AgentMemo | ChunkAnalysis>> = {};
 
     for (const agent of SWARM_AGENT_ORDER) {
       this.emitProgress({
@@ -452,8 +335,8 @@ export class AiBundleAnalyzer {
     },
     memory: Partial<Record<SwarmAgentName, unknown>>,
     retrievedContext: string[],
-  ): Promise<z.infer<typeof agentMemoSchema>> {
-    const result = await generateText({
+  ): Promise<AgentMemo> {
+    return generateObjectWithTextFallback({
       model: this.providerClient.getModel(),
       system: getSwarmAgentPrompt(agent),
       prompt: createPromptEnvelope({
@@ -465,7 +348,11 @@ export class AiBundleAnalyzer {
         memory,
         retrievedContext,
       }),
-      output: Output.object({ schema: agentMemoSchema }),
+      schema: agentMemoSchema,
+      contract: [
+        "JSON contract:",
+        '{"role":"string","summary":"string","observations":["string"],"evidence":["string"],"nextQuestions":["string"]}',
+      ].join("\n"),
       maxRetries: 2,
       providerOptions: {
         openai: {
@@ -473,8 +360,6 @@ export class AiBundleAnalyzer {
         },
       },
     });
-
-    return agentMemoSchema.parse(result.output);
   }
 
   private async runSynthesisAgent(
@@ -487,8 +372,8 @@ export class AiBundleAnalyzer {
     },
     memory: Partial<Record<SwarmAgentName, unknown>>,
     retrievedContext: string[],
-  ): Promise<z.infer<typeof chunkAnalysisSchema>> {
-    const result = await generateText({
+  ): Promise<ChunkAnalysis> {
+    return generateObjectWithTextFallback({
       model: this.providerClient.getModel(),
       system: getSwarmAgentPrompt("synthesizer"),
       prompt: createPromptEnvelope({
@@ -500,7 +385,11 @@ export class AiBundleAnalyzer {
         memory,
         retrievedContext,
       }),
-      output: Output.object({ schema: chunkAnalysisSchema }),
+      schema: chunkAnalysisSchema,
+      contract: [
+        "JSON contract:",
+        '{"entryPoints":[{"symbol":"string","description":"string","evidence":"string"}],"initializationFlow":["string"],"callGraph":[{"caller":"string","callee":"string","rationale":"string"}],"restoredNames":[{"originalName":"string","suggestedName":"string","justification":"string"}],"summary":"string","notableLibraries":["string"],"investigationTips":["string"],"risks":["string"]}',
+      ].join("\n"),
       maxRetries: 2,
       providerOptions: {
         openai: {
@@ -508,17 +397,15 @@ export class AiBundleAnalyzer {
         },
       },
     });
-
-    return chunkAnalysisSchema.parse(result.output);
   }
 
   private async summarizeFindings(
     pageUrl: string,
-    artifactSummaries: Array<z.infer<typeof artifactSummarySchema>>,
-    chunkAnalyses: Array<z.infer<typeof chunkAnalysisSchema>>,
+    artifactSummaries: ArtifactSummary[],
+    chunkAnalyses: ChunkAnalysis[],
   ): Promise<BundleAnalysis> {
     try {
-      const result = await generateText({
+      const result = await generateObjectWithTextFallback({
         model: this.providerClient.getModel(),
         system: [
           getGlobalMissionPrompt(),
@@ -532,12 +419,14 @@ export class AiBundleAnalyzer {
           "Chunk analyses:",
           JSON.stringify(chunkAnalyses, null, 2),
         ].join("\n\n"),
-        output: Output.object({
-          schema: finalAnalysisSchema.omit({
-            artifactSummaries: true,
-            analyzedChunkCount: true,
-          }),
+        schema: finalAnalysisSchema.omit({
+          artifactSummaries: true,
+          analyzedChunkCount: true,
         }),
+        contract: [
+          "JSON contract:",
+          '{"overview":"string","entryPoints":[{"symbol":"string","description":"string","evidence":"string"}],"initializationFlow":["string"],"callGraph":[{"caller":"string","callee":"string","rationale":"string"}],"restoredNames":[{"originalName":"string","suggestedName":"string","justification":"string"}],"notableLibraries":["string"],"investigationTips":["string"],"risks":["string"]}',
+        ].join("\n"),
         maxRetries: 2,
         providerOptions: {
           openai: {
@@ -547,7 +436,7 @@ export class AiBundleAnalyzer {
       });
 
       return finalAnalysisSchema.parse({
-        ...result.output,
+        ...result,
         artifactSummaries,
         analyzedChunkCount: chunkAnalyses.length,
       });

package/lib/ai-json.ts

@@ -0,0 +1,134 @@
+import { generateText, Output } from "ai";
+import { z } from "zod";
+
+const jsonFencePattern = /^```(?:json)?\s*([\s\S]*?)\s*```$/i;
+
+function extractBalancedJsonSlice(source: string): string | null {
+  const startIndex = source.search(/[\[{]/);
+  if (startIndex < 0) {
+    return null;
+  }
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = startIndex; index < source.length; index += 1) {
+    const character = source[index];
+
+    if (!character) {
+      continue;
+    }
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === "\"") {
+        inString = false;
+      }
+
+      continue;
+    }
+
+    if (character === "\"") {
+      inString = true;
+      continue;
+    }
+
+    if (character === "{" || character === "[") {
+      depth += 1;
+      continue;
+    }
+
+    if (character === "}" || character === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        return source.slice(startIndex, index + 1);
+      }
+    }
+  }
+
+  return null;
+}
+
+export function extractJsonFromText(source: string): unknown {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    throw new Error("Model returned empty text instead of JSON.");
+  }
+
+  const fenced = trimmed.match(jsonFencePattern)?.[1]?.trim();
+  const directCandidate = fenced ?? trimmed;
+
+  try {
+    return JSON.parse(directCandidate) as unknown;
+  } catch {
+    const balancedSlice = extractBalancedJsonSlice(directCandidate);
+    if (!balancedSlice) {
+      throw new Error("No JSON object found in model output.");
+    }
+
+    return JSON.parse(balancedSlice) as unknown;
+  }
+}
+
+export function shouldFallbackToTextJson(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("responseformat") ||
+    message.includes("structured output") ||
+    message.includes("structuredoutputs") ||
+    message.includes("response did not match schema") ||
+    message.includes("no object generated")
+  );
+}
+
+export async function generateObjectWithTextFallback<TOutput>(input: {
+  model: unknown;
+  system: string;
+  prompt: string;
+  schema: z.ZodType<TOutput>;
+  contract: string;
+  maxRetries?: number;
+  providerOptions?: Record<string, unknown>;
+}): Promise<TOutput> {
+  try {
+    const structuredResult = await generateText({
+      model: input.model as never,
+      system: input.system,
+      prompt: input.prompt,
+      output: Output.object({ schema: input.schema }),
+      maxRetries: input.maxRetries ?? 2,
+      ...(input.providerOptions !== undefined ? { providerOptions: input.providerOptions as never } : {}),
+    });
+
+    return input.schema.parse(structuredResult.output);
+  } catch (error) {
+    if (!shouldFallbackToTextJson(error)) {
+      throw error;
+    }
+  }
+
+  const textResult = await generateText({
+    model: input.model as never,
+    system: [
+      input.system,
+      "Return only one valid JSON object.",
+      "Do not wrap the JSON in markdown fences.",
+      "Do not add explanations before or after the JSON.",
+      input.contract,
+    ].join("\n"),
+    prompt: input.prompt,
+    output: Output.text(),
+    maxRetries: input.maxRetries ?? 2,
+    ...(input.providerOptions !== undefined ? { providerOptions: input.providerOptions as never } : {}),
+  });
+
+  return input.schema.parse(extractJsonFromText(textResult.output));
+}