@matheuskrumenauer/tanya 0.3.0-beta.0 → 0.4.0-beta.0

package/dist/cli.js

@@ -40,6 +40,170 @@ function numberEnvValue(local, key, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+// src/providers/adapters/deepseek.ts
+var deepSeekAdapter = {
+  id: "deepseek",
+  matchBaseUrl: /api\.deepseek\.com/i,
+  defaultBaseUrl: "https://api.deepseek.com",
+  defaultModel: "deepseek-chat",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: true,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/types.ts
+function withoutUnsupportedToolChoice(req) {
+  if (req.tool_choice === "required") {
+    const { tool_choice: _toolChoice, ...rest } = req;
+    return rest;
+  }
+  return req;
+}
+
+// src/providers/adapters/grok.ts
+var grokAdapter = {
+  id: "grok",
+  matchBaseUrl: /(?:api\.)?x\.ai/i,
+  defaultBaseUrl: "https://api.x.ai/v1",
+  defaultModel: "grok-3-mini",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: false
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/groq.ts
+var groqAdapter = {
+  id: "groq",
+  matchBaseUrl: /api\.groq\.com/i,
+  defaultBaseUrl: "https://api.groq.com/openai/v1",
+  defaultModel: "llama-3.3-70b-versatile",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/ollama.ts
+var ollamaAdapter = {
+  id: "ollama",
+  matchBaseUrl: /(?:localhost:11434|127\.0\.0\.1:11434|ollama)/i,
+  defaultBaseUrl: "http://localhost:11434/v1",
+  defaultModel: "qwen2.5-coder:7b",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: false
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/openai.ts
+var openAiAdapter = {
+  id: "openai",
+  matchBaseUrl: /(?:api\.)?openai\.com/i,
+  defaultBaseUrl: "https://api.openai.com/v1",
+  defaultModel: "gpt-4.1-mini",
+  capabilities: {
+    toolChoiceRequired: true,
+    parallelToolCalls: true,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/qwen.ts
+var qwenAdapter = {
+  id: "qwen",
+  matchBaseUrl: /(?:dashscope|aliyuncs|qwen)/i,
+  defaultBaseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  defaultModel: "qwen3-coder-plus",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: true
+  },
+  preRequest: (req) => ({
+    ...withoutUnsupportedToolChoice(req),
+    parallel_tool_calls: false
+  })
+};
+
+// src/providers/adapters/together.ts
+var togetherAdapter = {
+  id: "together",
+  matchBaseUrl: /api\.together\.xyz/i,
+  defaultBaseUrl: "https://api.together.xyz/v1",
+  defaultModel: "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: true
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/index.ts
+var providerAdapters = [
+  deepSeekAdapter,
+  qwenAdapter,
+  grokAdapter,
+  groqAdapter,
+  togetherAdapter,
+  ollamaAdapter,
+  openAiAdapter
+];
+var aliases = /* @__PURE__ */ new Map([
+  ["deepseek-reasoner", "deepseek"],
+  ["deepseek-chat", "deepseek"],
+  ["xai", "grok"],
+  ["openai-compatible", "openai"],
+  ["custom", "openai"]
+]);
+function resolveProviderAdapter(input = {}) {
+  const provider = normalizeProviderId(input.provider);
+  if (provider) {
+    const explicit = providerAdapters.find((adapter) => adapter.id === provider);
+    if (explicit) return explicit;
+  }
+  const baseUrl = input.baseUrl?.trim();
+  if (baseUrl) {
+    const matched = providerAdapters.find((adapter) => adapter.matchBaseUrl?.test(baseUrl));
+    if (matched) return matched;
+  }
+  return openAiAdapter;
+}
+function normalizeProviderId(provider) {
+  const normalized = provider?.trim().toLowerCase();
+  if (!normalized) return null;
+  return aliases.get(normalized) ?? normalized;
+}
+
 // src/config/env.ts
 function loadDotEnv(cwd) {
   const envPath = join(cwd, ".env");
@@ -48,11 +212,18 @@ function loadDotEnv(cwd) {
 }
 function loadConfig(cwd = process.cwd()) {
   const local = loadDotEnv(cwd);
-  const provider = envValue(local, "TANYA_PROVIDER") === "custom" ? "custom" : "deepseek";
   const profile = envValue(local, "TANYA_PROFILE") === "reasoner" ? "reasoner" : "chat";
+  const requestedProvider = envValue(local, "TANYA_PROVIDER").trim();
+  const requestedBaseUrl = envValue(local, "TANYA_BASE_URL").trim();
+  const providerSeed = requestedProvider || (requestedBaseUrl ? "" : "deepseek");
+  const adapter = resolveProviderAdapter({
+    provider: providerSeed,
+    baseUrl: requestedBaseUrl
+  });
+  const provider = providerSeed || adapter.id;
   const apiKey = provider === "deepseek" ? envValue(local, "DEEPSEEK_API_KEY") || envValue(local, "TANYA_API_KEY") : envValue(local, "TANYA_API_KEY");
-  const baseUrl = provider === "deepseek" ? envValue(local, "DEEPSEEK_BASE_URL") || envValue(local, "TANYA_BASE_URL") || "https://api.deepseek.com" : envValue(local, "TANYA_BASE_URL");
-  const profileModelDefault = profile === "reasoner" ? "deepseek-reasoner" : "deepseek-chat";
+  const baseUrl = provider === "deepseek" ? envValue(local, "DEEPSEEK_BASE_URL") || envValue(local, "TANYA_BASE_URL") || adapter.defaultBaseUrl || "https://api.deepseek.com" : envValue(local, "TANYA_BASE_URL") || adapter.defaultBaseUrl || "";
+  const profileModelDefault = profile === "reasoner" && adapter.id === "deepseek" ? "deepseek-reasoner" : adapter.defaultModel ?? "deepseek-chat";
   const model = envValue(local, "TANYA_MODEL") || profileModelDefault;
   const profileTimeoutDefault = profile === "reasoner" ? 18e4 : 9e4;
   const timeoutMs = numberEnvValue(local, "TANYA_TIMEOUT_MS", profileTimeoutDefault);
@@ -482,6 +653,39 @@ function createCosmoSink(stream = process.stdout) {
           runId: event.runId
         });
         break;
+      case "tool_call_parse_warning":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Tool-call parse warning: ${event.reason}`,
+          key: `tanya:tool-call-parse-warning:${event.toolCallId ?? event.turn ?? "unknown"}`,
+          provider: event.provider,
+          tool: event.tool,
+          attempt: event.attempt
+        });
+        break;
+      case "schema_flatten_warning":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Schema flatten warning: ${event.reason}`,
+          key: `tanya:schema-flatten-warning:${event.tool ?? event.path}`,
+          provider: event.provider,
+          tool: event.tool,
+          path: event.path
+        });
+        break;
+      case "provider_throttle":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Provider throttle: waiting ${Math.ceil(event.waitMs / 1e3)}s before retry ${event.attempt}.`,
+          key: `tanya:provider-throttle:${event.provider}:${event.attempt}`,
+          provider: event.provider,
+          attempt: event.attempt,
+          waitMs: event.waitMs
+        });
+        break;
       case "final":
         ensureEventLine();
         if (event.message.trim()) {
@@ -531,6 +735,9 @@ var knownEventTypes = /* @__PURE__ */ new Set([
   "tool_cancel_requested",
   "tool_cancelled",
   "tool_result",
+  "tool_call_parse_warning",
+  "schema_flatten_warning",
+  "provider_throttle",
   "command_invoked",
   "final",
   "error"
@@ -548,27 +755,237 @@ function createJsonlSink(stream = process.stdout) {
   };
 }
 
-// src/providers/openAiCompatible.ts
-var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503]);
-var MAX_FETCH_ATTEMPTS = 3;
-function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+// src/providers/schemaFlatten.ts
+function flattenJsonSchema(schema) {
+  const warnings = [];
+  const root = clone(schema);
+  const flattened = flattenValue(root, root, "#", warnings, /* @__PURE__ */ new Set());
+  return { schema: flattened, warnings };
 }
-function retryAfterMs(response) {
+function flattenToolDefinition(tool) {
+  const result = flattenJsonSchema(tool.function.parameters);
+  return {
+    schema: {
+      ...tool,
+      function: {
+        ...tool.function,
+        parameters: result.schema
+      }
+    },
+    warnings: result.warnings.map((warning) => ({ ...warning, tool: tool.function.name }))
+  };
+}
+function flattenToolDefinitions(tools) {
+  const flattened = [];
+  const warnings = [];
+  for (const tool of tools) {
+    const result = flattenToolDefinition(tool);
+    flattened.push(result.schema);
+    warnings.push(...result.warnings);
+  }
+  return { schema: flattened, warnings };
+}
+function flattenValue(value, root, path, warnings, seenRefs) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => flattenValue(item, root, `${path}/${index}`, warnings, seenRefs));
+  }
+  if (!isObject(value)) return value;
+  const ref = typeof value.$ref === "string" ? value.$ref : null;
+  if (ref) {
+    const resolved = resolveLocalRef(root, ref);
+    if (resolved === void 0) {
+      warnings.push({ path, reason: `unresolved $ref ${ref}; leaving reference in place` });
+      return value;
+    }
+    if (seenRefs.has(ref)) {
+      warnings.push({ path, reason: `circular $ref ${ref}; leaving reference in place` });
+      return value;
+    }
+    warnings.push({ path, reason: `inlined $ref ${ref}` });
+    seenRefs.add(ref);
+    const flattened = flattenValue(resolved, root, path, warnings, seenRefs);
+    seenRefs.delete(ref);
+    const { $ref: _ref, ...overrides } = value;
+    return isObject(flattened) ? flattenObject({ ...flattened, ...overrides }, root, path, warnings, seenRefs) : flattened;
+  }
+  return flattenObject(value, root, path, warnings, seenRefs);
+}
+function flattenObject(object, root, path, warnings, seenRefs) {
+  const withoutDefs = stripDefinitions(object);
+  if (Array.isArray(withoutDefs.oneOf)) {
+    return flattenOneOf(withoutDefs, root, path, warnings, seenRefs);
+  }
+  const output = {};
+  for (const [key, raw] of Object.entries(withoutDefs)) {
+    output[key] = flattenValue(raw, root, `${path}/${escapePointer(key)}`, warnings, seenRefs);
+  }
+  return output;
+}
+function flattenOneOf(object, root, path, warnings, seenRefs) {
+  const variants = object.oneOf;
+  const flattenedVariants = variants.map((variant, index) => flattenValue(variant, root, `${path}/oneOf/${index}`, warnings, seenRefs)).filter(isObject);
+  if (flattenedVariants.length === 0) {
+    warnings.push({ path, reason: "oneOf had no object variants; dropped oneOf" });
+    const { oneOf: _oneOf2, ...rest2 } = object;
+    return flattenObject(rest2, root, path, warnings, seenRefs);
+  }
+  const commonType = commonScalar(flattenedVariants.map((variant) => variant.type));
+  const commonProperties = commonObjectProperties(flattenedVariants);
+  const commonRequired = commonRequiredFields(flattenedVariants);
+  const { oneOf: _oneOf, ...rest } = object;
+  warnings.push({ path, reason: `collapsed oneOf (${variants.length} variants) to common object shape` });
+  return flattenObject({
+    ...rest,
+    ...commonType ? { type: commonType } : {},
+    ...Object.keys(commonProperties).length ? { properties: commonProperties } : {},
+    ...commonRequired.length ? { required: commonRequired } : {}
+  }, root, path, warnings, seenRefs);
+}
+function commonObjectProperties(variants) {
+  const propertyMaps = variants.map((variant) => isObject(variant.properties) ? variant.properties : {});
+  if (propertyMaps.length === 0) return {};
+  const commonKeys = Object.keys(propertyMaps[0] ?? {}).filter((key) => propertyMaps.every((properties) => key in properties));
+  const output = {};
+  for (const key of commonKeys) output[key] = propertyMaps[0]?.[key];
+  return output;
+}
+function commonRequiredFields(variants) {
+  const requiredLists = variants.map((variant) => Array.isArray(variant.required) ? variant.required.filter((item) => typeof item === "string") : []);
+  if (requiredLists.length === 0) return [];
+  return requiredLists[0]?.filter((key) => requiredLists.every((list) => list.includes(key))) ?? [];
+}
+function commonScalar(values) {
+  const [first] = values;
+  return typeof first === "string" && values.every((value) => value === first) ? first : null;
+}
+function resolveLocalRef(root, ref) {
+  if (!ref.startsWith("#/")) return void 0;
+  const parts = ref.slice(2).split("/").map(unescapePointer);
+  let current = root;
+  for (const part of parts) {
+    if (!isObject(current) && !Array.isArray(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function stripDefinitions(object) {
+  const { $defs: _defs, definitions: _definitions, ...rest } = object;
+  return rest;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function isObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function escapePointer(value) {
+  return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointer(value) {
+  return value.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+// src/providers/retry.ts
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_MAX_WAIT_MS = 3e4;
+var DEFAULT_INITIAL_WAIT_MS = 500;
+var DEFAULT_PROVIDER_CONCURRENCY = 4;
+var semaphores = /* @__PURE__ */ new Map();
+function retryAfterMs(response, now = Date.now()) {
   const raw = response.headers.get("retry-after");
   if (!raw) return null;
   const seconds = Number(raw);
-  if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 6e4);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.max(0, seconds * 1e3);
   const dateMs = Date.parse(raw);
-  if (!Number.isNaN(dateMs)) return Math.min(Math.max(dateMs - Date.now(), 0), 6e4);
+  if (!Number.isNaN(dateMs)) return Math.max(dateMs - now, 0);
+  return null;
+}
+function backoffMs(attempt, options = {}) {
+  const initial = options.initialWaitMs ?? DEFAULT_INITIAL_WAIT_MS;
+  const max = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  return Math.min(initial * 2 ** Math.max(0, attempt - 1), max);
+}
+function retryWaitMs(response, attempt, options = {}) {
+  if (response.status === 429) {
+    const retryAfter = retryAfterMs(response);
+    if (retryAfter !== null) return Math.min(retryAfter, options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS);
+  }
+  if (response.status >= 500 && response.status <= 599 || response.status === 429) {
+    return backoffMs(attempt, options);
+  }
   return null;
 }
-function backoffMs(attempt, response) {
-  const retryAfter = response?.status === 429 ? retryAfterMs(response) : null;
-  if (retryAfter !== null) return retryAfter;
-  const base = 100 * 2 ** attempt;
-  const jitter = base * 0.1 * (Math.random() * 2 - 1);
-  return Math.max(0, Math.round(base + jitter));
+async function fetchWithProviderRetry(options) {
+  const semaphore = getProviderSemaphore(options.provider, options.concurrency ?? DEFAULT_PROVIDER_CONCURRENCY);
+  return semaphore.run(() => fetchWithRetry(options));
+}
+async function fetchWithRetry(options) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const sleep2 = options.sleep ?? defaultSleep;
+  let response;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    response = await options.fetch();
+    const retryAttempt = attempt + 1;
+    const waitOptions = {
+      ...options.initialWaitMs !== void 0 ? { initialWaitMs: options.initialWaitMs } : {},
+      ...options.maxWaitMs !== void 0 ? { maxWaitMs: options.maxWaitMs } : {}
+    };
+    const waitMs = attempt < maxRetries ? retryWaitMs(response, retryAttempt, waitOptions) : null;
+    if (waitMs === null) return response;
+    await options.onThrottle?.({ provider: options.provider, attempt: retryAttempt, waitMs });
+    await sleep2(waitMs);
+  }
+  return response;
+}
+function getProviderSemaphore(provider, concurrency) {
+  const normalizedProvider = provider || "unknown";
+  const existing = semaphores.get(normalizedProvider);
+  if (existing && existing.limit === concurrency) return existing;
+  const created = new ProviderSemaphore(Math.max(1, Math.floor(concurrency)));
+  semaphores.set(normalizedProvider, created);
+  return created;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+var ProviderSemaphore = class {
+  limit;
+  active = 0;
+  queue = [];
+  constructor(limit) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (this.active < this.limit) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve13) => {
+      this.queue.push(() => {
+        this.active += 1;
+        resolve13();
+      });
+    });
+  }
+  release() {
+    this.active -= 1;
+    const next = this.queue.shift();
+    if (next) next();
+  }
+};
+
+// src/providers/openAiCompatible.ts
+function providerConcurrency() {
+  const raw = Number(envValue({}, "TANYA_PROVIDER_CONCURRENCY"));
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
 }
 var OpenAiCompatibleProvider = class {
   id;
@@ -578,11 +995,13 @@ var OpenAiCompatibleProvider = class {
   timeoutMs;
   temperature;
   topP;
+  adapter;
   constructor(options) {
+    this.adapter = resolveProviderAdapter({ provider: options.id, baseUrl: options.baseUrl });
     this.id = options.id;
     this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.model = options.model;
+    this.baseUrl = (options.baseUrl || this.adapter.defaultBaseUrl || "").replace(/\/$/, "");
+    this.model = options.model || this.adapter.defaultModel || "";
     const envTimeout = parseInt(envValue({}, "TANYA_TIMEOUT_MS"), 10);
     const envTimeoutMs = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : null;
     this.timeoutMs = envTimeoutMs ?? options.timeoutMs ?? 9e4;
@@ -599,54 +1018,62 @@ var OpenAiCompatibleProvider = class {
       if (timeout) clearTimeout(timeout);
       timeout = setTimeout(() => controller.abort(), this.timeoutMs);
     };
-    const requestBody = JSON.stringify({
+    const request = {
       model: this.model,
       messages: input.messages,
-      tools: input.tools?.length ? input.tools : void 0,
-      tool_choice: input.tools?.length ? "auto" : void 0,
       temperature: input.temperature ?? this.temperature,
       top_p: input.topP ?? this.topP,
       max_tokens: input.maxTokens ?? 8192,
       stream: true
-    });
-    let response = null;
-    let finalHttpErrorDetail = "";
-    for (let attempt = 0; attempt < MAX_FETCH_ATTEMPTS; attempt += 1) {
-      resetTimeout();
-      response = await fetch(`${this.baseUrl}/chat/completions`, {
-        method: "POST",
-        signal: controller.signal,
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: requestBody
-      }).catch((error) => {
-        if (controller.signal.aborted) {
-          throw new Error(`Provider ${this.id} timed out before streaming a response.`);
-        }
-        throw error;
-      });
-      if (response.ok && response.body) break;
-      if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === MAX_FETCH_ATTEMPTS - 1) {
-        break;
+    };
+    const schemaWarnings = [];
+    if (input.tools?.length) {
+      if (this.adapter.capabilities.flattenSchemas) {
+        const flattened = flattenToolDefinitions(input.tools);
+        request.tools = flattened.schema;
+        schemaWarnings.push(...flattened.warnings);
+      } else {
+        request.tools = input.tools;
       }
-      finalHttpErrorDetail = await response.text().catch(() => "");
-      await sleep(backoffMs(attempt, response));
-    }
-    if (!response) {
-      if (timeout) clearTimeout(timeout);
-      throw new Error(`Provider ${this.id} failed to open a streaming response.`);
+      request.tool_choice = "auto";
     }
+    const requestBody = JSON.stringify(this.adapter.preRequest ? this.adapter.preRequest(request) : request);
+    resetTimeout();
+    const retryOptions = {
+      provider: this.adapter.id,
+      concurrency: providerConcurrency(),
+      fetch: () => {
+        resetTimeout();
+        return fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          signal: controller.signal,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: requestBody
+        }).catch((error) => {
+          if (controller.signal.aborted) {
+            throw new Error(`Provider ${this.id} timed out before streaming a response.`);
+          }
+          throw error;
+        });
+      },
+      ...input.onProviderThrottle ? { onThrottle: input.onProviderThrottle } : {}
+    };
+    const response = await fetchWithProviderRetry(retryOptions);
     if (!response.ok || !response.body) {
       if (timeout) clearTimeout(timeout);
-      const detail = finalHttpErrorDetail || await response.text().catch(() => "");
+      const detail = await response.text().catch(() => "");
       throw new Error(`Provider ${this.id} returned HTTP ${response.status}: ${detail.slice(0, 500)}`);
     }
     const decoder = new TextDecoder();
     let buffer = "";
     const toolCallParts = /* @__PURE__ */ new Map();
     try {
+      if (schemaWarnings.length > 0) {
+        yield { schemaWarnings };
+      }
       for await (const chunk of response.body) {
         resetTimeout();
         buffer += decoder.decode(chunk, { stream: true });
@@ -659,7 +1086,8 @@ var OpenAiCompatibleProvider = class {
           if (data === "[DONE]") return;
           let parsed;
           try {
-            parsed = JSON.parse(data);
+            const rawParsed = JSON.parse(data);
+            parsed = this.adapter.postResponse ? this.adapter.postResponse(rawParsed) : rawParsed;
           } catch (error) {
             if (envValue({}, "TANYA_DEBUG")) {
               const message = error instanceof Error ? error.message : String(error);
@@ -712,7 +1140,7 @@ var OpenAiCompatibleProvider = class {
 // src/providers/factory.ts
 function createProvider(config) {
   return new OpenAiCompatibleProvider({
-    id: config.profile === "reasoner" ? "deepseek-reasoner" : config.provider,
+    id: config.provider === "deepseek" && config.profile === "reasoner" ? "deepseek-reasoner" : config.provider,
     apiKey: config.apiKey,
     baseUrl: config.baseUrl,
     model: config.model,
@@ -722,6 +1150,161 @@ function createProvider(config) {
   });
 }
 
+// src/providers/parser.ts
+var TOOL_CALL_CORRECTION_LIMIT = 3;
+function malformedToolCallCorrectionMessage(reason) {
+  return `[your last tool call was malformed: ${reason}. Try again with valid JSON.]`;
+}
+function parseProviderToolCalls(rawToolCalls, options = {}) {
+  const warnings = [];
+  const failures = [];
+  const toolCalls = [];
+  rawToolCalls.forEach((raw, index) => {
+    const parsed = parseOneToolCall(raw, index, options.turn ?? 0);
+    warnings.push(...parsed.warnings);
+    if (parsed.failure) {
+      failures.push(parsed.failure);
+      return;
+    }
+    toolCalls.push(parsed.toolCall);
+  });
+  return { toolCalls, warnings, failures };
+}
+function parseToolArguments(rawArguments) {
+  if (rawArguments === void 0 || rawArguments === null || rawArguments === "") {
+    return { ok: true, input: {} };
+  }
+  if (typeof rawArguments === "object") {
+    return { ok: true, input: rawArguments };
+  }
+  if (typeof rawArguments !== "string") {
+    return {
+      ok: false,
+      reason: `tool arguments must be JSON object or string, got ${typeof rawArguments}`,
+      rawArguments: String(rawArguments)
+    };
+  }
+  if (!rawArguments.trim()) return { ok: true, input: {} };
+  try {
+    return { ok: true, input: JSON.parse(rawArguments) };
+  } catch {
+    const preview = previewRawToolArguments(rawArguments);
+    return {
+      ok: false,
+      reason: `malformed JSON arguments: ${preview}`,
+      rawArguments: preview
+    };
+  }
+}
+function parseOneToolCall(raw, index, turn) {
+  const warnings = [];
+  if (!isRecord2(raw)) {
+    const toolCall3 = fallbackToolCall(turn, index, "__malformed_tool_call__", "");
+    return {
+      toolCall: toolCall3,
+      warnings,
+      failure: { reason: `tool call must be an object, got ${typeof raw}`, toolCall: toolCall3, raw }
+    };
+  }
+  const idValue = typeof raw.id === "string" && raw.id.trim() ? raw.id : void 0;
+  const id = idValue ?? `call_${turn}_${index}`;
+  if (!idValue) {
+    warnings.push({
+      reason: `missing tool call id; synthesized ${id}`,
+      toolCallId: id,
+      raw
+    });
+  }
+  const functionRecord = isRecord2(raw.function) ? raw.function : raw;
+  if (!isRecord2(raw.function)) {
+    warnings.push({
+      reason: "missing function wrapper; accepted top-level name/arguments",
+      toolCallId: id,
+      raw
+    });
+  }
+  const name = typeof functionRecord.name === "string" ? functionRecord.name.trim() : "";
+  if (!name) {
+    const toolCall3 = fallbackToolCall(turn, index, "__malformed_tool_call__", stringifyArguments(functionRecord.arguments));
+    return {
+      toolCall: toolCall3,
+      warnings,
+      failure: { reason: "missing function name", toolCall: toolCall3, raw }
+    };
+  }
+  const normalizedArguments = normalizeArguments(functionRecord.arguments, warnings, id, name, raw);
+  const toolCall2 = {
+    id,
+    type: "function",
+    function: {
+      name,
+      arguments: normalizedArguments
+    }
+  };
+  const parsedArguments = parseToolArguments(normalizedArguments);
+  if (!parsedArguments.ok) {
+    return {
+      toolCall: toolCall2,
+      warnings,
+      failure: { reason: parsedArguments.reason, toolCall: toolCall2, raw }
+    };
+  }
+  return { toolCall: toolCall2, warnings };
+}
+function normalizeArguments(value, warnings, toolCallId, tool, raw) {
+  if (value === void 0 || value === null) {
+    warnings.push({
+      reason: "missing arguments; using empty object",
+      toolCallId,
+      tool,
+      raw
+    });
+    return "{}";
+  }
+  if (typeof value === "string") return value;
+  if (typeof value === "object") {
+    warnings.push({
+      reason: "arguments arrived as object; stringified for OpenAI-compatible history",
+      toolCallId,
+      tool,
+      raw
+    });
+    return JSON.stringify(value);
+  }
+  warnings.push({
+    reason: `arguments arrived as ${typeof value}; stringified for correction`,
+    toolCallId,
+    tool,
+    raw
+  });
+  return String(value);
+}
+function stringifyArguments(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function fallbackToolCall(turn, index, name, args) {
+  return {
+    id: `call_${turn}_${index}`,
+    type: "function",
+    function: {
+      name,
+      arguments: args
+    }
+  };
+}
+function previewRawToolArguments(raw) {
+  return raw.length > 500 ? `${raw.slice(0, 500)}...[truncated ${raw.length - 500} chars]` : raw;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // src/safety/workspace.ts
 import { existsSync as existsSync3, lstatSync, realpathSync } from "fs";
 import { dirname as dirname2, resolve as resolve3, relative as relative2 } from "path";
@@ -1418,7 +2001,7 @@ function terminalSvg(config, frame) {
   ${body}
 </svg>`;
 }
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 async function waitForJson(url, timeout = 1e4) {
@@ -1429,7 +2012,7 @@ async function waitForJson(url, timeout = 1e4) {
       if (res.ok) return await res.json();
     } catch {
     }
-    await sleep2(120);
+    await sleep(120);
   }
   throw new Error(`Timed out waiting for ${url}`);
 }
@@ -1495,7 +2078,7 @@ async function captureFrames(config, frameDir, svgDir, chromeProfile) {
     await page.send("Emulation.setDefaultBackgroundColorOverride", { color: { r: 0, g: 0, b: 0, a: 0 } });
     const html = `<!doctype html><html><head><meta charset="utf-8"><style>html,body{margin:0;width:${config.width}px;height:${config.height}px;overflow:hidden;background:transparent;}svg{display:block;width:${config.width}px;height:${config.height}px;}</style></head><body></body></html>`;
     await page.send("Page.navigate", { url: `data:text/html;charset=utf-8,${encodeURIComponent(html)}` });
-    await sleep2(250);
+    await sleep(250);
     const totalFrames = Math.round(config.fps * config.duration);
     for (let i = 0; i < totalFrames; i += 1) {
       const n = String(i + 1).padStart(4, "0");
@@ -5177,15 +5760,15 @@ function metadataBoolean(runContext, key) {
   const value = runContext?.metadata?.[key];
   return value === true || value === "true" || value === "yes";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function metadataRecord(runContext, key) {
   const value = runContext?.metadata?.[key];
-  return isRecord2(value) ? value : void 0;
+  return isRecord3(value) ? value : void 0;
 }
 function recordArray2(value) {
-  return Array.isArray(value) ? value.filter(isRecord2) : [];
+  return Array.isArray(value) ? value.filter(isRecord3) : [];
 }
 function autoBriefRecords(runContext, key) {
   return recordArray2(metadataRecord(runContext, "autoBrief")?.[key]);
@@ -8610,25 +9193,6 @@ import { cp as cp2, mkdir as mkdir10, rm as rm2, stat as stat6 } from "fs/promis
 import { dirname as dirname12, isAbsolute as isAbsolute3, join as join15, relative as relative9, resolve as resolve9 } from "path";
 var CONTEXT_TOKEN_LIMIT = 48e3;
 var CONTEXT_SUMMARY_KEEP_RECENT = 6;
-function isMalformedToolArguments(value) {
-  return Boolean(value && typeof value === "object" && value.ok === false && typeof value.rawArguments === "string");
-}
-function previewRawToolArguments(raw) {
-  return raw.length > 500 ? `${raw.slice(0, 500)}...[truncated ${raw.length - 500} chars]` : raw;
-}
-function parseToolArguments(raw) {
-  if (!raw.trim()) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    const rawPreview = previewRawToolArguments(raw);
-    return {
-      ok: false,
-      error: `malformed tool arguments: ${rawPreview}`,
-      rawArguments: rawPreview
-    };
-  }
-}
 function findSafeCompressionBoundary(messages, desiredKeepCount) {
   if (messages.length <= desiredKeepCount + 1) return Math.max(1, messages.length - desiredKeepCount);
   let startIndex = messages.length - desiredKeepCount;
@@ -9027,6 +9591,7 @@ async function runAgent(options) {
   let createdArtifactPaths = [];
   const requiredTool = requiredHighLevelTool(options.runContext, options.prompt);
   let requiredToolUsed = requiredTool ? false : true;
+  let toolCallCorrectionAttempts = 0;
   async function syncArtifactOutput() {
     const outputRootValue = options.runContext?.metadata?.artifactOutputRoot;
     if (typeof outputRootValue !== "string" || !outputRootValue.trim()) return [];
@@ -9095,7 +9660,7 @@ async function runAgent(options) {
     }
     await options.sink({ type: "message_start" });
     let assistantText = "";
-    let toolCalls = [];
+    let rawToolCalls = [];
     const codingProviderOptions = isCodingTask(options.runContext) ? { temperature: 0, topP: 0.2 } : {};
     let providerAttempt = 0;
     const PROVIDER_TRANSIENT_RETRIES = 1;
@@ -9104,24 +9669,44 @@ async function runAgent(options) {
         for await (const delta of options.provider.streamChat({
           messages,
           tools: registry.list().map((tool) => tool.definition),
+          onProviderThrottle: (event) => {
+            void Promise.resolve(options.sink({
+              type: "provider_throttle",
+              provider: event.provider,
+              attempt: event.attempt,
+              waitMs: event.waitMs
+            })).catch(() => {
+            });
+          },
           ...codingProviderOptions
         })) {
           if (delta.usage) {
             totalPromptTokens += delta.usage.promptTokens;
             totalCompletionTokens += delta.usage.completionTokens;
           }
+          if (delta.schemaWarnings) {
+            for (const warning of delta.schemaWarnings) {
+              await options.sink({
+                type: "schema_flatten_warning",
+                reason: warning.reason,
+                path: warning.path,
+                provider: options.provider.id,
+                ...warning.tool ? { tool: warning.tool } : {}
+              });
+            }
+          }
           if (delta.content) {
             assistantText += delta.content;
             finalText += delta.content;
             await options.sink({ type: "message_delta", text: delta.content });
           }
-          if (delta.toolCalls?.length) toolCalls = delta.toolCalls;
+          if (delta.toolCalls?.length) rawToolCalls = delta.toolCalls;
         }
         break;
       } catch (err) {
         const message2 = err instanceof Error ? err.message : String(err);
         const isTransient = /timed out|fetch failed|ECONNRESET|EAI_AGAIN|ENOTFOUND|socket hang up/i.test(message2);
-        const noProgressYet = assistantText.length === 0 && toolCalls.length === 0;
+        const noProgressYet = assistantText.length === 0 && rawToolCalls.length === 0;
         if (isTransient && noProgressYet && providerAttempt < PROVIDER_TRANSIENT_RETRIES) {
           providerAttempt += 1;
           await options.sink({ type: "status", message: `Provider transient error (${message2.slice(0, 120)}); retrying same turn (${providerAttempt}/${PROVIDER_TRANSIENT_RETRIES}).` });
@@ -9131,6 +9716,62 @@ async function runAgent(options) {
       }
     }
     await options.sink({ type: "message_end" });
+    const parsedToolCalls = rawToolCalls.length > 0 ? parseProviderToolCalls(rawToolCalls, { turn }) : { toolCalls: [], warnings: [], failures: [] };
+    for (const warning of parsedToolCalls.warnings) {
+      await options.sink({
+        type: "tool_call_parse_warning",
+        reason: warning.reason,
+        provider: options.provider.id,
+        turn,
+        attempt: toolCallCorrectionAttempts,
+        ...warning.toolCallId ? { toolCallId: warning.toolCallId } : {},
+        ...warning.tool ? { tool: warning.tool } : {}
+      });
+    }
+    for (const failure of parsedToolCalls.failures) {
+      await options.sink({
+        type: "tool_call_parse_warning",
+        reason: failure.reason,
+        provider: options.provider.id,
+        turn,
+        attempt: toolCallCorrectionAttempts + 1,
+        toolCallId: failure.toolCall.id,
+        tool: failure.toolCall.function.name
+      });
+    }
+    if (parsedToolCalls.failures.length > 0 && toolCallCorrectionAttempts < TOOL_CALL_CORRECTION_LIMIT && turn < maxTurns - 1) {
+      toolCallCorrectionAttempts += 1;
+      messages.push({ role: "assistant", content: assistantText || null });
+      messages.push({
+        role: "user",
+        content: malformedToolCallCorrectionMessage(parsedToolCalls.failures.map((failure) => failure.reason).join("; "))
+      });
+      continue;
+    }
+    if (parsedToolCalls.failures.length > 0) {
+      const failedToolCalls = parsedToolCalls.failures.map((failure) => failure.toolCall);
+      toolErrorCount += failedToolCalls.length;
+      messages.push({
+        role: "assistant",
+        content: assistantText || null,
+        tool_calls: failedToolCalls
+      });
+      for (const failure of parsedToolCalls.failures) {
+        const error = `malformed tool call after ${TOOL_CALL_CORRECTION_LIMIT} correction attempts: ${failure.reason}`;
+        messages.push({ role: "tool", tool_call_id: failure.toolCall.id, content: JSON.stringify({ ok: false, error }) });
+        await options.sink({
+          type: "tool_result",
+          id: failure.toolCall.id,
+          tool: failure.toolCall.function.name,
+          ok: false,
+          summary: "Malformed tool call after correction attempts.",
+          error
+        });
+      }
+      continue;
+    }
+    const toolCalls = parsedToolCalls.toolCalls;
+    if (toolCalls.length > 0) toolCallCorrectionAttempts = 0;
     const assistantMessage = {
       role: "assistant",
       content: assistantText || null
@@ -9197,16 +9838,16 @@ async function runAgent(options) {
     for (const toolCall2 of toolCalls) {
       const toolName = toolCall2.function.name;
       const tool = registry.get(toolName);
-      const callInput = parseToolArguments(toolCall2.function.arguments);
-      if (isMalformedToolArguments(callInput)) {
+      const parsedInput = parseToolArguments(toolCall2.function.arguments);
+      if (!parsedInput.ok) {
         toolErrorCount += 1;
         messages.push({
           role: "tool",
           tool_call_id: toolCall2.id,
           content: JSON.stringify({
             ok: false,
-            error: callInput.error,
-            rawArguments: callInput.rawArguments
+            error: parsedInput.reason,
+            rawArguments: parsedInput.rawArguments
           })
         });
         await options.sink({
@@ -9215,11 +9856,12 @@ async function runAgent(options) {
           tool: toolName,
           ok: false,
           summary: "Invalid tool arguments (malformed JSON).",
-          output: `raw arguments (preview): ${callInput.rawArguments}`,
-          error: callInput.error
+          output: `raw arguments (preview): ${parsedInput.rawArguments}`,
+          error: parsedInput.reason
         });
         continue;
       }
+      const callInput = parsedInput.input;
       toolCallCount += 1;
       await options.sink({ type: "tool_call", id: toolCall2.id, tool: toolName, input: callInput });
       if (!tool) {
@@ -10090,6 +10732,19 @@ ${toolGlyph} ${event.tool}
         break;
       case "command_invoked":
         break;
+      case "tool_call_parse_warning":
+        stream.write(`  warning: malformed tool call (${event.reason})
+`);
+        break;
+      case "schema_flatten_warning":
+        stream.write(`  warning: flattened schema${event.tool ? ` for ${event.tool}` : ""} (${event.reason})
+`);
+        break;
+      case "provider_throttle":
+        stream.write(`
+Provider ${event.provider} throttled; waiting ${Math.ceil(event.waitMs / 1e3)}s before retry ${event.attempt}.
+`);
+        break;
       case "final":
         stream.write(`
 ${event.message.trim()}
@@ -11696,6 +12351,7 @@ var cliOptionDefinitions = [
   { flags: "--output-dir <path>", key: "output-dir", kind: "string", property: "outputDir", aliases: ["outputDir"] },
   { flags: "--plan", key: "plan", kind: "boolean", property: "plan" },
   { flags: "--profile <id>", key: "profile", kind: "string", property: "profile" },
+  { flags: "--provider <name>", key: "provider", kind: "string", property: "provider" },
   { flags: "--prompt-file <path>", key: "prompt-file", kind: "string", property: "promptFile" },
   { flags: "--repair-attempts <count>", key: "repair-attempts", kind: "string", property: "repairAttempts" },
   { flags: "--require-verification <command>", key: "require-verification", kind: "array", property: "requireVerification" },
@@ -11842,6 +12498,11 @@ function applyCliProfileFlag(args) {
   if (!profile) return;
   process.env.TANYA_PROFILE = profile;
 }
+function applyCliProviderFlag(args) {
+  const provider = flagString(args, "provider");
+  if (!provider) return;
+  process.env.TANYA_PROVIDER = provider;
+}
 function buildRetryContext(manifest, attempt, extraBlockers = []) {
   const lines = [
     `RETRY CONTEXT (attempt ${attempt}): the previous run did not complete cleanly.`,
@@ -11907,7 +12568,7 @@ Usage:
   tanya benchmark profiles      List benchmark profiles
   tanya benchmark run --all     Run executable regression benchmarks
   tanya benchmark validate      Validate recent benchmark signatures
-  tanya providers test          Test provider configuration
+  tanya providers test --provider deepseek  Test provider configuration (live only with TANYA_RUN_LIVE_PROVIDER_TESTS=1)
   tanya doctor                  Check local setup
   tanya patterns                Show forbidden-pattern fire metrics for this workspace
 
@@ -12037,20 +12698,31 @@ async function askOnce(provider, prompt) {
   process.stdout.write("\n");
   return text2;
 }
-async function testProvider() {
+async function testProvider(args) {
+  const requestedProvider = flagString(args, "provider") ?? "configured";
+  if (envValue({}, "TANYA_RUN_LIVE_PROVIDER_TESTS") !== "1") {
+    console.log(`skipped live provider test for ${requestedProvider}; set TANYA_RUN_LIVE_PROVIDER_TESTS=1 to run against the real endpoint.`);
+    return;
+  }
   const config = loadConfig();
   const provider = createProvider(config);
   const startedAt = Date.now();
   let text2 = "";
   for await (const delta of provider.streamChat({
-    messages: [{ role: "user", content: "Reply with exactly: pong" }],
+    messages: [
+      { role: "system", content: "You are a provider conformance probe. Keep answers short." },
+      { role: "user", content: "Reply with exactly: pong" },
+      { role: "user", content: "No tools are needed." }
+    ],
     tools: [],
     maxTokens: 12,
     temperature: 0
   })) {
     if (delta.content) text2 += delta.content;
   }
-  console.log(`ok ${provider.id}:${provider.model} ${Date.now() - startedAt}ms ${text2.trim()}`);
+  console.log(`PASS adapter: ${provider.id}:${provider.model}`);
+  console.log(`PASS streaming-chat: ${Date.now() - startedAt}ms ${text2.trim()}`);
+  console.log("PASS parser-surface: mock conformance covers malformed tool-call quirks in CI");
 }
 async function doctor(args) {
   const cwd = resolve12(args ? flagString(args, "cwd") ?? process.cwd() : process.cwd());
@@ -12136,8 +12808,8 @@ async function runVideoCommand(args) {
   if (preset === "presets" || preset === "list") {
     console.log("Video presets:");
     for (const item of videoPresets) {
-      const aliases = item.aliases.length ? ` aliases: ${item.aliases.join(", ")}` : "";
-      console.log(`- ${item.name} (${item.width}x${item.height}, ${item.fps}fps, ${item.duration}s)${aliases}`);
+      const aliases2 = item.aliases.length ? ` aliases: ${item.aliases.join(", ")}` : "";
+      console.log(`- ${item.name} (${item.width}x${item.height}, ${item.fps}fps, ${item.duration}s)${aliases2}`);
       console.log(`  ${item.description}`);
     }
     return;
@@ -12208,6 +12880,7 @@ async function runVideoCommand(args) {
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
+  applyCliProviderFlag(args);
   if (args.command === "help" || args.command === "--help" || args.command === "-h") {
     console.log(usage());
     return;
@@ -12248,10 +12921,10 @@ async function main() {
   }
   if (args.command === "providers") {
     if (args.positional[0] !== "test") {
-      console.log("Usage: tanya providers test");
+      console.log("Usage: tanya providers test --provider <name>");
       return;
     }
-    await testProvider();
+    await testProvider(args);
     return;
   }
   if (args.command === "init") {