@hunterzhu/pulse-adapters 0.1.3 → 0.1.4

package/dist/providers/anthropic.js

@@ -1,4 +1,4 @@
-import { consumeProviderSse, normalizeAnthropicResponse, parseProviderJson, providerHttpError, providerNetworkError, providerResponseError } from './normalize.js';
+import { consumeProviderSse, normalizeAnthropicResponse, parseProviderJson, providerHttpErrorFromResponse, providerNetworkError, providerResponseError } from './normalize.js';
 export class AnthropicAdapter {
     id;
     config;
@@ -16,7 +16,7 @@ export class AnthropicAdapter {
         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.js

@@ -1,4 +1,4 @@
-import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpError, providerNetworkError } from './normalize.js';
+import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpErrorFromResponse, providerNetworkError } from './normalize.js';
 export class OpenAICompatibleAdapter {
     id;
     config;
@@ -11,14 +11,14 @@ export class OpenAICompatibleAdapter {
     }
     async executeAttempt(params) {
         const streaming = params.onObservation !== undefined;
-        const tools = toolDefinitions(params.request);
+        const { definitions: tools, aliases: toolNameAliases } = 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 } } : {}) };
         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,7 +55,7 @@ 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)
@@ -83,5 +83,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-adapters",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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.4",
+    "@hunterzhu/pulse-tool-sdk": "0.1.4"
   }
 }