@coinrithm/mcp-trading 0.7.14 → 0.7.16

package/dist/agent/providerCapabilities.js

@@ -1,6 +1,16 @@
 import { DECISION_JSON_SCHEMA } from "./decision.js";
 export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
 export const DECISION_TOOL_NAME = "submit_trading_decision";
+// A retry changes transport only after the strict parser has rejected a known
+// Super tool-argument encoding failure. Valid responses and other routes keep
+// their original request shape. A custom endpoint is deliberately excluded.
+export function canRetrySuperToolOutput(route, responseSource, actionsStringDiagnostic) {
+    return (route.provider === "nvidia" &&
+        route.model === "nvidia/nemotron-3-super-120b-a12b" &&
+        (route.baseUrl == null || route.baseUrl === NVIDIA_BASE_URL) &&
+        responseSource === "tool_call" &&
+        actionsStringDiagnostic !== undefined);
+}
 // gpt-5*, o1/o3/o4* — the OpenAI reasoning-API family, wherever it is served.
 const OPENAI_REASONING_MODEL = /^(gpt-5|o[0-9])/i;
 const NEMOTRON_MODEL = /nemotron/i;
@@ -54,18 +64,61 @@ export function chatShapeFor(provider, model, baseUrl) {
         minProbeCompletionTokens: 1024,
     };
 }
+// Opt-in alternative for a hosted Nemotron route: plain JSON content
+// (`response_format: json_object`) instead of the forced decision tool call.
+// Hosted Super has returned the forced tool call with `actions` as a string
+// (519 of 533 malformed attempts in a 24h sample, 2026-10-05). In an 8-call
+// synthetic smoke pilot the tool-call arms failed 0/4 with the same coarse
+// string shape and the JSON-content arm parsed 2/2; that is not a rate
+// measurement and the exact serialization cause is not established. Only the
+// request transport changes: parseDecision still validates the full contract.
+export function withJsonContentTransport(shape) {
+    if (shape.family !== "nvidia-nemotron")
+        return shape;
+    return { ...shape, jsonSchema: undefined, jsonSchemaTransport: undefined };
+}
+// Transport-only restriction: drop the excluded variants from the action oneOf
+// a route decodes against. parseDecision keeps validating the FULL contract, so
+// a route that does not enforce a schema can still propose the action and the
+// validator rejects it. Never returns an empty oneOf.
+export function restrictDecisionSchema(schema, exclude) {
+    if (!exclude?.length)
+        return schema;
+    const properties = schema.properties;
+    const actions = properties?.actions;
+    const variants = actions?.items?.oneOf;
+    if (!properties || !actions || !Array.isArray(variants))
+        return schema;
+    const kept = variants.filter((variant) => {
+        const type = variant
+            .properties?.type?.const;
+        return !exclude.includes(type);
+    });
+    if (kept.length === variants.length || kept.length === 0)
+        return schema;
+    return {
+        ...schema,
+        properties: {
+            ...properties,
+            actions: { ...actions, items: { ...actions.items, oneOf: kept } },
+        },
+    };
+}
 /** Build the chat-completions body for a route from its capability shape. */
 export function buildChatBody(shape, args) {
     const system = shape.systemHint
         ? `${shape.systemHint}\n\n${args.system}`
         : args.system;
+    const jsonSchema = shape.jsonSchema
+        ? restrictDecisionSchema(shape.jsonSchema, args.excludeActionTypes)
+        : undefined;
     return {
         model: args.model,
         ...(shape.allowsTemperature
             ? { temperature: args.temperature ?? 0.2 }
             : {}),
         [shape.tokenParam]: args.maxTokens,
-        ...(shape.jsonSchema && shape.jsonSchemaTransport === "tool_call"
+        ...(jsonSchema && shape.jsonSchemaTransport === "tool_call"
             ? {
                 tools: [
                     {
@@ -73,7 +126,7 @@ export function buildChatBody(shape, args) {
                         function: {
                             name: DECISION_TOOL_NAME,
                             description: "Submit the complete CoinRithm paper-trading decision for this cycle.",
-                            parameters: shape.jsonSchema,
+                            parameters: jsonSchema,
                         },
                     },
                 ],
@@ -85,12 +138,12 @@ export function buildChatBody(shape, args) {
             : {}),
         ...(shape.jsonResponseFormat && shape.jsonSchemaTransport !== "tool_call"
             ? {
-                response_format: shape.jsonSchema
+                response_format: jsonSchema
                     ? {
                         type: "json_schema",
                         json_schema: {
                             name: "coinrithm_trading_decision",
-                            schema: shape.jsonSchema,
+                            schema: jsonSchema,
                         },
                     }
                     : { type: "json_object" },

package/dist/agent/providers.d.ts

@@ -1,9 +1,23 @@
 import { AgentSpec, ProviderName } from "./types.js";
+import { type ActionsStringDiagnostic } from "./decision.js";
+import { type DecisionActionExclusion } from "./providerCapabilities.js";
+export interface ProviderUsage {
+    promptTokens: number;
+    completionTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    cacheWrite5mTokens?: number;
+    cacheWrite1hTokens?: number;
+}
+export declare function anthropicUsage(raw: unknown): ProviderUsage | undefined;
 export interface DecideInput {
     system: string;
     user: string;
+    /** Optional equivalent presentation for explicitly verified hosted routes. */
+    compactUser?: string;
     maxTokens?: number;
     timeoutMs?: number;
+    excludeActionTypes?: readonly DecisionActionExclusion[];
 }
 export interface DecideRouteAttempt {
     provider: string;
@@ -14,6 +28,10 @@ export interface DecideRouteAttempt {
     retryAfterMs?: number;
     latencyMs: number;
     error?: string;
+    responseSource?: "tool_call" | "content_fallback" | "content";
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
+    /** Scheduler admission categories, never free-form provider error text. */
+    admissionReasons?: Array<"request_budget" | "token_budget" | "concurrency" | "shared_key_cooldown" | "model_cooldown">;
 }
 export interface DecideRouteMeta {
     policyVersion: string;
@@ -26,14 +44,14 @@ export interface DecideRouteMeta {
 export type DecideResult = {
     ok: true;
     text: string;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-    };
+    responseSource?: "tool_call" | "content_fallback" | "content";
+    usage?: ProviderUsage;
     route?: DecideRouteMeta;
 } | {
     ok: false;
     error: string;
+    failureClass?: "malformed";
+    usage?: ProviderUsage;
     status?: number;
     retryAfterMs?: number;
     retryableHttpFailure?: true;
@@ -55,10 +73,13 @@ export interface ProviderEnv {
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export declare function classifyProviderFailure(result: Extract<DecideResult, {
     ok: false;
-}>): "capacity" | "permanent" | "transient";
-export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
+}>): "capacity" | "permanent" | "transient" | "malformed";
+export interface ProviderRouteOptions {
+    nemotronJsonContent?: boolean | (() => boolean);
+}
+export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;
 export declare function providerForRoute(route: {
     provider: ProviderName;
     model: string;
     baseUrl?: string | null;
-}, apiKey: string, fetchFn?: typeof fetch): Provider;
+}, apiKey: string, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;

package/dist/agent/providers.js

@@ -3,7 +3,64 @@
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
 import { retryAfterSeconds } from "../retryAfter.js";
-import { chatShapeFor, buildChatBody, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+import { parseDecision } from "./decision.js";
+import { chatShapeFor, buildChatBody, withJsonContentTransport, canRetrySuperToolOutput, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+// A token count as Anthropic reports it: a non-negative safe integer. Zero
+// is a real count; anything else (missing, null, negative, NaN, fractional,
+// a string) is malformed.
+function exactCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+// Anthropic usage, including prompt-cache reads and writes (and the 5m/1h
+// write split) when reported. Strict, because paid metering prices it (root
+// review of #118): input_tokens and output_tokens are mandatory, and a
+// malformed reported field (mandatory or cache) makes the WHOLE usage unknown
+// (undefined), never zero, so the call is metered uncertain instead of free.
+// Cache fields the response does not carry at all stay absent. A reported
+// write total must equal its 5m/1h split; a split without a total implies it.
+export function anthropicUsage(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return undefined;
+    const u = raw;
+    const promptTokens = exactCount(u.input_tokens);
+    const completionTokens = exactCount(u.output_tokens);
+    if (promptTokens === undefined || completionTokens === undefined)
+        return undefined;
+    const usage = { promptTokens, completionTokens };
+    const optional = (value) => value === undefined ? undefined : (exactCount(value) ?? null);
+    const cacheRead = optional(u.cache_read_input_tokens);
+    const cacheWrite = optional(u.cache_creation_input_tokens);
+    let write5m;
+    let write1h;
+    if (u.cache_creation !== undefined) {
+        const split = u.cache_creation;
+        if (typeof split !== "object" || split === null || Array.isArray(split))
+            return undefined;
+        const s = split;
+        write5m = optional(s.ephemeral_5m_input_tokens);
+        write1h = optional(s.ephemeral_1h_input_tokens);
+    }
+    if ([cacheRead, cacheWrite, write5m, write1h].includes(null))
+        return undefined;
+    if (write5m != null || write1h != null) {
+        const splitTotal = (write5m ?? 0) + (write1h ?? 0);
+        if (cacheWrite != null && cacheWrite !== splitTotal)
+            return undefined;
+        usage.cacheWriteTokens = splitTotal;
+        if (write5m != null)
+            usage.cacheWrite5mTokens = write5m;
+        if (write1h != null)
+            usage.cacheWrite1hTokens = write1h;
+    }
+    else if (cacheWrite != null) {
+        usage.cacheWriteTokens = cacheWrite;
+    }
+    if (cacheRead != null)
+        usage.cacheReadTokens = cacheRead;
+    return usage;
+}
 // NVIDIA NIM is OpenAI-compatible; the `nvidia` preset hard-wires the hosted
 // endpoint so an agent only needs `{ provider: nvidia, name: "<model id>" }`.
 const NVIDIA_BASE_URL = CAP_NVIDIA_BASE_URL;
@@ -31,6 +88,8 @@ const DEFAULT_TIMEOUT_MS = 300_000;
 const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export function classifyProviderFailure(result) {
+    if (result.failureClass === "malformed")
+        return "malformed";
     if (result.status === 429 ||
         (result.status === 503 &&
             /resourceexhausted|worker local total request limit/i.test(result.error ?? "")))
@@ -186,15 +245,27 @@ class AnthropicProvider {
                 }
                 const json = (await res.json());
                 const text = json.content?.map((c) => c.text ?? "").join("") ?? "";
-                const usage = json.usage
-                    ? {
-                        promptTokens: json.usage.input_tokens ?? 0,
-                        completionTokens: json.usage.output_tokens ?? 0,
-                    }
-                    : undefined;
+                // Absent or malformed usage is undefined (unknown), never zero.
+                const usage = anthropicUsage(json.usage);
+                if (json.stop_reason === "max_tokens" ||
+                    json.stop_reason === "model_context_window_exceeded") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: json.stop_reason === "max_tokens"
+                            ? "provider returned incomplete decision (output token limit)"
+                            : "provider returned incomplete decision (context window limit)",
+                        usage,
+                    };
+                }
                 return text
-                    ? { ok: true, text, usage }
-                    : { ok: false, error: "anthropic returned empty content" };
+                    ? { ok: true, text, usage, responseSource: "content" }
+                    : // Answered (and billed) with nothing usable: keep the usage.
+                        {
+                            ok: false,
+                            error: "anthropic returned empty content",
+                            ...(usage ? { usage } : {}),
+                        };
             });
         }
         catch (err) {
@@ -213,24 +284,40 @@ class AnthropicProvider {
         }
     }
 }
+function wantsJsonContent(options) {
+    const v = options.nemotronJsonContent;
+    if (typeof v !== "function")
+        return v === true;
+    try {
+        return v() === true;
+    }
+    catch {
+        return false;
+    }
+}
 class OpenAiCompatProvider {
     provider;
     model;
     apiKey;
     baseUrl;
     fetchFn;
+    options;
     label;
-    constructor(provider, model, apiKey, baseUrl, fetchFn) {
+    constructor(provider, model, apiKey, baseUrl, fetchFn, options = {}) {
         this.provider = provider;
         this.model = model;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.fetchFn = fetchFn;
+        this.options = options;
         this.label = `${baseUrl}/${model}`;
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const baseShape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const shape = wantsJsonContent(this.options)
+            ? withJsonContentTransport(baseShape)
+            : baseShape;
         let failureResponse;
         try {
             return await withProviderTimeout(timeoutMs, async (signal) => {
@@ -246,6 +333,7 @@ class OpenAiCompatProvider {
                         system: input.system,
                         user: input.user,
                         maxTokens: input.maxTokens ?? 1024,
+                        excludeActionTypes: input.excludeActionTypes,
                     })),
                 });
                 if (!res.ok) {
@@ -272,8 +360,25 @@ class OpenAiCompatProvider {
                         completionTokens: json.usage.completion_tokens ?? 0,
                     }
                     : undefined;
+                if (json.choices?.[0]?.finish_reason === "length") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: "provider returned incomplete decision (output token limit)",
+                        usage,
+                    };
+                }
                 return text
-                    ? { ok: true, text, usage }
+                    ? {
+                        ok: true,
+                        text,
+                        usage,
+                        responseSource: decisionArguments != null
+                            ? "tool_call"
+                            : shape.jsonSchemaTransport === "tool_call"
+                                ? "content_fallback"
+                                : "content",
+                    }
                     : { ok: false, error: "provider returned empty content" };
             });
         }
@@ -293,20 +398,24 @@ class OpenAiCompatProvider {
         }
     }
 }
-// A direct NVIDIA 5xx previously lost the whole cycle until the next cadence.
-// Retry only an explicit server refusal, once, on the identical configured
-// route. The shared router owns its own attempt/capacity budget and MUST NOT
-// receive this wrapper. No auth/404/429, network, timeout or decision repair
-// retries; no model substitution or request-parameter changes.
+// Direct NVIDIA recovery has one shared two-call/deadline budget. Explicit
+// server refusals retry the original request; rejected Super tool encoding
+// retries JSON content on the same configured route. The shared router owns
+// its own admission budget and MUST NOT receive this wrapper. No model
+// substitution or repair/coercion of a rejected decision is allowed.
 class SameModelRetryProvider {
     delegate;
     provider;
     model;
+    contentRetry;
+    baseUrl;
     label;
-    constructor(delegate, provider, model) {
+    constructor(delegate, provider, model, contentRetry, baseUrl) {
         this.delegate = delegate;
         this.provider = provider;
         this.model = model;
+        this.contentRetry = contentRetry;
+        this.baseUrl = baseUrl;
         this.label = delegate.label;
     }
     async decide(input) {
@@ -314,56 +423,95 @@ class SameModelRetryProvider {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const first = await this.delegate.decide(input);
         const firstFinished = Date.now();
-        if (first.ok || !first.retryableHttpFailure) {
+        const parsedFirst = first.ok ? parseDecision(first.text) : undefined;
+        const retryContent = first.ok &&
+            parsedFirst?.ok === false &&
+            this.contentRetry !== undefined &&
+            canRetrySuperToolOutput({ provider: this.provider, model: this.model, baseUrl: this.baseUrl }, first.responseSource, parsedFirst.actionsStringDiagnostic);
+        if (!retryContent && (first.ok || !first.retryableHttpFailure)) {
             return first;
         }
-        const delayMs = Math.max(1000, first.retryAfterMs ?? 0);
+        const delayMs = retryContent
+            ? 0
+            : Math.max(1000, first.ok ? 0 : (first.retryAfterMs ?? 0));
         // Honor the provider's cooldown; a long one waits for the next cycle. Both
         // attempts and this backoff share the ORIGINAL deadline, never two 5m caps.
         if (delayMs > 5000 || delayMs >= timeoutMs - (firstFinished - started)) {
             return first;
         }
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        if (delayMs > 0)
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
         const retryStarted = Date.now();
         const remainingMs = timeoutMs - (retryStarted - started);
         if (remainingMs <= 0)
             return first;
-        const result = await this.delegate.decide({
+        const retryResult = await (retryContent ? this.contentRetry : this.delegate).decide({
             ...input,
             timeoutMs: remainingMs,
         });
-        const attempt = (res, latencyMs) => ({
-            provider: this.provider,
-            model: this.model,
-            outcome: res.ok ? "success" : "failed",
-            latencyMs,
-            ...(!res.ok
-                ? {
-                    error: res.error,
-                    status: res.status,
-                    retryAfterMs: res.retryAfterMs,
-                    failureClass: classifyProviderFailure(res) === "capacity"
-                        ? "capacity"
-                        : res.status !== undefined && res.status < 500
-                            ? "permanent"
-                            : "transient",
-                }
-                : {}),
-        });
+        const parsedRetry = retryResult.ok
+            ? parseDecision(retryResult.text)
+            : undefined;
+        const result = retryResult.ok && parsedRetry?.ok === false
+            ? {
+                ok: false,
+                failureClass: "malformed",
+                error: parsedRetry.error,
+                usage: retryResult.usage,
+            }
+            : retryResult;
+        const attempt = (res, latencyMs) => {
+            const parsed = res.ok ? parseDecision(res.text) : undefined;
+            return {
+                provider: this.provider,
+                model: this.model,
+                outcome: res.ok && parsed?.ok ? "success" : "failed",
+                latencyMs,
+                ...(res.ok ? { responseSource: res.responseSource } : {}),
+                ...(parsed?.ok === false
+                    ? {
+                        failureClass: "malformed",
+                        error: parsed.error,
+                        actionsStringDiagnostic: parsed.actionsStringDiagnostic,
+                    }
+                    : {}),
+                ...(!res.ok
+                    ? {
+                        error: res.error,
+                        status: res.status,
+                        retryAfterMs: res.retryAfterMs,
+                        failureClass: res.failureClass ??
+                            (classifyProviderFailure(res) === "capacity"
+                                ? "capacity"
+                                : res.status !== undefined && res.status < 500
+                                    ? "permanent"
+                                    : "transient"),
+                    }
+                    : {}),
+            };
+        };
+        // Sum reported usage from both physical calls, including rejected output.
+        // Missing usage is unknown, not evidence that a request consumed no tokens.
+        const usage = first.usage || result.usage
+            ? {
+                promptTokens: (first.usage?.promptTokens ?? 0) +
+                    (result.usage?.promptTokens ?? 0),
+                completionTokens: (first.usage?.completionTokens ?? 0) +
+                    (result.usage?.completionTokens ?? 0),
+            }
+            : undefined;
         return {
-            // Usage, when present, describes only the final response. The preceding
-            // 5xx did not report usage; attempt evidence is not total billed tokens
-            // or a certificate that returned text passed the trading-decision parser.
             ...result,
+            ...(usage ? { usage } : {}),
             route: {
-                policyVersion: "coinrithm.configured-same-model-retry.v2",
+                policyVersion: "coinrithm.configured-same-model-retry.v3",
                 profile: "configured",
                 effectiveProvider: this.provider,
                 effectiveModel: this.model,
                 reason: "configured_direct",
                 attempts: [
                     attempt(first, firstFinished - started),
-                    attempt(result, Date.now() - retryStarted),
+                    attempt(retryResult, Date.now() - retryStarted),
                 ],
             },
         };
@@ -372,7 +520,7 @@ class SameModelRetryProvider {
 // Build the provider from the spec's model block + env key. Throws a clear
 // error if no model is configured (self-host requires one) or the env key is
 // missing. fetch is injectable for tests.
-export function selectProvider(spec, env, fetchFn = fetch) {
+export function selectProvider(spec, env, fetchFn = fetch, options = {}) {
     if (!spec.model) {
         throw new Error("no model configured: set model.provider + model.name in the agent (self-host needs an explicit model)");
     }
@@ -401,15 +549,17 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, options);
     return provider === "nvidia"
-        ? new SameModelRetryProvider(direct, provider, name)
+        ? new SameModelRetryProvider(direct, provider, name, new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, {
+            nemotronJsonContent: true,
+        }), baseUrl)
         : direct;
 }
 // Build a provider for an EXPLICIT route + raw key (no spec, no env) — the
 // decision probe's entry point. Same classes as selectProvider, so a probe
 // exercises byte-identical request shapes to a real cycle.
-export function providerForRoute(route, apiKey, fetchFn = fetch) {
+export function providerForRoute(route, apiKey, fetchFn = fetch, options = {}) {
     if (route.provider === "mechanical")
         return new MechanicalProvider(route.model);
     if (route.provider === "anthropic")
@@ -418,5 +568,5 @@ export function providerForRoute(route, apiKey, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible route needs a baseUrl");
     }
-    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn);
+    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn, options);
 }

package/dist/agent/resolve.js

@@ -43,6 +43,9 @@ const CONFIG_BLOCKS = [
     "killSwitch",
     "objective",
     "capabilities",
+    "signals",
+    "data",
+    "universe",
 ];
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;

package/dist/agent/runner.d.ts

@@ -1,6 +1,7 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
 import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
+import { type ObserveOptions } from "./observe.js";
 import { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
@@ -13,6 +14,13 @@ export interface RunnerDeps {
     log?: (line: string) => void;
     /** Optional private storage hook. Its failure never changes cycle execution. */
     onDecisionInputRecord?: (record: DecisionInputRecord) => void;
+    /** Hosted shared-pool admission only; protective checks still run every cycle. */
+    minModelIntervalSeconds?: number;
+    /** Opt-in hosted canary; changes presentation only, preserving all values. */
+    compactPromptTables?: boolean;
+    /** Bench replay only (bench.ts): observation overrides. Live runs never
+     *  set it. */
+    observeOptions?: ObserveOptions;
 }
 export declare function houseAgentForecastEnabled(): boolean;
 export declare function agentOpportunityCaptureEnabled(): boolean;