mixdog 0.9.151 → 0.9.152

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -64,6 +64,7 @@ import {
     writeXaiResponsesCacheTrace,
 } from './openai-compat-xai.mjs';
 import { envFlag as _envFlag } from './lib/env-utils.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 
 const requireOpenAI = createRequire(import.meta.url);
 let _OpenAI = null;
@@ -168,10 +169,33 @@ function normalizeReasoningEffort(value, allowed) {
     return allowed.includes(effort) ? effort : null;
 }
 
+export function compatReportedCostUsd(providerName, usage) {
+    if (providerName === 'openrouter') {
+        const cost = Number(usage?.cost);
+        return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+    }
+    if (providerName === 'xai') {
+        const ticks = Number(usage?.cost_in_usd_ticks);
+        return Number.isFinite(ticks) && ticks >= 0
+            ? Number((ticks * 1e-10).toFixed(8))
+            : undefined;
+    }
+    return undefined;
+}
+
 // Keep provider extensions isolated: fields accepted by one OpenAI-compatible
 // backend are frequently rejected by another even when the core Chat schema is
 // shared.
 export function applyCompatProviderChatOptions(params, providerName, opts = {}, config = {}, modelInfo = null) {
+    if (providerName === 'openrouter') {
+        const effort = normalizeReasoningEffort(
+            opts.openRouterReasoningEffort ?? opts.effort ?? config?.reasoningEffort,
+            ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
+        );
+        if (effort === 'none') params.reasoning = { enabled: false };
+        else if (effort) params.reasoning = { enabled: true, effort };
+        return params;
+    }
     if (providerName === 'xai') {
         const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
             ?? opts.effort
@@ -594,6 +618,9 @@ export class OpenAICompatProvider {
         const reasoningContent = (capturesReasoningContent && typeof assembled.reasoningContent === 'string')
             ? assembled.reasoningContent
             : null;
+        const reasoningDetails = this.name === 'openrouter' && Array.isArray(choice?.message?.reasoning_details)
+            ? choice.message.reasoning_details
+            : null;
         return {
             content: assembled.content || '',
             // Streamed chunks can omit `model`; fall back to the requested
@@ -609,6 +636,9 @@ export class OpenAICompatProvider {
             // instead of silently treating a truncated answer as complete.
             ...(stopReason === 'length' && (assembled.content || '').length > 0 ? { truncated: true } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
+            ...(reasoningDetails?.length ? {
+                providerMetadata: { openrouter: { reasoning_details: reasoningDetails } },
+            } : {}),
             usage: response.usage ? (() => {
                 const input = response.usage.prompt_tokens ?? response.usage.input_tokens ?? 0;
                 const cached = extractCompatCachedTokens(response.usage);
@@ -616,10 +646,7 @@ export class OpenAICompatProvider {
                 // (1 tick = $1e-10, per docs.x.ai). Surface it as costUsd so the
                 // session manager skips the catalog-rate fallback and records the
                 // provider-billed value verbatim.
-                const ticks = response.usage.cost_in_usd_ticks;
-                const costUsd = typeof ticks === 'number' && ticks >= 0
-                    ? Number((ticks * 1e-10).toFixed(8))
-                    : undefined;
+                const costUsd = compatReportedCostUsd(this.name, response.usage);
                 return {
                     inputTokens: input,
                     outputTokens: response.usage.completion_tokens ?? response.usage.output_tokens ?? 0,
@@ -884,6 +911,7 @@ export class OpenAICompatProvider {
         // any rejection as a provider-side drop.)
         const nextPreviousResponseId = response.id;
         const encryptedReasoningItems = encryptedXaiReasoningItems(response.output);
+        const providerReplay = createProviderReplay('xai-responses', response.output);
         const encryptedReasoningHistory = [
             ...(Array.isArray(opts.providerState?.xaiResponses?.encryptedReasoningHistory)
                 ? opts.providerState.xaiResponses.encryptedReasoningHistory
@@ -904,6 +932,7 @@ export class OpenAICompatProvider {
             ...(streamed.stopReason === 'length' && (streamed.content || '').length > 0 ? { truncated: true } : {}),
             citations: searchSources.citations.length ? searchSources.citations : undefined,
             webSearchCalls: searchSources.webSearchCalls.length ? searchSources.webSearchCalls : undefined,
+            providerReplay,
             providerState: {
                 ...(opts.providerState || {}),
                 xaiResponses: {
@@ -1022,6 +1051,7 @@ export class OpenAICompatProvider {
         // Same rationale as the HTTP path above: `length` stop keeps the chain.
         const nextPreviousResponseId = responseId;
         const encryptedReasoningItems = encryptedXaiReasoningItems(result.responseItems);
+        const providerReplay = createProviderReplay('xai-responses', result.responseItems);
         const encryptedReasoningHistory = [
             ...(Array.isArray(opts.providerState?.xaiResponses?.encryptedReasoningHistory)
                 ? opts.providerState.xaiResponses.encryptedReasoningHistory
@@ -1080,6 +1110,7 @@ export class OpenAICompatProvider {
             // P1 audit fix: same truncated signal as the HTTP path (see
             // _doSendXaiResponses above) for the WebSocket transport.
             ...(result.stopReason === 'length' && (result.content || '').length > 0 ? { truncated: true } : {}),
+            providerReplay,
             providerState: {
                 ...(opts.providerState || {}),
                 xaiResponses: {

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -38,6 +38,7 @@ import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './ant
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL, _displayCodexModel } from './openai-oauth.mjs';
 import { createActiveToolItemTracker } from './tool-stream-state.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 import { envFlag as _envFlag } from './lib/env-utils.mjs';
 export { envPositiveInt as _envPositiveInt } from './lib/env-utils.mjs';
@@ -504,6 +505,8 @@ export async function sendViaHttpSse({
     const clearActiveToolItem = _toolTracker.clear;
     let _toolInFlight = false;
     const reasoningItems = [];
+    const responseItems = [];
+    const responseItemKeys = new Set();
     const citations = [];
     const citationKeys = new Set();
     const webSearchCalls = [];
@@ -663,6 +666,16 @@ export async function sendViaHttpSse({
             });
         }
     };
+    const pushResponseItem = (item) => {
+        if (!item || typeof item !== 'object') return;
+        let fallbackKey = '';
+        try { fallbackKey = JSON.stringify(item); } catch {}
+        const key = `${item.type || 'unknown'}:${item.id || item.call_id || fallbackKey}`;
+        if (responseItemKeys.has(key)) return;
+        responseItemKeys.add(key);
+        try { responseItems.push(structuredClone(item)); }
+        catch { responseItems.push({ ...item }); }
+    };
     const pushToolSearchCall = (item) => {
         if (!item || item.type !== 'tool_search_call') return;
         const callId = item.call_id || item.id || '';
@@ -800,6 +813,7 @@ export async function sendViaHttpSse({
                 break;
             case 'response.output_item.done': {
                 const item = event.item || {};
+                pushResponseItem(item);
                 pushReasoningItem(item);
                 pushWebSearchCall(item);
                 if (item.type === 'function_call') {
@@ -852,6 +866,7 @@ export async function sendViaHttpSse({
                 }
                 let reportedBundleProgress = false;
                 for (const item of resp.output || []) {
+                    pushResponseItem(item);
                     if (item.type === 'message') {
                         for (const part of item.content || []) {
                             if (!content && part.type === 'output_text') {
@@ -1060,6 +1075,11 @@ export async function sendViaHttpSse({
         // trailing text is never lost (streamed-text path).
         flushLeak();
     } catch (err) {
+        if (err && !err.partialProviderReplay) {
+            try {
+                err.partialProviderReplay = createProviderReplay('openai-responses', responseItems);
+            } catch {}
+        }
         // Live-text invariant: once a non-empty chunk has been relayed it
         // cannot be withdrawn — flag the error so no upstream layer retries.
         if (emittedText && err) { try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {} }
@@ -1100,6 +1120,7 @@ export async function sendViaHttpSse({
         try {
             err.partialContent = content;
             err.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
+            err.partialProviderReplay = createProviderReplay('openai-responses', responseItems);
             err.partialModel = model || undefined;
             err.pendingToolUse = pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true;
         } catch { /* best-effort enrichment */ }
@@ -1141,6 +1162,7 @@ export async function sendViaHttpSse({
         content,
         model: liveModel,
         reasoningItems: reasoningItems.length ? reasoningItems : undefined,
+        providerReplay: createProviderReplay('openai-responses', responseItems),
         toolCalls: _returnedToolCalls,
         citations: citations.length ? citations : undefined,
         webSearchCalls: webSearchCalls.length ? webSearchCalls : undefined,

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -50,7 +50,6 @@ import {
     acquireWebSocket,
     releaseWebSocket,
     _sendFrame,
-    _closeAllPooledSockets,
     drainOpenaiWsPool,
 } from './openai-ws-pool.mjs';
 import {
@@ -74,7 +73,6 @@ import { envPositiveInt } from './lib/env-utils.mjs';
 // (drainOpenaiWsPool), scripts/provider-toolcall-test.mjs (parseToolSearchArgs,
 // _logicalResponseItemMatch, _streamResponse) and other external callers.
 export {
-    _closeAllPooledSockets,
     drainOpenaiWsPool,
     _logicalResponseItemMatch,
     parseToolSearchArgs,

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -17,6 +17,7 @@ import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { makeModelCache } from './model-cache.mjs';
+import { providerReplayItems } from './lib/provider-replay.mjs';
 
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import { _combineUsageWithWarmup } from './openai-ws-events.mjs';
@@ -175,6 +176,18 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
             continue;
         }
         flushToolMedia();
+        const orderedReplay = replayEncryptedReasoning && m.role === 'assistant'
+            ? providerReplayItems(m, 'openai-responses')
+            : undefined;
+        if (orderedReplay?.length) {
+            for (const item of orderedReplay) {
+                if (item?.type === 'custom_tool_call' && item.call_id) {
+                    customToolCallNameById.set(item.call_id, item.name || '');
+                }
+                out.push(item);
+            }
+            continue;
+        }
         pushReasoningItems(m, 'before');
         if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
             // Default path deliberately omits reasoning replay: openai-oauth

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -184,7 +184,7 @@ function _getPoolArr(poolKey) {
 // cap-overflow ephemeral. They were invisible to per-session close and to the
 // global drain, so a wedged one survived both. Tracking them here keeps the
 // reuse map unchanged (nothing can select them) while making every owned socket
-// reachable by closeOpenaiWsPoolForSession/_closeAllPooledSockets.
+// reachable by closeOpenaiWsPoolForSession/drainOpenaiWsPool.
 const _unpooledSockets = new Set();
 
 function _trackUnpooled(entry, poolKey) {
@@ -883,16 +883,14 @@ export function _setOpenSocketForTest(fn) {
     _openSocketImpl = typeof fn === 'function' ? fn : _openSocket;
 }
 
-// Drain-complete fence — set true once _closeAllPooledSockets runs so any
+// Drain-complete fence — set true once drainOpenaiWsPool runs so any
 // in-flight acquire that resumes after drain throws instead of pushing a
 // fresh socket into the cleared pool. Single-set, process-lifetime invariant.
 let _drainComplete = false;
 
 // Drain hook — self-registered exit drain.
 // Force-closes pooled sockets and fences subsequent acquires.
-// `drainOpenaiWsPool` alias matches the registry's `drain*` naming convention;
-// `_closeAllPooledSockets` kept for backward compat with existing call sites.
-export function _closeAllPooledSockets(reason = 'shutdown', { immediate = false } = {}) {
+export function drainOpenaiWsPool(reason = 'shutdown', { immediate = false } = {}) {
     _drainComplete = true;
     for (const arr of _wsPool.values()) {
         // _shutdownEntry tears down per-entry timers before the map is dropped
@@ -909,7 +907,6 @@ export function _closeAllPooledSockets(reason = 'shutdown', { immediate = false
     _unpooledSockets.clear();
     _wsPool.clear();
 }
-export const drainOpenaiWsPool = _closeAllPooledSockets;
 // Session-close / drain hooks are shared across provider transports (cursor-wire
 // registers the same globals), so chain whatever is already installed instead of
 // replacing it — import order must not decide which transport gets torn down.
@@ -925,4 +922,4 @@ globalThis.__mixdogDrainProviderConnections = (reason) => {
 };
 // 'exit' hands the listener an exit CODE, never a reason string, and no timer
 // can fire after it: terminate immediately instead of scheduling.
-process.on('exit', () => _closeAllPooledSockets('process-exit', { immediate: true }));
+process.on('exit', () => drainOpenaiWsPool('process-exit', { immediate: true }));

package/src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs

@@ -33,6 +33,7 @@ import {
     streamStalledError,
 } from '../stall-policy.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import { _wsErrLabel, WS_MAX_INCOMING_FRAME_BYTES } from './openai-ws-pool.mjs';
 import {
     _sansInput,
@@ -675,6 +676,10 @@ export async function _streamResponse({
             try {
                 err.partialContent = content;
                 err.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
+                err.partialProviderReplay = createProviderReplay(
+                    traceProvider === 'xai' ? 'xai-responses' : 'openai-responses',
+                    responseItemsAdded,
+                );
                 err.pendingToolUse = pendingCalls.size > 0
                     || activeToolItems.size > 0
                     || _toolInFlight === true;
@@ -794,6 +799,10 @@ export async function _streamResponse({
                 model,
                 reasoningItems: reasoningItems.length ? reasoningItems : undefined,
                 responseItems: responseItemsAdded.length ? responseItemsAdded : undefined,
+                providerReplay: createProviderReplay(
+                    traceProvider === 'xai' ? 'xai-responses' : 'openai-responses',
+                    responseItemsAdded,
+                ),
                 // Dedupe by name+args (Fix 2, array side) so an identical
                 // synthetic-leaked + native pair can't run the tool twice.
                 toolCalls: toolCalls.length ? dedupeToolCallList(toolCalls) : undefined,

package/src/runtime/agent/orchestrator/providers/provider-replay.test.mjs

@@ -0,0 +1,235 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import {
+    createProviderReplay,
+    providerReplayItems,
+} from './lib/provider-replay.mjs';
+import { toAnthropicMessages } from './lib/anthropic-request-utils.mjs';
+import { parseSSEStream as parseAnthropicSSEStream } from './anthropic-sse.mjs';
+import { toGeminiContents } from './gemini-schema.mjs';
+import { convertMessagesToResponsesInput } from './openai-responses-payload.mjs';
+import { toOpenAIMessages, toXaiResponsesInput } from './openai-compat-wire.mjs';
+import { estimateMessagesTokens } from '../session/context-utils.mjs';
+import { _sessionForDisk } from '../session/store/serialize.mjs';
+
+function interleavedAnthropicBlocks() {
+    const blocks = [{ type: 'thinking', thinking: '', signature: 'sig-a' }];
+    for (let index = 1; index <= 10; index += 1) {
+        blocks.push({
+            type: 'tool_use',
+            id: `toolu_${index}`,
+            name: 'read',
+            input: { index },
+        });
+    }
+    blocks.push({ type: 'thinking', thinking: '', signature: 'sig-b' });
+    blocks.push({
+        type: 'tool_use',
+        id: 'toolu_11',
+        name: 'read',
+        input: { index: 11 },
+    });
+    return blocks;
+}
+
+function interleavedResponsesItems() {
+    const items = [{
+        type: 'reasoning',
+        id: 'rs_1',
+        encrypted_content: 'cipher-a',
+        summary: [],
+    }];
+    for (let index = 1; index <= 10; index += 1) {
+        items.push({
+            type: 'function_call',
+            call_id: `call_${index}`,
+            name: 'read',
+            arguments: JSON.stringify({ index }),
+        });
+    }
+    items.push({
+        type: 'reasoning',
+        id: 'rs_2',
+        encrypted_content: 'cipher-b',
+        summary: [],
+    });
+    items.push({
+        type: 'function_call',
+        call_id: 'call_11',
+        name: 'read',
+        arguments: '{"index":11}',
+    });
+    return items;
+}
+
+function anthropicSseResponse(events) {
+    const body = events
+        .map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
+        .join('');
+    return new Response(body, { headers: { 'content-type': 'text/event-stream' } });
+}
+
+test('provider replay is detached and scoped to its originating provider', () => {
+    const source = [{ type: 'thinking', thinking: 'plan', signature: 'sig' }];
+    const replay = createProviderReplay('anthropic', source);
+    source[0].signature = 'mutated';
+
+    assert.equal(replay.items[0].signature, 'sig');
+    assert.deepEqual(providerReplayItems({ providerReplay: replay }, 'anthropic'), replay.items);
+    assert.equal(providerReplayItems({ providerReplay: replay }, 'gemini'), undefined);
+});
+
+test('Anthropic keeps interleaved thinking at content[11]', () => {
+    const blocks = interleavedAnthropicBlocks();
+    const message = {
+        role: 'assistant',
+        content: '',
+        toolCalls: blocks
+            .filter((block) => block.type === 'tool_use')
+            .map((block) => ({
+                id: block.id,
+                name: block.name,
+                arguments: block.input,
+            })),
+        providerReplay: createProviderReplay('anthropic', blocks),
+    };
+    const lowered = toAnthropicMessages([message]);
+
+    assert.deepEqual(lowered[0].content, blocks);
+    assert.equal(lowered[0].content[11].type, 'thinking');
+    assert.equal(lowered[0].content[11].signature, 'sig-b');
+});
+
+test('Anthropic SSE parse to next-request replay keeps content[11] unchanged', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude-test', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'sig-a' } },
+        { type: 'content_block_stop', index: 0 },
+    ];
+    for (let index = 1; index <= 10; index += 1) {
+        events.push(
+            {
+                type: 'content_block_start',
+                index,
+                content_block: { type: 'tool_use', id: `toolu_${index}`, name: 'read' },
+            },
+            {
+                type: 'content_block_delta',
+                index,
+                delta: { type: 'input_json_delta', partial_json: JSON.stringify({ index }) },
+            },
+            { type: 'content_block_stop', index },
+        );
+    }
+    events.push(
+        { type: 'content_block_start', index: 11, content_block: { type: 'thinking', thinking: '' } },
+        { type: 'content_block_delta', index: 11, delta: { type: 'signature_delta', signature: 'sig-b' } },
+        { type: 'content_block_stop', index: 11 },
+        {
+            type: 'content_block_start',
+            index: 12,
+            content_block: { type: 'tool_use', id: 'toolu_11', name: 'read' },
+        },
+        {
+            type: 'content_block_delta',
+            index: 12,
+            delta: { type: 'input_json_delta', partial_json: '{"index":11}' },
+        },
+        { type: 'content_block_stop', index: 12 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    );
+    const parsed = await parseAnthropicSSEStream(
+        anthropicSseResponse(events),
+        null,
+        () => {},
+        () => {},
+        () => {},
+        {},
+        null,
+        new Set(['read']),
+    );
+    const lowered = toAnthropicMessages([{
+        role: 'assistant',
+        content: parsed.content || '',
+        toolCalls: parsed.toolCalls,
+        providerReplay: parsed.providerReplay,
+    }]);
+
+    assert.equal(parsed.providerReplay.items[11].type, 'thinking');
+    assert.deepEqual(lowered[0].content, parsed.providerReplay.items);
+});
+
+test('Gemini keeps signed thought Parts interleaved with function calls', () => {
+    const parts = [{ text: 'plan-a', thought: true, thoughtSignature: 'sig-a' }];
+    for (let index = 1; index <= 10; index += 1) {
+        parts.push({ functionCall: { id: `call_${index}`, name: 'read', args: { index } } });
+    }
+    parts.push({ text: 'plan-b', thought: true, thoughtSignature: 'sig-b' });
+    parts.push({ functionCall: { id: 'call_11', name: 'read', args: { index: 11 } } });
+    const contents = toGeminiContents([{
+        role: 'assistant',
+        content: '',
+        toolCalls: [],
+        providerReplay: createProviderReplay('gemini', parts),
+    }], 'gemini-3-pro');
+
+    assert.deepEqual(contents[0].parts, parts);
+    assert.equal(contents[0].parts[11].thoughtSignature, 'sig-b');
+});
+
+test('OpenAI Responses recovery keeps reasoning between function calls', () => {
+    const items = interleavedResponsesItems();
+    const input = convertMessagesToResponsesInput([{
+        role: 'assistant',
+        content: '',
+        toolCalls: [],
+        providerReplay: createProviderReplay('openai-responses', items),
+    }], { replayEncryptedReasoning: true });
+
+    assert.deepEqual(input, items);
+    assert.equal(input[11].type, 'reasoning');
+    assert.equal(input[11].id, 'rs_2');
+});
+
+test('xAI stateless recovery keeps encrypted reasoning output order', () => {
+    const items = interleavedResponsesItems();
+    const result = toXaiResponsesInput([{
+        role: 'assistant',
+        content: '',
+        toolCalls: [],
+        providerReplay: createProviderReplay('xai-responses', items),
+    }], null);
+
+    assert.deepEqual(result.input, items);
+    assert.equal(result.input[11].type, 'reasoning');
+});
+
+test('OpenRouter reasoning_details remains an unmodified assistant field', () => {
+    const reasoningDetails = [
+        { type: 'reasoning.text', text: 'plan', signature: 'opaque' },
+        { type: 'reasoning.encrypted', data: 'ciphertext' },
+    ];
+    const wire = toOpenAIMessages([{
+        role: 'assistant',
+        content: '',
+        toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }],
+        providerMetadata: { openrouter: { reasoning_details: reasoningDetails } },
+    }], 'openrouter');
+
+    assert.equal(wire[0].reasoning_details, reasoningDetails);
+});
+
+test('provider replay survives disk projection and contributes to context size', () => {
+    const providerReplay = createProviderReplay('openai-responses', interleavedResponsesItems());
+    const message = { role: 'assistant', content: '', providerReplay };
+    const stored = _sessionForDisk({ id: 's', messages: [message] });
+
+    assert.deepEqual(stored.messages[0].providerReplay, providerReplay);
+    assert.ok(
+        estimateMessagesTokens([message])
+        > estimateMessagesTokens([{ role: 'assistant', content: '' }]),
+    );
+});