@myagentroam/agent 0.11.32 → 0.11.34

package/dist/model/responses-request.js

@@ -0,0 +1,363 @@
+import { AgentError } from '../error.js';
+import { agentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from './configuration.js';
+import { modelImageUrl } from './image.js';
+import { isRealUserMessage, uniqueModelImages } from './input-images.js';
+import { responseItem } from './responses-event-projection.js';
+import { record, text } from './sse.js';
+import { resolveModelTextBlocks } from './text-blocks.js';
+import { stableToolSchema } from './tool-schema.js';
+import { jsonToolInput } from './tool-input.js';
+export function responsesRequestBody(configuration, request, messages, previousOutputItems = []) {
+    const systemBlocks = resolveModelTextBlocks(request.system, request.systemBlocks ?? []);
+    if ((request.systemBlocks !== undefined && systemBlocks.some((block) => block.cache)) ||
+        messages.some((message) => message.textBlocks !== undefined &&
+            resolveModelTextBlocks(message.content, message.textBlocks).some((block) => block.cache)))
+        throw new AgentError('MAR_AGENT_MODEL_CAPABILITY_UNAVAILABLE', 'This model protocol does not support explicit text-block cache markers.');
+    const tools = request.allowTools === false
+        ? []
+        : request.tools.map((tool) => tool.nativeType === 'tool_search' &&
+            configuration.responsesOptionalParameters?.nativeTools !== false
+            ? {
+                type: 'tool_search',
+                execution: 'client',
+                description: tool.description,
+                parameters: stableToolSchema(strictFunctionSchema(stableToolSchema(tool.inputSchema)))
+            }
+            : responsesFunctionTool(tool, configuration.responsesOptionalParameters?.nativeTools !== false));
+    if (configuration.responsesToolNamespace && tools.length > 0) {
+        const native = tools.filter((tool) => record(tool).type === 'tool_search');
+        const nested = tools.filter((tool) => record(tool).type !== 'tool_search');
+        tools.splice(0, tools.length, ...native);
+        if (nested.length)
+            tools.push({
+                type: 'namespace',
+                name: configuration.responsesToolNamespace,
+                description: 'Client-side agent tools.',
+                tools: nested
+            });
+    }
+    if (request.allowTools !== false &&
+        request.allowHostedTools !== false &&
+        configuration.hostedWebSearch)
+        tools.push({ type: 'web_search' });
+    const toolChoice = request.toolChoice ?? 'auto';
+    const input = openAiInput(messages, request.images, configuration.id, true, usesResponsesConfigurationUpdates(configuration), configuration.responsesOptionalParameters?.nativeTools !== false, request.tools, previousOutputItems);
+    const systemInput = responsesSystemInput(request, systemBlocks);
+    if (systemInput !== undefined)
+        input.unshift(systemInput);
+    return {
+        model: configuration.modelId,
+        ...(request.outputLimit === undefined
+            ? {}
+            : {
+                max_output_tokens: Math.min(request.outputLimit, configuration.maxOutputTokens)
+            }),
+        ...(configuration.serviceTier !== undefined
+            ? { service_tier: configuration.serviceTier }
+            : configuration.fastMode === true
+                ? { service_tier: 'priority' }
+                : {}),
+        tools,
+        ...(tools.length > 0 ? { tool_choice: toolChoice, parallel_tool_calls: true } : {}),
+        input,
+        stream: true,
+        store: configuration.responsesPreviousResponseId === true &&
+            configuration.responsesTransport?.transport !== 'WEBSOCKET',
+        ...(configuration.responsesOptionalParameters?.textVerbosity === false
+            ? {}
+            : { text: { verbosity: 'low' } }),
+        include: [
+            'reasoning.encrypted_content',
+            ...(configuration.hostedWebSearch &&
+                request.allowTools !== false &&
+                request.allowHostedTools !== false &&
+                toolChoice !== 'none'
+                ? ['web_search_call.action.sources']
+                : [])
+        ],
+        ...(request.promptCacheKey &&
+            configuration.responsesOptionalParameters?.promptCacheKey !== false
+            ? { prompt_cache_key: request.promptCacheKey }
+            : {}),
+        ...(configuration.responsesOptionalParameters?.reasoningEffort === false &&
+            configuration.responsesOptionalParameters?.reasoningSummary === false
+            ? {}
+            : {
+                reasoning: {
+                    ...(configuration.responsesOptionalParameters?.reasoningEffort === false
+                        ? {}
+                        : {
+                            effort: request.requestReasoningEffort?.trim() ||
+                                request.reasoningEffort?.trim() ||
+                                resolveModelDefaultReasoningEffort(configuration)
+                        }),
+                    ...(configuration.responsesOptionalParameters?.reasoningSummary === false
+                        ? {}
+                        : { summary: 'auto' })
+                }
+            })
+    };
+}
+function responsesSystemInput(request, blocks = resolveModelTextBlocks(request.system, request.systemBlocks ?? [])) {
+    if (blocks.length === 0)
+        return undefined;
+    return {
+        role: 'developer',
+        content: blocks.map((block) => ({ type: 'input_text', text: block.text }))
+    };
+}
+function strictFunctionSchema(value, optional = false) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const schema = value;
+    const supportedSchema = Object.fromEntries(Object.entries(schema).filter(([keyword]) => keyword !== 'propertyNames' && keyword !== 'uniqueItems'));
+    if (optional && Array.isArray(schema.enum) && !schema.enum.includes(null))
+        supportedSchema.enum = [...schema.enum, null];
+    if (schema.type === 'object') {
+        const properties = record(schema.properties);
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        return {
+            ...supportedSchema,
+            ...(optional ? { type: ['object', 'null'] } : {}),
+            properties: Object.fromEntries(Object.entries(properties).map(([name, property]) => [
+                name,
+                strictFunctionSchema(property, !required.has(name))
+            ])),
+            required: Object.keys(properties),
+            additionalProperties: false
+        };
+    }
+    if (schema.type === 'array')
+        return {
+            ...supportedSchema,
+            ...(schema.items === undefined ? {} : { items: strictFunctionSchema(schema.items) }),
+            ...(optional ? { type: ['array', 'null'] } : {})
+        };
+    if (!optional)
+        return supportedSchema;
+    if (typeof schema.type === 'string')
+        return { ...supportedSchema, type: [schema.type, 'null'] };
+    if (Array.isArray(schema.type))
+        return {
+            ...supportedSchema,
+            type: schema.type.includes('null') ? schema.type : [...schema.type, 'null']
+        };
+    if (Array.isArray(schema.enum))
+        return supportedSchema;
+    return { anyOf: [supportedSchema, { type: 'null' }] };
+}
+export function openAiInput(messages, images, modelId, requireEncryptedReasoning, configurationUpdates = true, nativeTools = true, tools = [], previousOutputItems = []) {
+    const compatibleMessages = messages.filter((message) => message.role !== 'provider' ||
+        (message.provider === 'OPENAI_RESPONSES' &&
+            (message.providerModelId === undefined || message.providerModelId === modelId) &&
+            (configurationUpdates || message.item?.type !== 'configuration_update') &&
+            (nativeTools ||
+                !['custom_tool_call', 'tool_search_call', 'tool_search_output'].includes(String(message.item?.type))) &&
+            (!requireEncryptedReasoning ||
+                message.item?.type !== 'reasoning' ||
+                typeof message.item.encrypted_content === 'string')));
+    const lastUser = compatibleMessages.findLast(isRealUserMessage);
+    const providerCallIds = new Set();
+    const functionCallIds = new Set();
+    const customCallIds = new Set();
+    const providerMessageTexts = new Set();
+    // Incremental input omits the calls already retained by the WebSocket response.
+    for (const item of previousOutputItems) {
+        if (typeof item.call_id !== 'string')
+            continue;
+        if (item.type === 'function_call')
+            functionCallIds.add(item.call_id);
+        if (nativeTools && item.type === 'custom_tool_call')
+            customCallIds.add(item.call_id);
+    }
+    for (const message of compatibleMessages) {
+        if (message.role !== 'provider' || !message.item)
+            continue;
+        if (message.item.type === 'function_call' && typeof message.item.call_id === 'string') {
+            providerCallIds.add(message.item.call_id);
+            functionCallIds.add(message.item.call_id);
+        }
+        if (message.item.type === 'tool_search_call' && typeof message.item.call_id === 'string')
+            providerCallIds.add(message.item.call_id);
+        if (message.item.type === 'custom_tool_call' && typeof message.item.call_id === 'string') {
+            providerCallIds.add(message.item.call_id);
+            customCallIds.add(message.item.call_id);
+        }
+        if (message.item.type === 'message') {
+            const content = Array.isArray(message.item.content) ? message.item.content : [];
+            const value = content
+                .map((part) => {
+                const item = record(part);
+                return text(item.text) ?? '';
+            })
+                .join('');
+            if (value)
+                providerMessageTexts.add(value);
+        }
+    }
+    for (const message of compatibleMessages)
+        if (nativeTools &&
+            message.role === 'tool_call' &&
+            message.inputMode === 'freeform' &&
+            message.callId)
+            customCallIds.add(message.callId);
+    const orderedMessages = [];
+    for (const message of compatibleMessages) {
+        if (message.role === 'provider' && message.item?.type === 'configuration_update') {
+            const userIndex = orderedMessages.findLastIndex(isRealUserMessage);
+            if (userIndex >= 0) {
+                orderedMessages.splice(userIndex, 0, message);
+                continue;
+            }
+        }
+        orderedMessages.push(message);
+    }
+    // SDK records the update after the user input; the wire item must precede
+    // that user message so the new effort applies to the response.
+    return orderedMessages
+        .filter((message) => !(message.role === 'tool_call' && message.callId && providerCallIds.has(message.callId)) &&
+        !(message.role === 'assistant' && providerMessageTexts.has(message.content)))
+        .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds, functionCallIds, nativeTools, tools));
+}
+function openAiInputItem(message, images, customCallIds = new Set(), functionCallIds = new Set(), nativeTools = true, tools = []) {
+    const userImages = message.role === 'user' ? uniqueModelImages(message.images, images) : [];
+    if (message.role === 'provider') {
+        if (message.provider !== 'OPENAI_RESPONSES' || !message.item)
+            throw new AgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item is invalid.');
+        if (message.item.type === 'configuration_update') {
+            const effort = agentReasoningEffortSchema.safeParse(record(message.item.reasoning).effort);
+            if (effort.success)
+                return { type: 'configuration_update', reasoning: { effort: effort.data } };
+        }
+        const item = responseItem(message.item);
+        if (!item)
+            throw new AgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item type is unsupported.');
+        return item;
+    }
+    if (nativeTools && message.role === 'tool_call' && message.inputMode === 'freeform')
+        return {
+            type: 'custom_tool_call',
+            call_id: message.callId,
+            name: message.name,
+            input: String(message.arguments ?? '')
+        };
+    if (nativeTools && message.role === 'tool_call' && message.name === 'tool_search')
+        return {
+            type: 'tool_search_call',
+            call_id: message.callId,
+            status: 'completed',
+            execution: 'client',
+            arguments: message.arguments ?? {}
+        };
+    if (message.role === 'tool_call')
+        return {
+            type: 'function_call',
+            call_id: message.callId,
+            name: message.name,
+            arguments: JSON.stringify(message.inputMode === 'freeform'
+                ? jsonToolInput(message, tools.find((tool) => tool.name === message.name))
+                : (message.arguments ?? {}))
+        };
+    if (message.role === 'tool' &&
+        nativeTools &&
+        message.toolSearchTools &&
+        !functionCallIds.has(message.callId ?? ''))
+        return {
+            type: 'tool_search_output',
+            call_id: message.callId,
+            status: 'completed',
+            execution: 'client',
+            tools: message.toolSearchTools.map((tool) => responsesFunctionTool(tool))
+        };
+    if (message.role === 'tool')
+        return {
+            type: customCallIds.has(message.callId ?? '')
+                ? 'custom_tool_call_output'
+                : 'function_call_output',
+            call_id: message.callId,
+            output: (message.textBlocks === undefined ? message.contentParts : undefined)?.map((part) => part.type === 'text'
+                ? { type: 'input_text', text: part.text }
+                : {
+                    type: 'input_image',
+                    image_url: modelImageUrl(part.image)
+                }) ??
+                (message.textBlocks !== undefined
+                    ? [
+                        ...resolveModelTextBlocks(message.content, message.textBlocks).map((block) => ({
+                            type: 'input_text',
+                            text: block.text
+                        })),
+                        ...(message.images ?? []).map((image) => ({
+                            type: 'input_image',
+                            image_url: modelImageUrl(image)
+                        }))
+                    ]
+                    : message.images?.length
+                        ? [
+                            { type: 'input_text', text: message.content },
+                            ...message.images.map((image) => ({
+                                type: 'input_image',
+                                image_url: modelImageUrl(image)
+                            }))
+                        ]
+                        : message.content)
+        };
+    return {
+        role: message.role === 'user' && contextualAuthority(message) === 'instruction'
+            ? 'developer'
+            : message.role,
+        content: message.textBlocks !== undefined
+            ? [
+                ...resolveModelTextBlocks(message.content, message.textBlocks).map((block) => ({
+                    type: message.role === 'assistant' ? 'output_text' : 'input_text',
+                    text: block.text
+                })),
+                ...userImages.map((image) => ({
+                    type: 'input_image',
+                    image_url: modelImageUrl(image)
+                }))
+            ]
+            : userImages.length > 0
+                ? [
+                    { type: 'input_text', text: message.content },
+                    ...userImages.map((image) => ({
+                        type: 'input_image',
+                        image_url: modelImageUrl(image)
+                    }))
+                ]
+                : message.content
+    };
+}
+function contextualAuthority(message) {
+    return message.contextualBlock?.authority;
+}
+function responsesFunctionTool(tool, nativeTools = true) {
+    const strict = !hasOpenFunctionObject(tool.inputSchema);
+    return tool.inputMode === 'freeform' && nativeTools
+        ? { type: 'custom', name: tool.name, description: tool.description }
+        : {
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: stableToolSchema(strict ? strictFunctionSchema(stableToolSchema(tool.inputSchema)) : tool.inputSchema),
+            strict
+        };
+}
+function hasOpenFunctionObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const schema = record(value);
+    if ((schema.type === 'object' || (Array.isArray(schema.type) && schema.type.includes('object'))) &&
+        (schema.additionalProperties === true ||
+            (schema.additionalProperties !== null && typeof schema.additionalProperties === 'object') ||
+            (schema.properties === undefined && schema.additionalProperties !== false)))
+        return true;
+    const children = [
+        ...Object.values(record(schema.properties)),
+        ...Object.values(record(schema.$defs)),
+        ...Object.values(record(schema.definitions)),
+        schema.items,
+        ...[schema.anyOf, schema.oneOf, schema.allOf].flatMap((items) => Array.isArray(items) ? items : [])
+    ];
+    return children.some(hasOpenFunctionObject);
+}

package/dist/model/responses-session-cache.d.ts

@@ -0,0 +1,33 @@
+import WebSocket from 'ws';
+export type ResponsesRequestBody = Readonly<Record<string, unknown>> & {
+    readonly input: readonly unknown[];
+};
+export interface ResponsesSessionState {
+    socket?: WebSocket;
+    endpoint?: string;
+    credentialRevision?: number;
+    credentialFingerprint?: string;
+    connectionId?: string;
+    proxyType?: 'DIRECT' | 'SOCKS5';
+    lastRequest?: ResponsesRequestBody;
+    lastMessageCount?: number;
+    lastInputItemCount?: number;
+    lastSystem?: string;
+    lastResponse?: {
+        readonly responseId: string;
+        readonly outputItems: readonly Record<string, unknown>[];
+    };
+}
+export declare function clearResponsesContinuation(state: ResponsesSessionState): void;
+export declare function terminateWebSocket(socket: WebSocket): void;
+export declare function invalidateResponsesWebSocket(state: ResponsesSessionState, clearContinuation: boolean): void;
+/** One idle state per Adapter; concurrent Turns never share a lease. */
+export declare class ResponsesSessionCache {
+    #private;
+    checkout(): {
+        readonly state: ResponsesSessionState;
+        readonly lease: boolean;
+    };
+    release(state: ResponsesSessionState, lease: boolean): void;
+    close(): void;
+}

package/dist/model/responses-session-cache.js

@@ -0,0 +1,64 @@
+import WebSocket from 'ws';
+import { AgentError } from '../error.js';
+export function clearResponsesContinuation(state) {
+    delete state.lastRequest;
+    delete state.lastMessageCount;
+    delete state.lastInputItemCount;
+    delete state.lastSystem;
+    delete state.lastResponse;
+}
+export function terminateWebSocket(socket) {
+    if (socket.readyState === WebSocket.CONNECTING)
+        socket.once('error', () => undefined);
+    socket.terminate();
+}
+export function invalidateResponsesWebSocket(state, clearContinuation) {
+    const socket = state.socket;
+    delete state.socket;
+    delete state.endpoint;
+    delete state.credentialRevision;
+    delete state.credentialFingerprint;
+    delete state.connectionId;
+    delete state.proxyType;
+    if (clearContinuation)
+        clearResponsesContinuation(state);
+    if (socket !== undefined &&
+        socket.readyState !== WebSocket.CLOSED &&
+        socket.readyState !== WebSocket.CLOSING)
+        terminateWebSocket(socket);
+}
+/** One idle state per Adapter; concurrent Turns never share a lease. */
+export class ResponsesSessionCache {
+    #state = {};
+    #leased = false;
+    #closed = false;
+    checkout() {
+        if (this.#closed)
+            throw new AgentError('MAR_AGENT_DISPOSED', 'Model adapter is disposed.');
+        const lease = !this.#leased;
+        const state = lease ? this.#state : {};
+        if (lease) {
+            this.#state = {};
+            this.#leased = true;
+        }
+        return { state, lease };
+    }
+    release(state, lease) {
+        if (!lease || this.#closed) {
+            invalidateResponsesWebSocket(state, true);
+            return;
+        }
+        if (state.socket !== undefined && state.socket.readyState !== WebSocket.OPEN) {
+            invalidateResponsesWebSocket(state, false);
+            clearResponsesContinuation(state);
+        }
+        this.#state = state;
+        this.#leased = false;
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        invalidateResponsesWebSocket(this.#state, true);
+    }
+}

package/dist/model/runtime-credential.d.ts

@@ -0,0 +1 @@
+export * from '../network/credential-runtime.js';

package/dist/model/runtime-credential.js

@@ -0,0 +1 @@
+export * from '../network/credential-runtime.js';