@jsonstudio/llms 0.6.473 → 0.6.568

package/dist/conversion/hub/tool-session-compat.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { extractSessionIdentifiersFromMetadata } from './pipeline/session-identifiers.js';
+const TOOL_HISTORY_ROOT = path.join(os.homedir(), '.routecodex', 'tool-history');
+const TOOL_UNKNOWN_PREFIX = '[RouteCodex] Tool call result unknown';
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function normalizeToolCallId(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const raw = call.id ??
+        call.tool_call_id ??
+        call.call_id;
+    if (typeof raw !== 'string') {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeToolMessageId(message) {
+    if (!message || typeof message !== 'object') {
+        return undefined;
+    }
+    const raw = message.tool_call_id ??
+        message.call_id ??
+        message.id;
+    if (typeof raw !== 'string') {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function findFirstNonToolIndex(messages, startIndex) {
+    let index = startIndex;
+    while (index < messages.length) {
+        const msg = messages[index];
+        if (!msg || typeof msg !== 'object') {
+            break;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function findToolMessageIndex(messages, startIndex, callId) {
+    for (let i = startIndex; i < messages.length; i += 1) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            continue;
+        }
+        const id = normalizeToolMessageId(msg);
+        if (id === callId) {
+            return i;
+        }
+    }
+    return -1;
+}
+function createUnknownToolMessage(callId, call) {
+    let name;
+    const fn = call && typeof call === 'object' ? call.function : undefined;
+    if (fn && typeof fn.name === 'string' && fn.name.trim().length) {
+        name = fn.name.trim();
+    }
+    const description = name ? `tool "${name}"` : 'tool call';
+    const content = `${TOOL_UNKNOWN_PREFIX}: ${description} (${callId}) did not produce a result in this session. Treat this tool as failed with unknown status.`;
+    const msg = {
+        role: 'tool',
+        tool_call_id: callId,
+        content
+    };
+    if (name) {
+        msg.name = name;
+    }
+    return msg;
+}
+function normalizeToolCallOrdering(messages) {
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (!message || typeof message !== 'object') {
+            index += 1;
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'assistant') {
+            index += 1;
+            continue;
+        }
+        const toolCalls = ensureArray(message.tool_calls);
+        if (!toolCalls.length) {
+            index += 1;
+            continue;
+        }
+        let insertionIndex = index + 1;
+        for (const call of toolCalls) {
+            if (!call || typeof call !== 'object') {
+                continue;
+            }
+            const callId = normalizeToolCallId(call);
+            if (!callId) {
+                continue;
+            }
+            const existingIndex = findToolMessageIndex(messages, insertionIndex, callId);
+            if (existingIndex >= 0) {
+                if (existingIndex === insertionIndex) {
+                    insertionIndex += 1;
+                    continue;
+                }
+                const [relocated] = messages.splice(existingIndex, 1);
+                messages.splice(insertionIndex, 0, relocated);
+                insertionIndex += 1;
+                continue;
+            }
+            const placeholder = createUnknownToolMessage(callId, call);
+            messages.splice(insertionIndex, 0, placeholder);
+            insertionIndex += 1;
+        }
+        index = Math.max(index + 1, insertionIndex);
+    }
+}
+function sanitizeSessionId(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return '';
+    }
+    return trimmed.replace(/[^A-Za-z0-9_.-]/g, '_');
+}
+async function loadSessionHistory(sessionId) {
+    try {
+        const file = path.join(TOOL_HISTORY_ROOT, `${sanitizeSessionId(sessionId)}.json`);
+        if (!fsSync.existsSync(file)) {
+            return null;
+        }
+        const text = await fs.readFile(file, 'utf-8');
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        parsed.lastMessages = Array.isArray(parsed.lastMessages) ? parsed.lastMessages : [];
+        parsed.pendingToolUses = parsed.pendingToolUses && typeof parsed.pendingToolUses === 'object'
+            ? parsed.pendingToolUses
+            : {};
+        parsed.updatedAt = typeof parsed.updatedAt === 'string' && parsed.updatedAt.trim().length
+            ? parsed.updatedAt
+            : new Date().toISOString();
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function persistSessionHistory(sessionId, history) {
+    try {
+        if (!fsSync.existsSync(TOOL_HISTORY_ROOT)) {
+            await fs.mkdir(TOOL_HISTORY_ROOT, { recursive: true });
+        }
+        const file = path.join(TOOL_HISTORY_ROOT, `${sanitizeSessionId(sessionId)}.json`);
+        const payload = JSON.stringify(history);
+        await fs.writeFile(file, payload, 'utf-8');
+    }
+    catch {
+        // history persistence must never block the main flow
+    }
+}
+function collectToolHistoryRecords(messages) {
+    const now = new Date().toISOString();
+    const records = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role === 'assistant') {
+            const toolCalls = ensureArray(msg.tool_calls);
+            for (const call of toolCalls) {
+                const id = normalizeToolCallId(call);
+                if (!id) {
+                    continue;
+                }
+                const fn = call.function;
+                const name = fn && typeof fn.name === 'string' && fn.name.trim().length
+                    ? fn.name.trim()
+                    : undefined;
+                records.push({
+                    role: 'assistant',
+                    tool_use: { id, name },
+                    ts: now
+                });
+            }
+            continue;
+        }
+        if (role === 'tool') {
+            const id = normalizeToolMessageId(msg);
+            if (!id) {
+                continue;
+            }
+            const rawName = msg.name;
+            const name = typeof rawName === 'string' && rawName.trim().length ? rawName.trim() : undefined;
+            const content = msg.content;
+            const status = typeof content === 'string' && content.startsWith(TOOL_UNKNOWN_PREFIX) ? 'unknown' : 'ok';
+            records.push({
+                role: 'tool',
+                tool_result: { id, name, status },
+                ts: now
+            });
+        }
+    }
+    return records;
+}
+function buildUpdatedHistory(existing, delta) {
+    const prevMessages = existing?.lastMessages ?? [];
+    const combined = [...prevMessages, ...delta];
+    const trimmed = combined.slice(-10);
+    const pending = {};
+    for (const entry of trimmed) {
+        if (entry.tool_use) {
+            pending[entry.tool_use.id] = {
+                name: entry.tool_use.name,
+                ts: entry.ts
+            };
+        }
+        if (entry.tool_result) {
+            delete pending[entry.tool_result.id];
+        }
+    }
+    return {
+        lastMessages: trimmed,
+        pendingToolUses: pending,
+        updatedAt: new Date().toISOString()
+    };
+}
+export async function applyToolSessionCompat(chat, ctx) {
+    if (!chat || !Array.isArray(chat.messages) || chat.messages.length === 0) {
+        return;
+    }
+    const entry = (ctx.entryEndpoint || '').toLowerCase();
+    if (!entry.includes('/v1/messages')) {
+        normalizeToolCallOrdering(chat.messages);
+        return;
+    }
+    normalizeToolCallOrdering(chat.messages);
+    const validCallIds = new Set();
+    for (const msg of chat.messages) {
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'assistant') {
+            continue;
+        }
+        const toolCalls = ensureArray(msg.tool_calls);
+        for (const call of toolCalls) {
+            const id = normalizeToolCallId(call);
+            if (id) {
+                validCallIds.add(id);
+            }
+        }
+    }
+    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
+        const filtered = chat.toolOutputs.filter((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                return false;
+            }
+            const rawId = entry.tool_call_id ??
+                entry.call_id ??
+                entry.id;
+            if (typeof rawId !== 'string') {
+                return false;
+            }
+            const trimmed = rawId.trim();
+            return trimmed.length > 0 && validCallIds.has(trimmed);
+        });
+        chat.toolOutputs = filtered.length ? filtered : undefined;
+    }
+    const metadata = (chat.metadata || {});
+    const identifiers = extractSessionIdentifiersFromMetadata(metadata);
+    const sessionId = identifiers.sessionId;
+    if (!sessionId) {
+        return;
+    }
+    const history = await loadSessionHistory(sessionId);
+    const records = collectToolHistoryRecords(chat.messages);
+    if (!records.length && !history) {
+        return;
+    }
+    const updated = buildUpdatedHistory(history, records);
+    await persistSessionHistory(sessionId, updated);
+}

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -53,6 +53,7 @@ export interface AdapterContext {
     originalModelId?: string;
     clientModelId?: string;
     toolCallIdStyle?: 'fc' | 'preserve';
+    responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }
 export interface ChatEnvelope {

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -48,7 +48,6 @@ export declare function buildResponsesRequestFromChat(payload: Record<string, un
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
 }): BuildResponsesRequestResult;
-export declare function ensureResponsesApplyPatchArguments(input?: BridgeInputItem[]): void;
 export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
 export declare function extractRequestIdFromResponse(response: any): string | undefined;
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';

package/dist/conversion/responses/responses-openai-bridge.js

@@ -21,7 +21,6 @@ function isObject(v) {
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
-    ensureResponsesApplyPatchArguments(preservedInput);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
@@ -398,76 +397,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
-export function ensureResponsesApplyPatchArguments(input) {
-    if (!Array.isArray(input) || !input.length) {
-        return;
-    }
-    for (const entry of input) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        const name = (typeof entry.name === 'string' && entry.name.trim()) ||
-            (entry.function && typeof entry.function === 'object' && typeof entry.function.name === 'string' && entry.function.name.trim()) ||
-            '';
-        if (name !== 'apply_patch')
-            continue;
-        let normalized;
-        try {
-            normalized = normalizeApplyPatchArguments(entry.arguments ?? entry.function?.arguments);
-        }
-        catch {
-            // best-effort: do not fail the whole request due to a malformed historical tool call
-            normalized = undefined;
-        }
-        if (normalized === undefined) {
-            continue;
-        }
-        entry.arguments = normalized;
-        if (entry.function && typeof entry.function === 'object') {
-            entry.function.arguments = normalized;
-        }
-    }
-}
-function normalizeApplyPatchArguments(source) {
-    let parsed;
-    if (typeof source === 'string' && source.trim()) {
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            parsed = { patch: source };
-        }
-    }
-    else if (source && typeof source === 'object') {
-        parsed = { ...source };
-    }
-    else if (source === undefined) {
-        parsed = {};
-    }
-    else {
-        return typeof source === 'string' ? source : undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return typeof source === 'string' ? source : undefined;
-    }
-    const patchText = typeof parsed.patch === 'string' && parsed.patch.trim().length
-        ? parsed.patch
-        : typeof parsed.input === 'string' && parsed.input.trim().length
-            ? parsed.input
-            : undefined;
-    if (patchText) {
-        parsed.patch = patchText;
-        parsed.input = patchText;
-    }
-    try {
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return typeof source === 'string' ? source : undefined;
-    }
-}
 function readToolCallIdStyleFromContext(ctx) {
     if (!ctx) {
         return undefined;

package/dist/conversion/shared/anthropic-message-utils.js

@@ -647,6 +647,56 @@ function createAnthropicToolNameResolver(source) {
         return lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase()) ?? trimmed;
     };
 }
+function normalizeAnthropicToolChoice(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isPlainRecord(value)) {
+        // Already an object – best-effort clone while trimming type, and also support
+        // Chat-style { type: 'function', function: { name } } by mapping to Anthropic's
+        // { type: 'tool', name } shape.
+        const cloned = cloneAnthropicSchema(value);
+        const rawType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        if (rawType) {
+            cloned.type = rawType;
+            return cloned;
+        }
+        const selectorType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        const fn = cloned.function;
+        if (selectorType === 'function' &&
+            fn &&
+            typeof fn === 'object' &&
+            typeof fn.name === 'string' &&
+            String(fn.name).trim().length) {
+            return { type: 'tool', name: String(fn.name).trim() };
+        }
+        return cloned;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return undefined;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'auto') {
+            return { type: 'auto' };
+        }
+        if (lower === 'none') {
+            return { type: 'none' };
+        }
+        if (lower === 'any') {
+            return { type: 'any' };
+        }
+        if (lower === 'required') {
+            // "required" in canonical Chat roughly maps to Anthropic's "any" semantics:
+            // the model must choose some tool if available.
+            return { type: 'any' };
+        }
+        // Fallback: preserve custom mode as-is in type field.
+        return { type: trimmed };
+    }
+    return undefined;
+}
 export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     const requestBody = isObject(chatReq) ? chatReq : {};
     const model = String(requestBody?.model || 'unknown');
@@ -882,6 +932,10 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     if (anthropicTools !== undefined) {
         out.tools = anthropicTools;
     }
+    const normalizedToolChoice = normalizeAnthropicToolChoice(requestBody.tool_choice);
+    if (normalizedToolChoice !== undefined) {
+        out.tool_choice = normalizedToolChoice;
+    }
     try {
         if (requestBody.metadata && typeof requestBody.metadata === 'object') {
             out.metadata = JSON.parse(JSON.stringify(requestBody.metadata));

package/dist/conversion/shared/args-mapping.js

@@ -1,4 +1,4 @@
-// Shared tool + argument mapping helpers (schema-driven)
+import { buildShellDescription, hasApplyPatchToolDeclared, isShellToolName } from '../../tools/tool-description-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -155,6 +155,7 @@ export function normalizeTools(tools) {
     if (!Array.isArray(tools))
         return [];
     const out = [];
+    const applyPatchAvailable = hasApplyPatchToolDeclared(tools);
     for (const t of tools) {
         if (!t || typeof t !== 'object')
             continue;
@@ -175,7 +176,7 @@ export function normalizeTools(tools) {
         }
         // Enforce schema for known tools with minimal, compatible constraints
         let finalParams;
-        if (typeof name === 'string' && name.trim().toLowerCase() === 'shell') {
+        if (isShellToolName(name)) {
             // Do NOT downgrade an existing schema; prefer string command, allow argv array as fallback
             const base = isObject(params) ? params : {};
             const props = isObject(base.properties) ? base.properties : {};
@@ -205,7 +206,14 @@ export function normalizeTools(tools) {
         else {
             finalParams = { type: 'object', properties: {}, additionalProperties: true };
         }
-        const norm = { type: 'function', function: { name, ...(desc ? { description: desc } : {}), parameters: finalParams } };
+        const functionNode = { name, ...(desc ? { description: desc } : {}), parameters: finalParams };
+        if (isShellToolName(name)) {
+            const display = (typeof name === 'string' && name.trim().length > 0)
+                ? name.trim()
+                : ((typeof topName === 'string' && topName.trim().length > 0) ? topName.trim() : 'shell');
+            functionNode.description = buildShellDescription(display, applyPatchAvailable);
+        }
+        const norm = { type: 'function', function: functionNode };
         if (norm.function?.name)
             out.push(norm);
     }

package/dist/conversion/shared/gemini-tool-utils.js

@@ -12,6 +12,14 @@ function cloneParameters(value) {
     if (isPlainRecord(value)) {
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
+            // Gemini function_declarations.parameters only support a subset of JSON Schema.
+            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum.
+            if (typeof key === 'string') {
+                if (key.startsWith('$'))
+                    continue;
+                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum')
+                    continue;
+            }
             cloned[key] = cloneParameters(entry);
         }
         return cloned;

package/dist/conversion/shared/responses-output-builder.js

@@ -153,70 +153,50 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (usageRaw && typeof usageRaw === 'object') {
-        const usage = { ...usageRaw };
-        if (usage.input_tokens != null && usage.prompt_tokens == null) {
-            usage.prompt_tokens = usage.input_tokens;
-        }
-        if (usage.output_tokens != null && usage.completion_tokens == null) {
-            usage.completion_tokens = usage.output_tokens;
-        }
-        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
-            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
-            if (!Number.isNaN(total))
-                usage.total_tokens = total;
-        }
-        try {
-            delete usage.input_tokens;
-            delete usage.output_tokens;
-        }
-        catch {
-            /* ignore */
-        }
-        return usage;
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return usageRaw;
     }
-    return usageRaw;
-}
-function extractApplyPatchArguments(rawArgs) {
-    // Upstream Responses providers may wrap apply_patch arguments in a JSON object
-    // (e.g. { patch: '*** Begin Patch...', input: '...' }). For Codex, the tool
-    // expects a FREEFORM patch string obeying the unified diff grammar. Here we
-    // best-effort extract such a patch string when available.
-    const tryExtractFromObject = (obj) => {
-        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
-            return null;
-        const record = obj;
-        const candidates = ['patch', 'input'];
-        for (const key of candidates) {
-            const value = record[key];
-            if (typeof value !== 'string')
-                continue;
-            const trimmed = value.trimStart();
-            if (trimmed.startsWith('*** Begin Patch')) {
-                return trimmed;
-            }
-        }
-        return null;
-    };
-    if (typeof rawArgs === 'string') {
-        const trimmed = rawArgs.trimStart();
-        if (trimmed.startsWith('*** Begin Patch')) {
-            return trimmed;
-        }
-        try {
-            const parsed = JSON.parse(rawArgs);
-            const fromObject = tryExtractFromObject(parsed);
-            if (fromObject) {
-                return fromObject;
-            }
-        }
-        catch {
-            // non-JSON string that is not a patch header; leave to caller
+    const usage = { ...usageRaw };
+    // 统一 Responses 与 Chat 两种 usage 形态：
+    // - Responses: input_tokens / output_tokens / total_tokens
+    // - Chat: prompt_tokens / completion_tokens / total_tokens
+    const inputTokens = typeof usage.input_tokens === 'number'
+        ? usage.input_tokens
+        : typeof usage.prompt_tokens === 'number'
+            ? usage.prompt_tokens
+            : undefined;
+    const outputTokens = typeof usage.output_tokens === 'number'
+        ? usage.output_tokens
+        : typeof usage.completion_tokens === 'number'
+            ? usage.completion_tokens
+            : undefined;
+    let totalTokens = typeof usage.total_tokens === 'number'
+        ? usage.total_tokens
+        : undefined;
+    if (totalTokens === undefined && inputTokens !== undefined && outputTokens !== undefined) {
+        const total = Number(inputTokens) + Number(outputTokens);
+        if (!Number.isNaN(total)) {
+            totalTokens = total;
         }
-        return null;
     }
-    const fromObject = tryExtractFromObject(rawArgs);
-    return fromObject;
+    // Responses 规范字段：input_tokens / output_tokens / total_tokens
+    if (inputTokens !== undefined) {
+        usage.input_tokens = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usage.output_tokens = outputTokens;
+    }
+    if (totalTokens !== undefined) {
+        usage.total_tokens = totalTokens;
+    }
+    // 为了兼容内部统计逻辑，保留 prompt_tokens / completion_tokens 映射（如果原本没有）
+    if (usage.prompt_tokens == null && inputTokens !== undefined) {
+        usage.prompt_tokens = inputTokens;
+    }
+    if (usage.completion_tokens == null && outputTokens !== undefined) {
+        usage.completion_tokens = outputTokens;
+    }
+    return usage;
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
@@ -228,37 +208,16 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         if (!sanitized || sanitized.toLowerCase() === 'tool')
             return null;
         const rawArgs = fn?.arguments ?? call.arguments ?? {};
-        let argsStr;
-        if (sanitized === 'apply_patch') {
-            const patch = extractApplyPatchArguments(rawArgs);
-            if (patch != null) {
-                argsStr = patch;
-            }
-            else if (typeof rawArgs === 'string') {
-                argsStr = rawArgs;
-            }
-            else {
+        const argsStr = typeof rawArgs === 'string'
+            ? rawArgs
+            : (() => {
                 try {
-                    argsStr = JSON.stringify(rawArgs ?? {});
+                    return JSON.stringify(rawArgs ?? {});
                 }
                 catch {
-                    argsStr = '{}';
+                    return '{}';
                 }
-            }
-        }
-        else {
-            argsStr =
-                typeof rawArgs === 'string'
-                    ? rawArgs
-                    : (() => {
-                        try {
-                            return JSON.stringify(rawArgs ?? {});
-                        }
-                        catch {
-                            return '{}';
-                        }
-                    })();
-        }
+            })();
         const originalCallId = typeof call.id === 'string' && call.id.trim().length
             ? String(call.id)
             : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);