promptpilot 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -2,6 +2,28 @@ type ProviderType = "ollama" | "heuristic";
 type OptimizationMode = "clarity" | "concise" | "detailed" | "structured" | "persuasive" | "compress" | "claude_cli";
 type PromptPreset = "code" | "email" | "essay" | "support" | "summarization" | "chat";
 type ModelRoutingStrategy = "qwen";
+type RoutingPriority = "cheapest_adequate" | "best_quality" | "fastest_adequate";
+type WorkloadBias = "code_first";
+type TargetCapability = "coding" | "agentic" | "tool_use" | "refactor" | "debugging" | "architecture" | "writing" | "email" | "support" | "chat" | "summarization";
+interface TargetModelCandidate {
+    provider: string;
+    model: string;
+    label?: string;
+    capabilities?: readonly TargetCapability[];
+    costRank?: number;
+    latencyRank?: number;
+}
+interface RankedTargetCandidate extends TargetModelCandidate {
+    rank: number;
+    reason: string;
+}
+interface RoutingDecision {
+    selectedTarget: TargetModelCandidate | null;
+    rankedTargets: RankedTargetCandidate[];
+    routingReason: string | null;
+    routingWarnings: string[];
+    routingProvider: string | null;
+}
 interface ContextEntry {
     id: string;
     sessionId: string;
@@ -60,6 +82,12 @@ interface OptimizePromptInput {
     timeoutMs?: number;
     tags?: string[];
     pinnedConstraints?: string[];
+    availableTargets?: TargetModelCandidate[];
+    routingEnabled?: boolean;
+    routingPriority?: RoutingPriority;
+    routingTopK?: number;
+    targetHints?: TargetCapability[];
+    workloadBias?: WorkloadBias;
 }
 interface OptimizePromptResult {
     originalPrompt: string;
@@ -73,6 +101,11 @@ interface OptimizePromptResult {
     mode: OptimizationMode;
     provider: ProviderType;
     model: string;
+    selectedTarget: TargetModelCandidate | null;
+    rankedTargets: RankedTargetCandidate[];
+    routingReason: string | null;
+    routingWarnings: string[];
+    routingProvider: string | null;
     warnings: string[];
     changes: string[];
     debugInfo?: Record<string, unknown>;
@@ -158,6 +191,7 @@ declare class PromptOptimizer {
     private tryOllamaOptimization;
     private resolveOllamaModel;
     private tryQwenModelRouting;
+    private routeDownstreamTargets;
     private heuristicOptimize;
     private reduceToBudget;
 }
@@ -289,4 +323,4 @@ declare class SQLiteSessionStore implements SessionStore {
 declare function createOptimizer(config?: OptimizerConfig): PromptOptimizer;
 declare function optimizePrompt(input: OptimizePromptInput, config?: OptimizerConfig): Promise<OptimizePromptResult>;
 
-export { ContextCompressor, type ContextEntry, ContextManager, ContextStoreError, type ContextSummary, FileSessionStore, InvalidPromptError, type Logger, type ModelRoutingStrategy, OllamaClient, type OllamaClientLike, type OllamaGenerateOptions, type OllamaModelInfo, OllamaUnavailableError, type OptimizationMode, type OptimizePromptInput, type OptimizePromptResult, type OptimizerConfig, PromptOptimizer, type PromptPreset, type ProviderType, type RelevantContextResult, SQLiteSessionStore, type SessionData, type SessionStore, TokenBudgetExceededError, TokenEstimator, type TokenUsageEstimate, createOptimizer, getDefaultPreferredModels, optimizePrompt, selectOllamaModel };
+export { ContextCompressor, type ContextEntry, ContextManager, ContextStoreError, type ContextSummary, FileSessionStore, InvalidPromptError, type Logger, type ModelRoutingStrategy, OllamaClient, type OllamaClientLike, type OllamaGenerateOptions, type OllamaModelInfo, OllamaUnavailableError, type OptimizationMode, type OptimizePromptInput, type OptimizePromptResult, type OptimizerConfig, PromptOptimizer, type PromptPreset, type ProviderType, type RankedTargetCandidate, type RelevantContextResult, type RoutingDecision, type RoutingPriority, SQLiteSessionStore, type SessionData, type SessionStore, type TargetCapability, type TargetModelCandidate, TokenBudgetExceededError, TokenEstimator, type TokenUsageEstimate, type WorkloadBias, createOptimizer, getDefaultPreferredModels, optimizePrompt, selectOllamaModel };

package/dist/index.js

@@ -327,13 +327,13 @@ var modeGuidance = {
   clarity: "Improve clarity, remove ambiguity, and keep the request easy for a downstream model to follow.",
   concise: "Minimize token count while preserving user intent, constraints, and expected output.",
   detailed: "Make the request explicit and complete, including structure and success criteria.",
-  structured: "Organize the request into clean sections with compact headings and bullet points where helpful.",
+  structured: "Organize the request into sections only when that improves clarity or token efficiency.",
   persuasive: "Refine wording so the request is compelling and likely to elicit a thoughtful response.",
   compress: "Aggressively compress redundant wording while preserving the meaning and critical constraints.",
   claude_cli: "Optimize specifically for Claude CLI: compact sections, direct instructions, and minimal boilerplate."
 };
 var presetGuidance = {
-  code: "Favor precise technical requirements, edge cases, and expected output format for code tasks.",
+  code: "Favor precise technical requirements, edge cases, expected output format, and a compact inspect-plan-act-test-reflect loop for code tasks.",
   email: "Preserve the sender's goal, tone, and audience; aim for a realistic and usable writing request.",
   essay: "Preserve thesis, structure, and voice guidance while making the prompt clearer.",
   support: "Favor concise issue context, user impact, and desired resolution details.",
@@ -351,6 +351,10 @@ function getOptimizationSystemPrompt(mode, preset) {
     "- Preserve critical constraints and task goals.",
     "- Improve clarity, structure, and downstream usefulness.",
     "- Keep the result compact when the mode requests compression.",
+    "- Do not force sections when direct phrasing is shorter and equally clear.",
+    "- Remove redundancy aggressively when the source prompt repeats the same goal multiple ways.",
+    "- For code tasks, prefer a terse agent brief over narrative prose.",
+    "- For code tasks, structure the prompt around a Karpathy-style loop: inspect, plan, act, test, reflect, repeat.",
     `Mode guidance: ${modeGuidance[mode]}`,
     preset ? `Preset guidance: ${presetGuidance[preset]}` : "Preset guidance: none"
   ].join("\n");
@@ -679,7 +683,11 @@ function tokenize(value) {
   );
 }
 function extractConstraints(value) {
-  return value.split(/\n+/).map((line) => line.trim()).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max)/i.test(line)).slice(0, 8);
+  return Array.from(
+    new Set(
+      value.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((line) => line.trim().replace(/^[-*]\s*/, "")).filter((line) => line.length > 0 && line.length <= 180).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max|preserve|keep)/i.test(line))
+    )
+  ).slice(0, 8);
 }
 function extractEntities(value) {
   return Array.from(
@@ -801,6 +809,9 @@ var DEFAULT_PROVIDER = "ollama";
 var DEFAULT_MAX_INPUT_TOKENS = 1200;
 var DEFAULT_MAX_CONTEXT_TOKENS = 800;
 var DEFAULT_MAX_TOTAL_TOKENS = 2200;
+var DEFAULT_ROUTING_PRIORITY = "cheapest_adequate";
+var DEFAULT_ROUTING_TOP_K = 3;
+var DEFAULT_WORKLOAD_BIAS = "code_first";
 var PromptOptimizer = class {
   config;
   logger;
@@ -838,6 +849,10 @@ var PromptOptimizer = class {
     const maxInputTokens = input.maxInputTokens ?? this.config.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
     const maxContextTokens = input.maxContextTokens ?? this.config.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
     const maxTotalTokens = input.maxTotalTokens ?? this.config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
+    const routingEnabled = input.routingEnabled !== false;
+    const routingPriority = input.routingPriority ?? DEFAULT_ROUTING_PRIORITY;
+    const routingTopK = input.routingTopK ?? DEFAULT_ROUTING_TOP_K;
+    const workloadBias = input.workloadBias ?? DEFAULT_WORKLOAD_BIAS;
     const warnings = [];
     const changes = [];
     const useContext = input.useContext !== false && Boolean(input.sessionId);
@@ -867,6 +882,7 @@ var PromptOptimizer = class {
     );
     let provider = input.bypassOptimization ? "heuristic" : this.config.provider ?? DEFAULT_PROVIDER;
     let model = provider === "ollama" ? this.config.ollamaModel ?? "auto" : "heuristic";
+    let usedPreprocessedFallback = false;
     let optimizedPrompt = originalPrompt;
     let providerWarnings = [];
     let providerChanges = [];
@@ -901,6 +917,11 @@ var PromptOptimizer = class {
         optimizedPrompt = ollamaResult.optimizedPrompt;
         providerWarnings = ollamaResult.warnings;
         providerChanges = ollamaResult.changes;
+        if (ollamaResult.source === "preprocessed") {
+          provider = "heuristic";
+          model = "cheap-preprocess";
+          usedPreprocessedFallback = true;
+        }
       } else if (provider === "ollama") {
         provider = "heuristic";
         model = "heuristic";
@@ -909,7 +930,7 @@ var PromptOptimizer = class {
         ];
       }
     }
-    if (provider === "heuristic") {
+    if (provider === "heuristic" && !usedPreprocessedFallback) {
       const fallback = this.heuristicOptimize({
         input: {
           ...input,
@@ -926,6 +947,22 @@ var PromptOptimizer = class {
     }
     warnings.push(...providerWarnings);
     changes.push(...providerChanges);
+    const routingDecision = await this.routeDownstreamTargets({
+      input: {
+        ...input,
+        prompt: originalPrompt,
+        mode,
+        preset,
+        routingPriority,
+        routingTopK,
+        workloadBias
+      },
+      routingEnabled,
+      routingPriority,
+      routingTopK,
+      workloadBias
+    });
+    warnings.push(...routingDecision.routingWarnings);
     let finalPrompt = composeFinalPrompt({
       optimizedPrompt,
       input: {
@@ -934,7 +971,8 @@ var PromptOptimizer = class {
         mode,
         preset
       },
-      context: relevantContext
+      context: relevantContext,
+      routingDecision
     });
     let estimatedTokensAfter = {
       prompt: this.estimator.estimateText(optimizedPrompt),
@@ -951,6 +989,7 @@ var PromptOptimizer = class {
         },
         optimizedPrompt,
         context: relevantContext,
+        routingDecision,
         maxTotalTokens
       });
       finalPrompt = reduced.finalPrompt;
@@ -986,6 +1025,11 @@ var PromptOptimizer = class {
       mode,
       provider,
       model,
+      selectedTarget: routingDecision.selectedTarget,
+      rankedTargets: routingDecision.rankedTargets,
+      routingReason: routingDecision.routingReason,
+      routingWarnings: routingDecision.routingWarnings,
+      routingProvider: routingDecision.routingProvider,
       warnings,
       changes,
       debugInfo: input.debug ? {
@@ -994,7 +1038,8 @@ var PromptOptimizer = class {
         estimatedTokensAfter,
         extractedConstraints,
         preset,
-        selectedModel: model
+        selectedModel: model,
+        routingDecision
       } : void 0
     };
   }
@@ -1017,29 +1062,88 @@ var PromptOptimizer = class {
     });
   }
   async tryOllamaOptimization(options) {
+    const preprocessedPrompt = cheapCompress(options.input.prompt);
+    const preprocessedTokenCount = this.estimator.estimateText(preprocessedPrompt);
+    const ultraMode = preprocessedTokenCount > 500;
     try {
       if (!await this.client.isAvailable()) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because Ollama was unavailable."],
+          warnings: ["Ollama was unavailable, so PromptPilot kept the cheap preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const systemPrompt = ultraMode ? `${getOptimizationSystemPrompt(options.input.mode, options.input.preset)}
+Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemPrompt(options.input.mode, options.input.preset);
+      const optimizationPrompt = buildOptimizationPrompt(
+        {
+          ...options.input,
+          prompt: preprocessedPrompt
+        },
+        options.relevantContext,
+        options.extractedConstraints
+      );
+      const timeoutMs = options.input.timeoutMs ?? this.config.timeoutMs;
+      let optimizedPrompt = "";
+      let responseChanges = [];
+      let responseWarnings = [];
+      try {
+        const response = await this.client.generateJson({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature,
+          format: "json"
+        });
+        optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
+        responseChanges = response.changes ?? [];
+        responseWarnings = response.warnings ?? [];
+      } catch {
+        const raw = await this.client.generate({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature
+        });
+        optimizedPrompt = sanitizeTextOptimizationOutput(raw);
+        responseChanges = [`Applied text-only Ollama optimization with ${options.model}.`];
       }
-      const response = await this.client.generateJson({
-        systemPrompt: getOptimizationSystemPrompt(options.input.mode, options.input.preset),
-        prompt: buildOptimizationPrompt(options.input, options.relevantContext, options.extractedConstraints),
-        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
-        model: options.model,
-        temperature: this.config.temperature,
-        format: "json"
-      });
-      const optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
       if (!optimizedPrompt) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because the model returned an empty optimization."],
+          warnings: ["The local optimizer returned an empty result, so PromptPilot kept the preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const optimizedTokenCount = this.estimator.estimateText(optimizedPrompt);
+      if (isCompressionSensitiveMode(options.input.mode) && optimizedTokenCount >= preprocessedTokenCount) {
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: [
+            ...responseChanges,
+            "Kept the cheap preprocessed prompt because the model output was not smaller."
+          ],
+          warnings: responseWarnings,
+          source: "preprocessed"
+        };
       }
       return {
         optimizedPrompt,
-        changes: response.changes ?? [`Applied Ollama optimization with ${options.model}.`],
-        warnings: response.warnings ?? []
+        changes: responseChanges.length > 0 ? responseChanges : [`Applied Ollama optimization with ${options.model}.`],
+        warnings: responseWarnings,
+        source: "ollama"
       };
     } catch {
-      return null;
+      return {
+        optimizedPrompt: preprocessedPrompt,
+        changes: ["Applied cheap local preprocessing because Ollama optimization failed."],
+        warnings: ["Ollama optimization failed, so PromptPilot kept the preprocessed prompt."],
+        source: "preprocessed"
+      };
     }
   }
   async resolveOllamaModel(options) {
@@ -1210,17 +1314,146 @@ var PromptOptimizer = class {
       };
     }
   }
+  async routeDownstreamTargets(options) {
+    const availableTargets = normalizeAvailableTargets(options.input.availableTargets ?? []);
+    if (!options.routingEnabled || availableTargets.length === 0) {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [],
+        routingProvider: null
+      };
+    }
+    if (availableTargets.length === 1) {
+      return {
+        selectedTarget: stripInternalTargetFields(availableTargets[0]),
+        rankedTargets: [
+          {
+            ...stripInternalTargetFields(availableTargets[0]),
+            rank: 1,
+            reason: "Only one downstream target was supplied."
+          }
+        ],
+        routingReason: "Only one downstream target was supplied, so it was selected directly.",
+        routingWarnings: [],
+        routingProvider: "direct"
+      };
+    }
+    if (!this.client.listModels) {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [
+          "Downstream target routing requires local Ollama model discovery so a Qwen router can run."
+        ],
+        routingProvider: null
+      };
+    }
+    try {
+      const installedModels = await this.client.listModels();
+      const routerModel = getQwenRouterModel(installedModels, this.config.routerModel);
+      if (!routerModel) {
+        return {
+          selectedTarget: null,
+          rankedTargets: [],
+          routingReason: null,
+          routingWarnings: [
+            "Downstream target routing could not run because no suitable local Qwen router model is installed."
+          ],
+          routingProvider: null
+        };
+      }
+      const response = await this.client.generateJson({
+        model: routerModel,
+        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
+        temperature: 0,
+        format: "json",
+        systemPrompt: buildDownstreamRoutingSystemPrompt(options.routingPriority, options.workloadBias),
+        prompt: JSON.stringify(
+          {
+            objective: "Rank the caller-supplied downstream targets for this prompt and choose the best top target.",
+            prompt: options.input.prompt,
+            task: options.input.task ?? null,
+            mode: options.input.mode,
+            preset: options.input.preset,
+            tone: options.input.tone ?? null,
+            targetHints: options.input.targetHints ?? [],
+            workloadBias: options.workloadBias,
+            routingPriority: options.routingPriority,
+            candidateTargets: availableTargets.map((target) => ({
+              id: target.id,
+              provider: target.provider,
+              model: target.model,
+              label: target.label ?? null,
+              costRank: target.costRank,
+              latencyRank: target.latencyRank,
+              capabilities: target.capabilities,
+              profile: describeDownstreamTarget(target)
+            }))
+          },
+          null,
+          2
+        )
+      });
+      const rankedTargetIds = Array.from(
+        new Set((response.rankedTargetIds ?? []).map((value) => value.trim()).filter(Boolean))
+      ).slice(0, Math.max(1, options.routingTopK));
+      const rankedTargets = rankedTargetIds.map((id, index) => {
+        const target = availableTargets.find((candidate) => candidate.id === id);
+        if (!target) {
+          return null;
+        }
+        return {
+          ...stripInternalTargetFields(target),
+          rank: index + 1,
+          reason: index === 0 ? response.reason?.trim() || "Selected by the local Qwen downstream router." : `Ranked #${index + 1} by the local Qwen downstream router.`
+        };
+      }).filter((value) => value !== null);
+      const selectedTargetId = response.selectedTargetId?.trim();
+      const selectedTargetCandidate = (selectedTargetId && availableTargets.find((candidate) => candidate.id === selectedTargetId)) ?? (rankedTargets[0] ? availableTargets.find(
+        (candidate) => candidate.provider === rankedTargets[0].provider && candidate.model === rankedTargets[0].model && candidate.label === rankedTargets[0].label
+      ) ?? null : null);
+      if (!selectedTargetCandidate || rankedTargets.length === 0) {
+        return {
+          selectedTarget: null,
+          rankedTargets: [],
+          routingReason: null,
+          routingWarnings: [
+            "Downstream target routing returned an invalid selection, so no downstream target was chosen."
+          ],
+          routingProvider: routerModel
+        };
+      }
+      return {
+        selectedTarget: stripInternalTargetFields(selectedTargetCandidate),
+        rankedTargets,
+        routingReason: response.reason?.trim() || "Selected by the local Qwen downstream router.",
+        routingWarnings: [],
+        routingProvider: routerModel
+      };
+    } catch {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [
+          "Downstream target routing could not complete, so no downstream target was selected."
+        ],
+        routingProvider: null
+      };
+    }
+  }
   heuristicOptimize(options) {
-    const lines = [
-      `Request: ${options.input.prompt}`,
-      options.input.task ? `Task type: ${options.input.task}` : "",
-      options.input.tone ? `Tone: ${options.input.tone}` : "",
-      options.input.outputFormat ? `Output format: ${options.input.outputFormat}` : "",
-      options.input.maxLength ? `Maximum length: ${options.input.maxLength}` : "",
-      options.constraints.length ? `Critical constraints: ${options.constraints.join("; ")}` : ""
-    ].filter(Boolean);
+    const isCodeRequest = isCodeFirstRequest(options.input);
+    const lines = isCodeRequest ? buildCodeFirstHeuristicPrompt(options.input, options.constraints) : buildGeneralHeuristicPrompt(options.input, options.constraints);
     const optimizedPrompt = lines.join("\n");
-    const changes = ["Normalized prompt structure for downstream model consumption."];
+    const changes = isCodeRequest ? [
+      "Compressed the prompt into a code-agent brief.",
+      "Removed redundant narrative phrasing.",
+      "Applied a Karpathy-style inspect-plan-act-test-reflect loop."
+    ] : ["Normalized prompt structure for downstream model consumption."];
     if (options.input.mode === "compress" || options.input.mode === "concise") {
       changes.push("Applied concise formatting to reduce token usage.");
     }
@@ -1241,7 +1474,8 @@ var PromptOptimizer = class {
     const finalPrompt = composeFinalPrompt({
       optimizedPrompt: this.estimator.truncateToBudget(options.optimizedPrompt, Math.floor(options.maxTotalTokens * 0.5)),
       input: options.input,
-      context: compactContext
+      context: compactContext,
+      routingDecision: options.routingDecision
     });
     return {
       finalPrompt,
@@ -1300,9 +1534,17 @@ ${contextBlock}`);
   if (constraints.length > 0) {
     sections.push(`Constraints:
 - ${constraints.join("\n- ")}`);
+  }
+  if (isCodeFirstRequest(input.input)) {
+    sections.push(`Execution loop:
+- Inspect the relevant files and current behavior.
+- Plan the smallest safe next step.
+- Act with minimal, reversible changes.
+- Test or validate the result.
+- Reflect on gaps or risks, then repeat.`);
   }
   const desiredOutput = [
-    input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
+    input.routingDecision.selectedTarget ? `Selected target: ${formatTargetLabel(input.routingDecision.selectedTarget)}` : input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
     `Mode: ${input.input.mode}`,
     `Preset: ${input.input.preset}`
   ];
@@ -1328,6 +1570,179 @@ function emptyRelevantContext() {
     debugInfo: {}
   };
 }
+function normalizeAvailableTargets(targets) {
+  return targets.map((target, index) => ({
+    ...target,
+    id: `${target.provider}:${target.model}:${index}`,
+    label: target.label ?? `${target.provider}:${target.model}`,
+    capabilities: target.capabilities ?? inferCapabilities(target),
+    costRank: target.costRank ?? index + 1,
+    latencyRank: target.latencyRank ?? index + 1
+  }));
+}
+function stripInternalTargetFields(target) {
+  return {
+    provider: target.provider,
+    model: target.model,
+    label: target.label,
+    capabilities: target.capabilities,
+    costRank: target.costRank,
+    latencyRank: target.latencyRank
+  };
+}
+function buildDownstreamRoutingSystemPrompt(priority, workloadBias) {
+  return [
+    "You are a downstream model router for PromptPilot.",
+    "Return strict JSON only with this shape:",
+    '{"selectedTargetId":"string","rankedTargetIds":["string"],"reason":"string"}',
+    "Choose only from the supplied candidate target IDs.",
+    "Rank up to the requested top targets in best-first order.",
+    `Routing priority: ${priority}.`,
+    `Workload bias: ${workloadBias}.`,
+    "Code-first means ambiguous prompts should default toward coding-capable or agentic-capable targets.",
+    "Explicit email, support, chat, and lightweight writing prompts may prefer cheaper lighter targets.",
+    "Do not invent targets. Do not output prose outside JSON."
+  ].join("\n");
+}
+function inferCapabilities(target) {
+  const lower = `${target.provider} ${target.model} ${target.label ?? ""}`.toLowerCase();
+  const capabilities = /* @__PURE__ */ new Set();
+  if (/code|codex|coder|agent|tool/.test(lower)) {
+    capabilities.add("coding");
+  }
+  if (/agent|tool/.test(lower)) {
+    capabilities.add("agentic");
+    capabilities.add("tool_use");
+  }
+  if (/refactor|coder|codex/.test(lower)) {
+    capabilities.add("refactor");
+  }
+  if (/debug|fix|ci/.test(lower)) {
+    capabilities.add("debugging");
+  }
+  if (/write|email|chat|sonnet|mini/.test(lower)) {
+    capabilities.add("writing");
+  }
+  if (/email/.test(lower)) {
+    capabilities.add("email");
+  }
+  return Array.from(capabilities);
+}
+function describeDownstreamTarget(target) {
+  return [
+    `provider=${target.provider}`,
+    `model=${target.model}`,
+    `label=${target.label}`,
+    `costRank=${target.costRank}`,
+    `latencyRank=${target.latencyRank}`,
+    `capabilities=${target.capabilities?.join(",") || "none"}`
+  ].join("; ");
+}
+function formatTargetLabel(target) {
+  return target.label ?? `${target.provider}:${target.model}`;
+}
+function isCompressionSensitiveMode(mode) {
+  return mode === "compress" || mode === "concise" || mode === "claude_cli";
+}
+function cheapCompress(text) {
+  return normalizeWhitespace(text).replace(/\b(?:please|kindly|just)\b/gi, "").replace(/\bI\s+(?:want|need|would\s+like\s+to)\b/gi, "").replace(/\s+([,.;:!?])/g, "$1").replace(/\s{2,}/g, " ").trim();
+}
+function sanitizeTextOptimizationOutput(raw) {
+  const normalized = normalizeWhitespace(raw);
+  if (!normalized) {
+    return "";
+  }
+  if (!containsReasoningLeak(normalized)) {
+    return stripWrappingQuotes(normalized);
+  }
+  const candidates = raw.split(/\n{2,}/).map((chunk) => stripWrappingQuotes(normalizeWhitespace(chunk))).filter(Boolean).filter((chunk) => !containsReasoningLeak(chunk)).filter((chunk) => !/^(role|task|guidelines|thinking|thinking process|attempt|critique|final decision|analysis)\b/i.test(chunk)).filter((chunk) => !/^[-*]\s/.test(chunk)).filter((chunk) => !/^\d+\.\s/.test(chunk));
+  return candidates.at(-1) ?? stripWrappingQuotes(normalized);
+}
+function containsReasoningLeak(text) {
+  return /(thinking process|analyze the request|drafting the optimized prompt|critique \d|attempt \d|final decision)/i.test(text);
+}
+function stripWrappingQuotes(text) {
+  return text.replace(/^["'`]+|["'`]+$/g, "").trim();
+}
+function isCodeFirstRequest(input) {
+  if (input.task === "code" || input.preset === "code") {
+    return true;
+  }
+  if ((input.targetHints ?? []).some((hint) => ["coding", "agentic", "refactor", "debugging", "tool_use", "architecture"].includes(hint))) {
+    return true;
+  }
+  return /\b(code|coding|repo|repository|refactor|patch|debug|bug|ci|test|typescript|javascript|agent|tool)\b/i.test(
+    input.prompt
+  );
+}
+function buildGeneralHeuristicPrompt(input, constraints) {
+  return [
+    `Request: ${summarizePrompt(input.prompt, 320)}`,
+    input.task ? `Task type: ${input.task}` : "",
+    input.tone ? `Tone: ${input.tone}` : "",
+    input.outputFormat ? `Output format: ${input.outputFormat}` : "",
+    input.maxLength ? `Maximum length: ${input.maxLength}` : "",
+    constraints.length ? `Critical constraints: ${constraints.join("; ")}` : ""
+  ].filter(Boolean);
+}
+function buildCodeFirstHeuristicPrompt(input, constraints) {
+  const deliverables = inferCodeDeliverables(input.prompt);
+  return [
+    `Goal: ${summarizeCodeGoal(input.prompt)}`,
+    input.tone ? `Tone: ${input.tone}` : "",
+    deliverables.length ? `Deliverables:
+- ${deliverables.join("\n- ")}` : "",
+    constraints.length ? `Constraints: ${constraints.join("; ")}` : "",
+    "Use a Karpathy loop: inspect, plan, act, test, reflect, repeat."
+  ].filter(Boolean);
+}
+function summarizePrompt(prompt, maxLength) {
+  const normalized = normalizeWhitespace(prompt);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 1).trim()}\u2026`;
+}
+function summarizeCodeGoal(prompt) {
+  const normalized = summarizePrompt(prompt, 220);
+  const lowered = prompt.toLowerCase();
+  if (/auth|authentication|login|token/.test(lowered)) {
+    return "Inspect the codebase, understand the authentication flow, and produce a safe incremental refactor plan.";
+  }
+  if (/ci|debug|failing|failure|test/.test(lowered)) {
+    return "Inspect the codebase and failing signals, identify root causes, and produce a practical debugging plan.";
+  }
+  if (/refactor/.test(lowered)) {
+    return "Inspect the codebase and produce a phased refactor plan with minimal-risk execution steps.";
+  }
+  return normalized;
+}
+function inferCodeDeliverables(prompt) {
+  const lowered = prompt.toLowerCase();
+  const deliverables = [];
+  if (/inspect|codebase|repo|repository/.test(lowered)) {
+    deliverables.push("Summarize the relevant modules, ownership boundaries, and current behavior.");
+  }
+  if (/shared abstraction|shared abstractions|duplicate|duplicated/.test(lowered)) {
+    deliverables.push("Identify duplicated logic and the best shared abstractions to extract.");
+  }
+  if (/incremental|phase|phased|rollout|step/.test(lowered)) {
+    deliverables.push("Propose an incremental plan with small, reversible steps.");
+  }
+  if (/risk|migration|compatibility|backward/.test(lowered)) {
+    deliverables.push("Call out migration risks, compatibility concerns, and rollback points.");
+  }
+  if (/test|tests/.test(lowered)) {
+    deliverables.push("List the tests or validation needed before and after each phase.");
+  }
+  if (/avoid hand-wavy|practical|concrete/.test(lowered)) {
+    deliverables.push("Keep the recommendations concrete, implementation-oriented, and free of vague architecture advice.");
+  }
+  if (deliverables.length === 0) {
+    deliverables.push("Produce a compact, execution-ready plan for the coding task.");
+  }
+  return deliverables.slice(0, 6);
+}
 
 // src/index.ts
 function createOptimizer(config = {}) {