@juspay/neurolink 12.11.2 → 12.12.0

package/dist/processors/media/AudioProcessor.js

@@ -335,22 +335,57 @@ export class AudioProcessor extends BaseFileProcessor {
             return skipped(`format is not one Whisper accepts (extension "${ext ?? "none"}", mimetype "${mimetype ?? "none"}"); supported: ${AUDIO_CONFIG.WHISPER_SUPPORTED_FORMATS.join(", ")}`);
         }
         try {
-            // Dynamic imports to avoid loading these modules when transcription is not needed
-            const [{ createOpenAI }, { experimental_transcribe }] = await Promise.all([import("@ai-sdk/openai"), import("../../utils/generation.js")]);
-            const openai = createOpenAI({ apiKey });
-            const model = openai.transcription("whisper-1");
+            // Native multipart POST to OpenAI's transcription endpoint. This used to
+            // go through @ai-sdk/openai's createOpenAI().transcription() plus the ai
+            // package's experimental_transcribe; both were dropped, and this is the
+            // only wire behaviour of theirs the processor ever depended on. The same
+            // request is already made natively by voice/providers/OpenAISTT.ts.
+            // Only `text` is read off the response, as before.
+            const baseUrl = (process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+            const form = new FormData();
+            form.append("file", new Blob([new Uint8Array(buffer)], {
+                type: mimetype || "audio/mpeg",
+            }), filename);
+            form.append("model", "whisper-1");
+            form.append("response_format", "verbose_json");
             // Wrap in withTimeout — large audio files can take a while, but a
             // stalled request shouldn't block the processor forever. A TimeoutError
             // lands in the same handler as other failures below, which reports it as
             // the reason rather than discarding it.
-            const result = await withTimeout(experimental_transcribe({
-                model,
-                audio: buffer,
-            }), AUDIO_CONFIG.TRANSCRIPTION_TIMEOUT_MS, "openai-whisper", "generate");
-            if (result.text && result.text.trim().length > 0) {
-                logger.debug(`[AudioProcessor] Transcribed ${filename} via openai-whisper (${result.text.trim().length} chars)`);
+            // `withTimeout` only races the promise against a timer — it cannot
+            // cancel the operation. This code owns the raw fetch now, so without an
+            // abort the socket and its in-flight upload (up to 25MB) stay alive
+            // after the timeout has already resolved the caller.
+            const transcriptionAbort = new AbortController();
+            const transcriptionTimer = setTimeout(() => transcriptionAbort.abort(), AUDIO_CONFIG.TRANSCRIPTION_TIMEOUT_MS);
+            let response;
+            try {
+                response = await withTimeout(fetch(`${baseUrl}/audio/transcriptions`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                    body: form,
+                    signal: transcriptionAbort.signal,
+                }), AUDIO_CONFIG.TRANSCRIPTION_TIMEOUT_MS, "openai-whisper", "generate");
+            }
+            finally {
+                clearTimeout(transcriptionTimer);
+            }
+            if (!response.ok) {
+                const detail = await response.text().catch(() => "");
+                // Mirrors the old behaviour: a non-2xx used to surface as a thrown
+                // APICallError caught by the handler below and reported as the reason.
+                return skipped(`transcription request failed — HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`);
+            }
+            const payload = await response.json();
+            const rawText = typeof payload === "object" &&
+                payload !== null &&
+                typeof payload.text === "string"
+                ? payload.text
+                : "";
+            if (rawText.trim().length > 0) {
+                logger.debug(`[AudioProcessor] Transcribed ${filename} via openai-whisper (${rawText.trim().length} chars)`);
                 return {
-                    transcript: result.text.trim(),
+                    transcript: rawText.trim(),
                     hasTranscript: true,
                     transcriptionProvider: "openai-whisper",
                     transcriptionSkippedReason: undefined,

package/dist/providers/amazonSagemaker.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { StreamOptions } from "../types/index.js";
+import type { EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
 /**
  * Amazon SageMaker Provider extending BaseProvider
@@ -20,6 +20,22 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModel;
+    /**
+     * Native non-streaming generate.
+     *
+     * SageMaker's doGenerate makes one invokeEndpoint call and already returns
+     * toolCalls; no streaming is involved, so the wire hazard that reverted the
+     * first migration does not apply here. This supplies only the multi-step
+     * iteration the ai package used to.
+     *
+     * NOT EXERCISED LIVE. This machine has no SageMaker endpoint or credentials.
+     * The single-step shape is identical by construction — with no tool calls the
+     * loop breaks after exactly one doGenerate carrying the same options the ai
+     * loop passed. The multi-step branch is the new code and wants a real
+     * endpoint before it is trusted.
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    private executeNativeGenerate;
     /**
      * Streaming was previously an `executeStream` override that unconditionally
      * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`

package/dist/providers/amazonSagemaker.js

@@ -1,6 +1,13 @@
 import { BaseProvider } from "../core/baseProvider.js";
 import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
+import { resolveRequestKind } from "../core/resolveRequestKind.js";
+import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
+import { withProviderRetry } from "../utils/providerRetry.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
 import { withSpan } from "../telemetry/withSpan.js";
 import { tracers } from "../telemetry/tracers.js";
 // SageMaker-specific imports
@@ -93,6 +100,109 @@ export class AmazonSageMakerProvider extends BaseProvider {
         const smModel = this.sagemakerModel;
         return smModel;
     }
+    /**
+     * Native non-streaming generate.
+     *
+     * SageMaker's doGenerate makes one invokeEndpoint call and already returns
+     * toolCalls; no streaming is involved, so the wire hazard that reverted the
+     * first migration does not apply here. This supplies only the multi-step
+     * iteration the ai package used to.
+     *
+     * NOT EXERCISED LIVE. This machine has no SageMaker endpoint or credentials.
+     * The single-step shape is identical by construction — with no tool calls the
+     * loop breaks after exactly one doGenerate carrying the same options the ai
+     * loop passed. The multi-step branch is the new code and wants a real
+     * endpoint before it is trusted.
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        await this.ensureModelLimits();
+        const options = this.normalizeTextOptions(optionsOrPrompt);
+        if (resolveRequestKind(options, this.modelName) !== "text") {
+            return super.generate(options, analysisSchema);
+        }
+        this.validateOptions(options);
+        const mergedTools = await this.getToolsForStream(options);
+        const callerOwnsFallback = "disableInternalFallback" in options &&
+            options.disableInternalFallback === true;
+        // The native loop bypasses BaseProvider.executeGeneration, so the turn
+        // budget has to be composed here or it stops existing for this provider.
+        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback);
+    }
+    async executeNativeGenerate(options) {
+        const startTime = Date.now();
+        // Middleware must wrap the model here. The native loop bypasses
+        // BaseProvider.executeGeneration, and with it the only place middleware was
+        // ever applied — a probe showed a caller's wrapGenerate running zero times
+        // on every native provider while their onFinish still fired, because
+        // onFinish had been special-cased and nothing else had.
+        const model = await this.getAISDKModelWithMiddleware(options);
+        if (!hasNativeDoGenerate(model)) {
+            throw this.handleProviderError(new Error("sagemaker: model handle exposes no doGenerate()"));
+        }
+        const doGenerate = model.doGenerate.bind(model);
+        const shouldUseTools = !options.disableTools && this.supportsTools();
+        const toolsRecord = shouldUseTools
+            ? options.tools || {}
+            : {};
+        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => {
+            const tool = t;
+            return {
+                type: "function",
+                name,
+                description: tool.description ?? "",
+                inputSchema: (tool.inputSchema
+                    ? convertZodToJsonSchema(tool.inputSchema)
+                    : { type: "object", properties: {} }),
+            };
+        });
+        // Structured output was dropped entirely on this path: the schema never
+        // reached the request, and nothing downstream re-imposed it, so a caller
+        // asking for an object got whatever JSON coerceJsonToSchema could scrape
+        // out of prose.
+        const responseFormat = options.schema
+            ? {
+                type: "json",
+                schema: convertZodToJsonSchema(options.schema),
+            }
+            : undefined;
+        const conversation = (await this.buildMessagesForStream(options));
+        const toolExecutionSummaries = [];
+        const loop = await runNativeGenerateLoop({
+            doGenerate,
+            conversation,
+            ...(responseFormat ? { responseFormat } : {}),
+            ...(v3Tools.length > 0 ? { tools: v3Tools } : {}),
+            toolsRecord,
+            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+            ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
+            ...(options.toolTimeoutMs !== undefined
+                ? { toolTimeoutMs: options.toolTimeoutMs }
+                : {}),
+            runStep: (call) => withProviderRetry(call, undefined, "sagemaker generate").catch((err) => {
+                throw this.handleProviderError(err);
+            }),
+        }, toolExecutionSummaries);
+        const enhanced = {
+            content: loop.text,
+            provider: this.providerName,
+            model: this.modelName,
+            finishReason: loop.finishReason,
+            usage: {
+                input: loop.inputTokens,
+                output: loop.outputTokens,
+                total: loop.inputTokens + loop.outputTokens,
+            },
+            responseTime: Date.now() - startTime,
+            toolsUsed: loop.toolsUsed,
+            toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
+            enhancedWithTools: loop.toolsUsed.length > 0,
+        };
+        return this.finalizeNativeGenerate(enhanced, options, startTime);
+    }
     /**
      * Streaming was previously an `executeStream` override that unconditionally
      * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`

package/dist/providers/anthropic/client.d.ts

@@ -133,6 +133,17 @@ export declare class AnthropicProvider extends BaseProvider {
      * BaseProvider so that expired tokens are renewed automatically.
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Text turns run natively; every other request kind still goes to
+     * BaseProvider.generate().
+     *
+     * The loop runs over this provider's own delegating-model `doGenerate`,
+     * which issues a NON-streaming `messages.create`. That matters: the streaming
+     * loop adapter hardcodes `stream: true`, and an earlier attempt that routed
+     * generate through it silently changed the wire.
+     */
+    private dispatchGenerate;
+    private executeNativeGenerate;
     /**
      * Fold a captured snapshot into the provider's usage bookkeeping and log it.
      *

package/dist/providers/anthropic/client.js

@@ -25,6 +25,11 @@ import { calculateCost } from "../../utils/pricing.js";
 import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicLoopAdapter } from "./loopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
+import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../../core/nativeGenerateLoop.js";
+import { withProviderRetry } from "../../utils/providerRetry.js";
+import { resolveRequestKind } from "../../core/resolveRequestKind.js";
+import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
+import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
 import { resolveToolChoice } from "../../utils/toolChoice.js";
@@ -1327,7 +1332,7 @@ export class AnthropicProvider extends BaseProvider {
         // rather than on the instance is what makes it concurrency-safe: several
         // generate() calls can be in flight on one provider instance, and an
         // instance field would attribute one call's limits to another.
-        const { result, snapshot } = await withLimitCapture(() => super.generate(optionsOrPrompt, analysisSchema));
+        const { result, snapshot } = await withLimitCapture(() => this.dispatchGenerate(optionsOrPrompt, analysisSchema));
         if (result && snapshot) {
             this.recordLimitSnapshot(snapshot);
             result.limits = snapshot;
@@ -1337,6 +1342,148 @@ export class AnthropicProvider extends BaseProvider {
         }
         return result;
     }
+    /**
+     * Text turns run natively; every other request kind still goes to
+     * BaseProvider.generate().
+     *
+     * The loop runs over this provider's own delegating-model `doGenerate`,
+     * which issues a NON-streaming `messages.create`. That matters: the streaming
+     * loop adapter hardcodes `stream: true`, and an earlier attempt that routed
+     * generate through it silently changed the wire.
+     */
+    async dispatchGenerate(optionsOrPrompt, analysisSchema) {
+        await this.ensureModelLimits();
+        const options = this.normalizeTextOptions(optionsOrPrompt);
+        if (resolveRequestKind(options, this.modelName) !== "text") {
+            return super.generate(options, analysisSchema);
+        }
+        this.validateOptions(options);
+        const mergedTools = await this.getToolsForStream(options);
+        const callerOwnsFallback = "disableInternalFallback" in options &&
+            options.disableInternalFallback === true;
+        // The native loop bypasses BaseProvider.executeGeneration, so the turn
+        // budget has to be composed here or it stops existing for this provider.
+        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback);
+    }
+    async executeNativeGenerate(options) {
+        const startTime = Date.now();
+        const modelId = this.modelName || getDefaultAnthropicModel();
+        // Middleware must wrap the model here. The native loop bypasses
+        // BaseProvider.executeGeneration, and with it the only place middleware was
+        // ever applied — a probe showed a caller's wrapGenerate running zero times
+        // on every native provider while their onFinish still fired, because
+        // onFinish had been special-cased and nothing else had.
+        const model = await this.getAISDKModelWithMiddleware(options);
+        if (!hasNativeDoGenerate(model)) {
+            throw this.handleProviderError(new Error("anthropic: model handle exposes no doGenerate()"));
+        }
+        const doGenerate = model.doGenerate.bind(model);
+        const shouldUseTools = !options.disableTools && this.supportsTools();
+        const toolsRecord = shouldUseTools
+            ? options.tools || {}
+            : {};
+        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => {
+            const tool = t;
+            return {
+                type: "function",
+                name,
+                description: tool.description ?? "",
+                inputSchema: (tool.inputSchema
+                    ? convertZodToJsonSchema(tool.inputSchema)
+                    : { type: "object", properties: {} }),
+            };
+        });
+        const hasTools = v3Tools.length > 0;
+        // Two structured-output routes, and doGenerate implements both. With no
+        // tools it replaces the tool list with one forced json tool; with tools it
+        // APPENDS final_result so the real tools stay callable. Picking the wrong
+        // one is what dropped structuredData to null on the first attempt.
+        const schemaJson = options.schema
+            ? convertZodToJsonSchema(options.schema)
+            : undefined;
+        const responseFormat = schemaJson && !hasTools
+            ? { type: "json", schema: schemaJson }
+            : undefined;
+        const anthropicNamespace = {};
+        if (schemaJson && hasTools) {
+            anthropicNamespace.finalResultSchema = schemaJson;
+        }
+        if (options.thinkingConfig?.enabled &&
+            options.thinkingConfig.budgetTokens) {
+            anthropicNamespace.thinking = {
+                type: "enabled",
+                budget_tokens: options.thinkingConfig.budgetTokens,
+            };
+        }
+        // The per-call `timeout` keeps its per-MODEL-CALL meaning once
+        // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the model
+        // layer only through providerOptions.neurolink. Without it each step fell
+        // back to the provider default.
+        const mergedProviderOptions = {};
+        if (Object.keys(anthropicNamespace).length > 0) {
+            mergedProviderOptions.anthropic = anthropicNamespace;
+        }
+        if (typeof options.timeout === "number") {
+            mergedProviderOptions.neurolink = { timeoutMs: options.timeout };
+        }
+        const providerOptions = Object.keys(mergedProviderOptions).length > 0
+            ? mergedProviderOptions
+            : undefined;
+        const conversation = (await this.buildMessagesForStream(options));
+        const toolExecutionSummaries = [];
+        const loop = await runNativeGenerateLoop({
+            doGenerate,
+            conversation,
+            ...(hasTools ? { tools: v3Tools } : {}),
+            toolsRecord,
+            // A caller's toolChoice was dropped here while the streaming path and
+            // the OpenAI-compatible native path both forwarded it, so
+            // `toolChoice: "required"` and named-tool choices silently degraded to
+            // Anthropic's default `auto` on generate().
+            ...(hasTools && options.toolChoice
+                ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
+                : {}),
+            ...(responseFormat ? { responseFormat } : {}),
+            ...(providerOptions ? { providerOptions } : {}),
+            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+            ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
+            ...(options.toolTimeoutMs !== undefined
+                ? { toolTimeoutMs: options.toolTimeoutMs }
+                : {}),
+            runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, "anthropic generate").catch((err) => {
+                throw this.handleProviderError(err);
+            }),
+        }, toolExecutionSummaries);
+        const enhanced = {
+            content: loop.text,
+            provider: this.providerName,
+            model: modelId,
+            finishReason: loop.finishReason,
+            ...(loop.rawFinishReason
+                ? { rawFinishReason: loop.rawFinishReason }
+                : {}),
+            usage: {
+                input: loop.inputTokens,
+                output: loop.outputTokens,
+                total: loop.inputTokens + loop.outputTokens,
+                ...(loop.cacheReadTokens
+                    ? { cacheReadTokens: loop.cacheReadTokens }
+                    : {}),
+                ...(loop.cacheWriteTokens
+                    ? { cacheCreationTokens: loop.cacheWriteTokens }
+                    : {}),
+            },
+            responseTime: Date.now() - startTime,
+            toolsUsed: loop.toolsUsed,
+            toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
+            enhancedWithTools: loop.toolsUsed.length > 0,
+        };
+        return this.finalizeNativeGenerate(enhanced, options, startTime);
+    }
     /**
      * Fold a captured snapshot into the provider's usage bookkeeping and log it.
      *

package/dist/providers/catalog/index.generated.d.ts

@@ -1,3 +1,3 @@
 import type { ProviderCatalogJson } from "../../types/index.js";
 export declare const CATALOG_JSON_ENTRIES: ProviderCatalogJson[];
-export declare const CATALOG_PROVIDER_IDS: readonly ["baseten", "cerebras", "cloudflare", "fireworks", "gmicloud", "groq", "inception-labs", "io-intelligence", "mistral", "perplexity", "sambanova", "together-ai", "upstage", "xai"];
+export declare const CATALOG_PROVIDER_IDS: readonly ["baseten", "cerebras", "cloudflare", "fireworks", "gmicloud", "groq", "inception-labs", "io-intelligence", "mancer", "mistral", "perplexity", "sambanova", "together-ai", "upstage", "xai"];

package/dist/providers/catalog/index.generated.js

@@ -8,6 +8,7 @@ import gmicloudJson from "./gmicloud.json" with { type: "json" };
 import groqJson from "./groq.json" with { type: "json" };
 import inceptionLabsJson from "./inception-labs.json" with { type: "json" };
 import ioIntelligenceJson from "./io-intelligence.json" with { type: "json" };
+import mancerJson from "./mancer.json" with { type: "json" };
 import mistralJson from "./mistral.json" with { type: "json" };
 import perplexityJson from "./perplexity.json" with { type: "json" };
 import sambanovaJson from "./sambanova.json" with { type: "json" };
@@ -23,6 +24,7 @@ export const CATALOG_JSON_ENTRIES = [
     groqJson,
     inceptionLabsJson,
     ioIntelligenceJson,
+    mancerJson,
     mistralJson,
     perplexityJson,
     sambanovaJson,
@@ -39,6 +41,7 @@ export const CATALOG_PROVIDER_IDS = [
     "groq",
     "inception-labs",
     "io-intelligence",
+    "mancer",
     "mistral",
     "perplexity",
     "sambanova",

package/dist/providers/catalog/loader.js

@@ -89,6 +89,7 @@ export function buildCatalogEntries() {
                 entry.models.fallbacks[0],
             fallbackModels: [...entry.models.fallbacks],
             errorRules: buildErrorRules(entry),
+            supportsTools: entry.capabilities.tools,
         };
         const { baseURLTemplate } = entry.wire;
         if (baseURLTemplate) {

package/dist/providers/catalog/mancer.json

@@ -0,0 +1,192 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "mancer",
+    "displayName": "Mancer",
+    "aliases": ["mancer-tech"],
+    "tier": 2,
+    "wire": {
+        "baseURL": "https://neuro.mancer.tech/oai/v1"
+    },
+    "models": {
+        "default": "deepseek-v4-flash",
+        "fallbacks": ["deepseek-v4-flash", "gpt-oss-120b"],
+        "defaultContextWindow": 1048576,
+        "defaultMaxOutputTokens": 1048576,
+        "catalog": {
+            "mythomax": {
+                "contextWindow": 8192,
+                "maxOutputTokens": 8192,
+                "pricingPerMTok": {
+                    "input": 0.14,
+                    "output": 0.24
+                },
+                "vision": false,
+                "status": "production",
+                "description": "MythoMax (LLaMA 2, Simplified Alpaca format) — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "deepseek-v4-flash": {
+                "contextWindow": 1048576,
+                "maxOutputTokens": 1048576,
+                "pricingPerMTok": {
+                    "input": 0.07,
+                    "output": 0.2
+                },
+                "vision": false,
+                "status": "production",
+                "description": "DeepSeek V4 Flash — Mancer's flagship general model; paid credits required — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "deepseek-v4-flash-0731": {
+                "contextWindow": 1048576,
+                "maxOutputTokens": 1048576,
+                "pricingPerMTok": {
+                    "input": 0.07,
+                    "output": 0.2
+                },
+                "vision": false,
+                "status": "production",
+                "description": "DeepSeek V4 Flash, 2026-07-31 snapshot; paid credits required — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "mytholite": {
+                "contextWindow": 2560,
+                "maxOutputTokens": 150,
+                "pricingPerMTok": {
+                    "input": 0,
+                    "output": 0
+                },
+                "vision": false,
+                "status": "production",
+                "description": "MythoLite — Mancer's free demo model (2,560-token context, 150-token completions, Simplified Alpaca format); the only model usable with a zero balance — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "remm-slerp": {
+                "contextWindow": 6144,
+                "maxOutputTokens": 6144,
+                "pricingPerMTok": {
+                    "input": 0.14,
+                    "output": 0.26
+                },
+                "vision": false,
+                "status": "production",
+                "description": "ReMM-SLERP (Simplified Alpaca format) — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "magnum-72b-v4": {
+                "contextWindow": 32768,
+                "maxOutputTokens": 4096,
+                "pricingPerMTok": {
+                    "input": 1,
+                    "output": 2
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Magnum 72B v4 (ChatML format) — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "glm-4.7": {
+                "contextWindow": 131072,
+                "maxOutputTokens": 131072,
+                "pricingPerMTok": {
+                    "input": 0.28,
+                    "output": 1
+                },
+                "vision": false,
+                "status": "production",
+                "description": "GLM-4.7 — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "gpt-oss-120b": {
+                "contextWindow": 131072,
+                "maxOutputTokens": 131072,
+                "pricingPerMTok": {
+                    "input": 0.022,
+                    "output": 0.2
+                },
+                "vision": false,
+                "status": "production",
+                "description": "GPT-OSS 120B — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "weaver-alpha": {
+                "contextWindow": 8000,
+                "maxOutputTokens": 6000,
+                "pricingPerMTok": {
+                    "input": 0.16,
+                    "output": 0.3
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Weaver Alpha (Simplified Alpaca format) — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            },
+            "dans-pe-1.3-24b": {
+                "contextWindow": 32768,
+                "maxOutputTokens": 8192,
+                "pricingPerMTok": {
+                    "input": 0.2,
+                    "output": 0.8
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Dan's PersonalityEngine 1.3 24B — pricing and limits from the authenticated /oai/v1/models roster, 2026-09-03"
+            }
+        },
+        "topModels": ["deepseek-v4-flash", "gpt-oss-120b", "glm-4.7", "mytholite"],
+        "testModel": "mytholite"
+    },
+    "capabilities": {
+        "text": true,
+        "streaming": true,
+        "tools": false,
+        "toolsWithStreaming": false,
+        "structuredOutput": true,
+        "structuredOutputWithTools": false,
+        "embeddings": false,
+        "thinking": false
+    },
+    "errorRules": [
+        {
+            "status": 401,
+            "pattern": "Bad API key",
+            "class": "authentication",
+            "message": "Invalid Mancer API key. Check {apiKeyEnvVar}. Get one at https://mancer.tech/dashboard"
+        },
+        {
+            "pattern": "Unknown Model",
+            "class": "invalid-model",
+            "message": "Mancer model '{model}' is unknown. Pick a current model from the /oai/v1/models roster or https://mancer.tech/pricing."
+        },
+        {
+            "status": 402,
+            "pattern": "requires paid credits",
+            "class": "provider",
+            "message": "Mancer model '{model}' requires paid credits; with a zero balance only the free model 'mytholite' works. Add credits at https://mancer.tech/dashboard or see https://mancer.tech/pricing."
+        }
+    ],
+    "setup": {
+        "url": "https://mancer.tech/dashboard",
+        "apiKeyFormat": "^mcr_[A-Za-z0-9]+$",
+        "billingPolicy": "free-tier",
+        "instructions": [
+            "1. Visit: https://mancer.tech/dashboard and sign in",
+            "2. Create an API key (prefix mcr_)",
+            "3. Without credits only the free model 'mytholite' answers; every other model returns 402 until you add credits at https://mancer.tech/pricing",
+            "4. Set {apiKeyEnvVar} in your .env file"
+        ],
+        "description": "OpenAI-compatible endpoint at https://neuro.mancer.tech/oai/v1. One free demo model; paid credits unlock the rest of the roster."
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-03",
+            "method": "authenticated GET /oai/v1/models; full response retained as evidence/mancer-roster-authenticated.json in the campaign scratchpad and every catalog price/limit machine-checked against it (Mancer re-prices — gpt-oss-120b input moved 0.024 → 0.022 within the day)",
+            "status": 200
+        },
+        "authProbe": {
+            "date": "2026-09-03",
+            "status": 401
+        },
+        "billingProbe": {
+            "date": "2026-09-03",
+            "status": 402,
+            "method": "POST /oai/v1/chat/completions on deepseek-v4-flash with a zero balance: {\"error\":{\"type\":\"CANT_AFFORD\",\"message\":\"This model requires paid credits to use!\"}}"
+        },
+        "liveMatrix": {
+            "date": "2026-09-03",
+            "result": "18-probe harness on the free model mytholite: roster, chat, max_completion_tokens, system role, content parts, sampling params, SSE stream (usage chunk + [DONE]), json_schema (valid JSON matching schema) and json_object all 200; tools and tools+schema 400 BAD_PARAMETERS ('\"auto\" tool choice requires --enable-auto-tool-choice and --tool-call-parser') so tools are declared false; vision 200 but text-only (image ignored); bad key 401 'Bad API key'; unknown model 400 'Unknown Model'. Paid models could not be capability-probed without credits — tools may work there and can be re-declared once probed. Nightly matrix pins testModel mytholite."
+        },
+        "addedInPR": "pending"
+    }
+}