@hunterzhu/pulse-adapters 0.1.3 → 0.1.5

package/dist/providers/anthropic.js

@@ -1,4 +1,13 @@
-import { consumeProviderSse, normalizeAnthropicResponse, parseProviderJson, providerHttpError, providerNetworkError, providerResponseError } from './normalize.js';
+import { consumeProviderSse, normalizeAnthropicResponse, parseProviderJson, providerHttpErrorFromResponse, providerNetworkError, providerResponseError } from './normalize.js';
+function anthropicThinking(effort, maxTokens) {
+    if (!effort)
+        return {};
+    const requested = effort === 'high' ? 8_000 : effort === 'medium' ? 2_048 : 1_024;
+    const budget = Math.min(requested, maxTokens - 1_024);
+    if (budget < 1_024 || budget >= maxTokens)
+        return {};
+    return { thinking: { type: 'enabled', budget_tokens: budget } };
+}
 export class AnthropicAdapter {
     id;
     config;
@@ -12,11 +21,12 @@ export class AnthropicAdapter {
         const messages = [{ role: 'user', content: params.request.blocks.filter((block) => !['system', 'policy', 'tools'].includes(block.kind)).map((block) => ({ type: 'text', text: typeof block.content === 'string' ? block.content : JSON.stringify(block.content) })) }];
         const streaming = params.onObservation !== undefined;
         const tools = toolDefinitions(params.request);
-        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), max_tokens: params.maxOutputTokens ?? this.config.maxOutputTokens ?? 4096, ...(system ? { system } : {}), messages, ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: anthropicToolChoice(this.config.toolChoice) }) } : {}), ...(params.outputSchema === undefined ? {} : { output_format: { type: 'json_schema', schema: params.outputSchema } }), ...(streaming ? { stream: true } : {}) };
+        const maxTokens = params.maxOutputTokens ?? this.config.maxOutputTokens ?? 4096;
+        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), max_tokens: maxTokens, ...anthropicThinking(this.config.reasoningEffort, maxTokens), ...(system ? { system } : {}), messages, ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: anthropicToolChoice(this.config.toolChoice) }) } : {}), ...(params.outputSchema === undefined ? {} : { output_format: { type: 'json_schema', schema: params.outputSchema } }), ...(streaming ? { stream: true } : {}) };
         try {
             const response = await fetch(`${(this.config.baseURL ?? 'https://api.anthropic.com').replace(/\/$/, '')}/v1/messages`, { method: 'POST', signal: params.signal, headers: { 'content-type': 'application/json', ...(this.config.apiKey ? { 'x-api-key': this.config.apiKey } : {}), 'anthropic-version': '2023-06-01' }, body: JSON.stringify(body) });
             if (!response.ok)
-                throw providerHttpError(response.status);
+                throw await providerHttpErrorFromResponse(response);
             if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
                 return normalizeAnthropicResponse(await parseProviderJson(response));
             const events = await consumeProviderSse(response);

package/dist/providers/normalize.d.ts

@@ -3,10 +3,15 @@ export interface ProviderSseEvent {
     event?: string;
     data: any;
 }
-export declare function providerHttpError(status: number): Error & {
+export declare function providerHttpError(status: number, detail?: string): Error & {
     code: string;
     retryable: boolean;
 };
+/** Preserve the provider's actionable error message without copying arbitrary response bodies into logs. */
+export declare function providerHttpErrorFromResponse(response: Response): Promise<Error & {
+    code: string;
+    retryable: boolean;
+}>;
 export declare function providerNetworkError(cause: unknown): Error & {
     code: string;
     retryable: boolean;
@@ -18,5 +23,5 @@ export declare function providerResponseError(detail: string): Error & {
 export declare function parseProviderJson(response: Response): Promise<unknown>;
 /** Read provider SSE frames without treating incomplete tool arguments as executable input. */
 export declare function consumeProviderSse(response: Response): Promise<ProviderSseEvent[]>;
-export declare function normalizeOpenAIResponse(response: any): LLMResult;
+export declare function normalizeOpenAIResponse(response: any, toolNameAliases?: ReadonlyMap<string, string>): LLMResult;
 export declare function normalizeAnthropicResponse(response: any): LLMResult;

package/dist/providers/normalize.js

@@ -1,6 +1,43 @@
-export function providerHttpError(status) {
+export function providerHttpError(status, detail) {
     const retryable = status === 408 || status === 425 || status === 429 || status >= 500;
-    return Object.assign(new Error(`PROVIDER_HTTP_${status}`), { code: `PROVIDER_HTTP_${status}`, retryable });
+    const suffix = detail === undefined || detail.length === 0 ? '' : `: ${detail}`;
+    return Object.assign(new Error(`PROVIDER_HTTP_${status}${suffix}`), { code: `PROVIDER_HTTP_${status}`, retryable });
+}
+/** Preserve the provider's actionable error message without copying arbitrary response bodies into logs. */
+export async function providerHttpErrorFromResponse(response) {
+    let raw = '';
+    try {
+        raw = typeof response.text === 'function' ? await response.text() : '';
+    }
+    catch { /* keep the status-only error */ }
+    return providerHttpError(response.status, summarizeProviderError(raw));
+}
+function summarizeProviderError(raw) {
+    if (!raw.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const root = parsed;
+            const error = root.error;
+            if (typeof error === 'string')
+                return truncateProviderDetail(error);
+            if (error && typeof error === 'object' && !Array.isArray(error)) {
+                const value = error;
+                const fields = [value.message, value.type, value.code, value.param].filter((field) => typeof field === 'string' && field.length > 0);
+                if (fields.length > 0)
+                    return truncateProviderDetail(fields.join(' | '));
+            }
+            const message = root.message;
+            if (typeof message === 'string' && message.length > 0)
+                return truncateProviderDetail(message);
+        }
+    }
+    catch { /* fall back to a bounded plain-text detail */ }
+    return truncateProviderDetail(raw.replace(/\s+/g, ' ').trim());
+}
+function truncateProviderDetail(value) {
+    return value.length <= 500 ? value : `${value.slice(0, 497)}...`;
 }
 export function providerNetworkError(cause) {
     return Object.assign(new Error('PROVIDER_NETWORK_ERROR'), { code: 'PROVIDER_NETWORK_ERROR', retryable: true, cause });
@@ -71,13 +108,13 @@ export async function consumeProviderSse(response) {
         flush();
     return events;
 }
-export function normalizeOpenAIResponse(response) {
+export function normalizeOpenAIResponse(response, toolNameAliases) {
     const root = providerRecord(response, 'OpenAI response');
     if (!Array.isArray(root.choices) || root.choices.length === 0)
         throw providerResponseError('OpenAI response must contain at least one choice');
     const choice = providerRecord(root.choices[0], 'OpenAI choice');
     const message = providerRecord(choice.message, 'OpenAI message');
-    const toolCalls = message.tool_calls === undefined ? [] : normalizeOpenAIToolCalls(message.tool_calls);
+    const toolCalls = message.tool_calls === undefined ? [] : normalizeOpenAIToolCalls(message.tool_calls, toolNameAliases);
     const refusal = message.refusal === undefined ? undefined : requiredProviderString(message.refusal, 'OpenAI refusal');
     const text = providerText(message.content, 'OpenAI message content');
     const finishReason = normalizeOpenAIFinishReason(choice.finish_reason, refusal, toolCalls.length > 0);
@@ -156,13 +193,14 @@ function normalizeCost(raw, provider) {
         throw providerResponseError(`${provider} pricing version must be a string`);
     return { amount: value.amount, currency: value.currency, source: 'reported', ...(value.pricing_version === undefined ? {} : { pricingVersion: value.pricing_version }) };
 }
-function normalizeOpenAIToolCalls(raw) {
+function normalizeOpenAIToolCalls(raw, toolNameAliases) {
     if (!Array.isArray(raw))
         throw providerResponseError('OpenAI tool_calls must be an array');
     return raw.map((call, index) => {
         const value = providerRecord(call, 'OpenAI tool call');
         const fn = providerRecord(value.function, 'OpenAI tool function');
-        return { toolCallId: `pulse-tool-${index + 1}`, name: requiredProviderString(fn.name, 'OpenAI tool name'), input: parseJson(fn.arguments) };
+        const providerName = requiredProviderString(fn.name, 'OpenAI tool name');
+        return { toolCallId: `pulse-tool-${index + 1}`, name: toolNameAliases?.get(providerName) ?? providerName, input: parseJson(fn.arguments) };
     });
 }
 function normalizeOpenAIFinishReason(raw, refusal, hasTools) {

package/dist/providers/openai-compat.d.ts

@@ -1,10 +1,11 @@
-import type { JsonValue, LLMRequestProjection } from '@hunterzhu/pulse-runtime';
+import type { JsonValue, LLMRequestProjection, LLMResult } from '@hunterzhu/pulse-runtime';
 import type { ProviderAdapter, ProviderPresetConfig } from './types.js';
 export declare class OpenAICompatibleAdapter implements ProviderAdapter {
     readonly id: string;
     private readonly config;
     readonly name = "OpenAI Compatible";
     private readonly baseURL;
+    private reasoningUnsupported;
     constructor(id: string, config: ProviderPresetConfig);
     executeAttempt(params: {
         request: LLMRequestProjection;
@@ -13,7 +14,7 @@ export declare class OpenAICompatibleAdapter implements ProviderAdapter {
         model?: string;
         outputSchema?: JsonValue;
         maxOutputTokens?: number;
-    }): Promise<import("@hunterzhu/pulse-runtime").LLMResult>;
+    }): Promise<LLMResult>;
 }
 export declare function toOpenAIMessages(request: LLMRequestProjection): Array<{
     role: 'system' | 'user' | 'assistant';

package/dist/providers/openai-compat.js

@@ -1,9 +1,18 @@
-import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpError, providerNetworkError } from './normalize.js';
+import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpErrorFromResponse, providerNetworkError } from './normalize.js';
+function reasoningParameterRejected(cause) {
+    if (!(cause instanceof Error))
+        return false;
+    const code = cause.code;
+    if (code !== 'PROVIDER_HTTP_400')
+        return false;
+    return /reasoning_effort|unknown parameter|unrecognized (?:request )?argument|extra fields? not permitted/i.test(cause.message);
+}
 export class OpenAICompatibleAdapter {
     id;
     config;
     name = 'OpenAI Compatible';
     baseURL;
+    reasoningUnsupported = false;
     constructor(id, config) {
         this.id = id;
         this.config = config;
@@ -11,14 +20,15 @@ export class OpenAICompatibleAdapter {
     }
     async executeAttempt(params) {
         const streaming = params.onObservation !== undefined;
-        const tools = toolDefinitions(params.request);
-        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), ...((params.maxOutputTokens ?? this.config.maxOutputTokens) === undefined ? {} : { max_tokens: params.maxOutputTokens ?? this.config.maxOutputTokens }), messages: toMessages(params.request), ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: this.config.toolChoice }) } : {}), ...(params.outputSchema === undefined ? {} : { response_format: { type: 'json_schema', json_schema: { name: 'pulse_output', strict: true, schema: params.outputSchema } } }), ...(streaming ? { stream: true, stream_options: { include_usage: true } } : {}) };
+        const { definitions: tools, aliases: toolNameAliases } = toolDefinitions(params.request);
+        const includeReasoning = Boolean(this.config.reasoningEffort) && !this.reasoningUnsupported;
+        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), ...((params.maxOutputTokens ?? this.config.maxOutputTokens) === undefined ? {} : { max_tokens: params.maxOutputTokens ?? this.config.maxOutputTokens }), ...(includeReasoning ? { reasoning_effort: this.config.reasoningEffort } : {}), messages: toMessages(params.request), ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: this.config.toolChoice }) } : {}), ...(params.outputSchema === undefined ? {} : { response_format: { type: 'json_schema', json_schema: { name: 'pulse_output', strict: true, schema: params.outputSchema } } }), ...(streaming ? { stream: true, stream_options: { include_usage: true } } : {}) };
         try {
             const response = await fetch(`${this.baseURL.replace(/\/$/, '')}/chat/completions`, { method: 'POST', signal: params.signal, headers: { 'content-type': 'application/json', ...(this.config.apiKey ? { authorization: `Bearer ${this.config.apiKey}` } : {}), ...(this.config.extraHeaders ?? {}) }, body: JSON.stringify(body) });
             if (!response.ok)
-                throw providerHttpError(response.status);
+                throw await providerHttpErrorFromResponse(response);
             if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
-                return normalizeOpenAIResponse(await parseProviderJson(response));
+                return normalizeOpenAIResponse(await parseProviderJson(response), toolNameAliases);
             const events = await consumeProviderSse(response);
             const content = [];
             const refusals = [];
@@ -55,11 +65,15 @@ export class OpenAICompatibleAdapter {
                 if (event.data.usage !== undefined)
                     usage = event.data.usage;
             }
-            return normalizeOpenAIResponse({ choices: [{ message: { content: content.join('') || null, ...(refusals.length ? { refusal: refusals.join('') } : {}), ...(toolCalls.size ? { tool_calls: [...toolCalls.entries()].sort(([left], [right]) => left - right).map(([, call]) => ({ id: call.id, function: { name: call.name, arguments: call.arguments } })) } : {}) }, finish_reason: finishReason ?? 'stop' }], ...(usage === undefined ? {} : { usage }) });
+            return normalizeOpenAIResponse({ choices: [{ message: { content: content.join('') || null, ...(refusals.length ? { refusal: refusals.join('') } : {}), ...(toolCalls.size ? { tool_calls: [...toolCalls.entries()].sort(([left], [right]) => left - right).map(([, call]) => ({ id: call.id, function: { name: call.name, arguments: call.arguments } })) } : {}) }, finish_reason: finishReason ?? 'stop' }], ...(usage === undefined ? {} : { usage }) }, toolNameAliases);
         }
         catch (cause) {
             if (params.signal.aborted)
                 throw Object.assign(new Error('Provider request was cancelled.'), { code: 'PROVIDER_REQUEST_CANCELLED', retryable: false, cause });
+            if (includeReasoning && reasoningParameterRejected(cause)) {
+                this.reasoningUnsupported = true;
+                return this.executeAttempt(params);
+            }
             if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string' && 'retryable' in cause && typeof cause.retryable === 'boolean')
                 throw cause;
             throw providerNetworkError(cause);
@@ -83,5 +97,18 @@ function toolDefinitions(request) {
     const block = request.blocks.find((candidate) => candidate.kind === 'tools');
     const content = block?.content;
     const values = Array.isArray(content) ? content : content && typeof content === 'object' && !Array.isArray(content) && Array.isArray(content.tools) ? content.tools : [];
-    return values.filter((value) => typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.name === 'string').map((value) => ({ type: 'function', function: { name: value.name, ...(typeof value.description === 'string' ? { description: value.description } : {}), parameters: (value.inputSchema ?? value.parameters ?? {}) } }));
+    const aliases = new Map();
+    const used = new Set();
+    const definitions = values.filter((value) => typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.name === 'string').map((value, index) => {
+        const originalName = value.name;
+        const baseName = originalName.replace(/[^a-zA-Z0-9_-]/g, '_') || `tool_${index + 1}`;
+        let providerName = baseName;
+        let suffix = 2;
+        while (used.has(providerName))
+            providerName = `${baseName}_${suffix++}`;
+        used.add(providerName);
+        aliases.set(providerName, originalName);
+        return { type: 'function', function: { name: providerName, ...(typeof value.description === 'string' ? { description: value.description } : {}), parameters: (value.inputSchema ?? value.parameters ?? {}) } };
+    });
+    return { definitions, aliases };
 }

package/dist/providers/types.d.ts

@@ -25,4 +25,5 @@ export interface ProviderPresetConfig {
     maxOutputTokens?: number;
     toolChoice?: ProviderToolChoice;
     extraHeaders?: Record<string, string>;
+    reasoningEffort?: 'low' | 'medium' | 'high' | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-adapters",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/zhuhengtan/Pulse"
@@ -16,7 +16,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@hunterzhu/pulse-runtime": "0.1.3",
-    "@hunterzhu/pulse-tool-sdk": "0.1.3"
+    "@hunterzhu/pulse-runtime": "0.1.5",
+    "@hunterzhu/pulse-tool-sdk": "0.1.5"
   }
 }