@hunterzhu/pulse-adapters 0.2.1 → 0.4.0

package/dist/providers/anthropic.js

@@ -29,6 +29,10 @@ export class AnthropicAdapter {
         for (const block of params.request.blocks) {
             if (block.kind === 'system' || block.kind === 'policy' || block.kind === 'tools')
                 continue;
+            // Provider-native tool history is currently projected only by compatible
+            // OpenAI adapters. Keep Anthropic on the legacy history projection.
+            if (block.kind === 'provider_history')
+                continue;
             if (block.kind === 'conversation' && Array.isArray(block.content)) {
                 for (const item of block.content) {
                     if (!item || typeof item !== 'object' || Array.isArray(item))

package/dist/providers/normalize.d.ts

@@ -23,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, onEvent?: (event: ProviderSseEvent) => void): Promise<ProviderSseEvent[]>;
-export declare function normalizeOpenAIResponse(response: any, toolNameAliases?: ReadonlyMap<string, string>): LLMResult;
+export declare function normalizeOpenAIResponse(response: any, toolNameAliases?: ReadonlyMap<string, string>, provider?: string): LLMResult;
 export declare function normalizeAnthropicResponse(response: any): LLMResult;

package/dist/providers/normalize.js

@@ -110,7 +110,7 @@ export async function consumeProviderSse(response, onEvent) {
         flush();
     return events;
 }
-export function normalizeOpenAIResponse(response, toolNameAliases) {
+export function normalizeOpenAIResponse(response, toolNameAliases, provider = 'openai') {
     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');
@@ -122,8 +122,10 @@ export function normalizeOpenAIResponse(response, toolNameAliases) {
     const finishReason = normalizeOpenAIFinishReason(choice.finish_reason, refusal, toolCalls.length > 0);
     const rawUsage = root.usage === undefined ? undefined : providerRecord(root.usage, 'OpenAI usage');
     const promptDetails = rawUsage?.prompt_tokens_details === undefined ? undefined : providerRecord(rawUsage.prompt_tokens_details, 'OpenAI prompt token details');
-    const usage = normalizeUsage(rawUsage === undefined ? undefined : { ...rawUsage, cached_tokens: rawUsage.cached_tokens ?? promptDetails?.cached_tokens ?? rawUsage.cache_read_input_tokens }, { input: 'prompt_tokens', output: 'completion_tokens', cached: 'cached_tokens' }, 'OpenAI');
-    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(usage === undefined ? {} : { usage }) };
+    const usage = normalizeUsage(rawUsage === undefined ? undefined : { ...rawUsage, cached_tokens: rawUsage.cached_tokens ?? promptDetails?.cached_tokens ?? rawUsage.cache_read_input_tokens, reasoning_tokens: rawUsage.completion_tokens_details?.reasoning_tokens ?? rawUsage.reasoning_tokens }, { input: 'prompt_tokens', output: 'completion_tokens', cached: 'cached_tokens', reasoning: 'reasoning_tokens' }, 'OpenAI');
+    const reasoningContent = typeof message.reasoning_content === 'string' ? message.reasoning_content : undefined;
+    const measuredUsage = usage === undefined ? undefined : { ...usage, visibleOutputChars: text.length };
+    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(measuredUsage === undefined ? {} : { usage: measuredUsage }), ...(provider !== 'deepseek' || reasoningContent === undefined ? {} : { providerContinuation: { provider, reasoningContent } }) };
 }
 export function normalizeAnthropicResponse(response) {
     const root = providerRecord(response, 'Anthropic response');
@@ -140,7 +142,8 @@ export function normalizeAnthropicResponse(response) {
     const refusal = refusalBlock?.text;
     const finishReason = normalizeAnthropicFinishReason(root.stop_reason, refusal, toolCalls.length > 0);
     const usage = normalizeUsage(root.usage, { input: 'input_tokens', output: 'output_tokens', cached: 'cache_read_input_tokens' }, 'Anthropic');
-    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(usage === undefined ? {} : { usage }) };
+    const measuredUsage = usage === undefined ? undefined : { ...usage, visibleOutputChars: text.length };
+    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(measuredUsage === undefined ? {} : { usage: measuredUsage }) };
 }
 function providerRecord(value, label) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -180,10 +183,11 @@ function normalizeUsage(raw, fields, provider) {
     const inputTokens = providerMetric(value[fields.input], `${provider} input tokens`);
     const outputTokens = providerMetric(value[fields.output], `${provider} output tokens`);
     const cachedInputTokens = providerMetric(value[fields.cached], `${provider} cached input tokens`);
+    const reasoningTokens = fields.reasoning === undefined ? undefined : providerMetric(value[fields.reasoning], `${provider} reasoning tokens`);
     if (inputTokens !== undefined && cachedInputTokens !== undefined && cachedInputTokens > inputTokens)
         throw providerResponseError(`${provider} cached input tokens exceed input tokens`);
     const cost = value.cost === undefined ? undefined : normalizeCost(value.cost, provider);
-    return { ...(inputTokens === undefined ? {} : { inputTokens }), ...(outputTokens === undefined ? {} : { outputTokens }), ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }), ...(inputTokens !== undefined && cachedInputTokens !== undefined ? { uncachedInputTokens: inputTokens - cachedInputTokens } : {}), ...(cost === undefined ? {} : { cost }) };
+    return { ...(inputTokens === undefined ? {} : { inputTokens }), ...(outputTokens === undefined ? {} : { outputTokens }), ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }), ...(reasoningTokens === undefined ? {} : { reasoningTokens }), ...(inputTokens !== undefined && cachedInputTokens !== undefined ? { uncachedInputTokens: inputTokens - cachedInputTokens } : {}), ...(cost === undefined ? {} : { cost }) };
 }
 function normalizeCost(raw, provider) {
     const value = providerRecord(raw, `${provider} cost`);
@@ -202,7 +206,10 @@ function normalizeOpenAIToolCalls(raw, toolNameAliases) {
         const value = providerRecord(call, 'OpenAI tool call');
         const fn = providerRecord(value.function, 'OpenAI tool function');
         const providerName = requiredProviderString(fn.name, 'OpenAI tool name');
-        return { toolCallId: `pulse-tool-${index + 1}`, name: toolNameAliases?.get(providerName) ?? providerName, input: parseJson(fn.arguments) };
+        const providerToolCallId = typeof value.id === 'string' && value.id.length > 0 ? value.id : undefined;
+        if (typeof fn.arguments !== 'string')
+            throw providerResponseError('OpenAI tool arguments must be a JSON string');
+        return { toolCallId: `pulse-tool-${index + 1}`, ...(providerToolCallId === undefined ? {} : { providerToolCallId }), providerToolName: providerName, providerToolArguments: fn.arguments, name: toolNameAliases?.get(providerName) ?? providerName, input: parseJson(fn.arguments) };
     });
 }
 function normalizeOpenAIFinishReason(raw, refusal, hasTools) {

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

@@ -16,8 +16,4 @@ export declare class OpenAICompatibleAdapter implements ProviderAdapter {
         maxOutputTokens?: number;
     }): Promise<LLMResult>;
 }
-export declare function toOpenAIMessages(request: LLMRequestProjection): Array<{
-    role: 'system' | 'user' | 'assistant';
-    content: string;
-    name?: string;
-}>;
+export declare function toOpenAIMessages(request: LLMRequestProjection, provider?: string): Array<Record<string, unknown>>;

package/dist/providers/openai-compat.js

@@ -22,7 +22,7 @@ export class OpenAICompatibleAdapter {
         const streaming = params.onObservation !== undefined;
         const { definitions: tools, aliases: toolNameAliases } = toolDefinitions(params.request);
         const includeReasoning = Boolean(this.config.reasoningEffort) && !this.reasoningUnsupported;
-        const messages = toMessages(params.request);
+        const messages = toMessages(params.request, this.config.provider);
         const deepSeekJsonMode = params.outputSchema !== undefined && this.config.provider === 'deepseek';
         if (deepSeekJsonMode)
             messages.unshift({ role: 'system', content: `Return only a JSON object matching this schema. The application will validate the result:\n${JSON.stringify(params.outputSchema)}` });
@@ -35,7 +35,7 @@ export class OpenAICompatibleAdapter {
             if (!response.ok)
                 throw await providerHttpErrorFromResponse(response);
             if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
-                return normalizeOpenAIResponse(await parseProviderJson(response), toolNameAliases);
+                return normalizeOpenAIResponse(await parseProviderJson(response), toolNameAliases, this.config.provider);
             const events = await consumeProviderSse(response, (event) => {
                 const delta = event.data?.choices?.[0]?.delta;
                 if (typeof delta?.content === 'string')
@@ -44,6 +44,7 @@ export class OpenAICompatibleAdapter {
                     params.onObservation?.(delta.refusal);
             });
             const content = [];
+            const reasoningContent = [];
             const refusals = [];
             const toolCalls = new Map();
             let finishReason;
@@ -56,6 +57,8 @@ export class OpenAICompatibleAdapter {
                 if (typeof delta?.content === 'string') {
                     content.push(delta.content);
                 }
+                if (typeof delta?.reasoning_content === 'string')
+                    reasoningContent.push(delta.reasoning_content);
                 if (typeof delta?.refusal === 'string') {
                     refusals.push(delta.refusal);
                 }
@@ -67,7 +70,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 }) }, toolNameAliases);
+            return normalizeOpenAIResponse({ choices: [{ message: { content: content.join('') || null, ...(reasoningContent.length ? { reasoning_content: reasoningContent.join('') } : {}), ...(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, this.config.provider);
         }
         catch (cause) {
             if (params.signal.aborted)
@@ -82,7 +85,7 @@ export class OpenAICompatibleAdapter {
         }
     }
 }
-export function toOpenAIMessages(request) {
+export function toOpenAIMessages(request, provider = 'openai') {
     const messages = [];
     for (const block of request.blocks) {
         const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
@@ -102,15 +105,30 @@ export function toOpenAIMessages(request) {
             messages.push({ role: 'system', content });
             continue;
         }
-        if (block.kind === 'history')
+        if (block.kind === 'history' && request.contextSpec.providerHistory !== undefined)
+            continue;
+        if (block.kind === 'provider_history' && request.contextSpec.providerHistory !== undefined) {
+            for (const item of request.contextSpec.providerHistory) {
+                if (item.role === 'user')
+                    messages.push({ role: 'user', content: item.content });
+                else if (item.role === 'assistant')
+                    messages.push({ role: 'assistant', content: item.content, ...(provider === 'deepseek' && item.reasoningContent !== undefined ? { reasoning_content: item.reasoningContent } : {}), ...(item.toolCalls === undefined ? {} : { tool_calls: item.toolCalls.map((call) => ({ id: call.id, type: 'function', function: { name: call.name, arguments: call.arguments } })) }) });
+                else
+                    messages.push({ role: 'tool', tool_call_id: item.toolCallId, name: item.name, content: item.content });
+            }
+            continue;
+        }
+        else if (block.kind === 'history')
             messages.push({ role: 'assistant', content });
+        else if (block.kind === 'provider_history')
+            continue;
         else
             messages.push({ role: 'user', name: block.kind, content });
     }
     return messages;
 }
-function toMessages(request) {
-    return toOpenAIMessages(request);
+function toMessages(request, provider) {
+    return toOpenAIMessages(request, provider);
 }
 function nextToolIndex(toolCalls) {
     let next = 0;

package/dist/providers/runtime-executor.js

@@ -82,7 +82,7 @@ function toJson(value, seen = new Set()) {
 function candidateMetadata(candidate, attempts, usage, slotWaitMs, routes) {
     return { selected: { id: candidate.id, providerId: candidate.providerId }, routes, attempts: attempts.map((attempt) => {
             const recorded = usage.get(attempt.attemptId);
-            const usageJson = recorded === undefined ? undefined : { ...(recorded.inputTokens === undefined ? {} : { inputTokens: recorded.inputTokens }), ...(recorded.outputTokens === undefined ? {} : { outputTokens: recorded.outputTokens }), ...(recorded.cachedInputTokens === undefined ? {} : { cachedInputTokens: recorded.cachedInputTokens }), ...(recorded.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: recorded.uncachedInputTokens }), ...(recorded.latencyMs === undefined ? {} : { latencyMs: recorded.latencyMs }), ...(recorded.cost === undefined ? {} : { cost: recorded.cost }) };
+            const usageJson = recorded === undefined ? undefined : { ...(recorded.inputTokens === undefined ? {} : { inputTokens: recorded.inputTokens }), ...(recorded.outputTokens === undefined ? {} : { outputTokens: recorded.outputTokens }), ...(recorded.reasoningTokens === undefined ? {} : { reasoningTokens: recorded.reasoningTokens }), ...(recorded.visibleOutputChars === undefined ? {} : { visibleOutputChars: recorded.visibleOutputChars }), ...(recorded.cachedInputTokens === undefined ? {} : { cachedInputTokens: recorded.cachedInputTokens }), ...(recorded.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: recorded.uncachedInputTokens }), ...(recorded.latencyMs === undefined ? {} : { latencyMs: recorded.latencyMs }), ...(recorded.cost === undefined ? {} : { cost: recorded.cost }) };
             const waited = slotWaitMs.get(attempt.attemptId);
             return { effectId: attempt.effectId, attemptId: attempt.attemptId, attemptNo: attempt.attemptNo, modelId: attempt.candidate.id, providerId: attempt.candidate.providerId, ...(waited === undefined ? {} : { slotWaitMs: waited }), ...(usageJson === undefined ? {} : { usage: usageJson }) };
         }) };
@@ -163,10 +163,10 @@ export function createModelEffectExecutor(config) {
                         observations.push(observation);
                 };
                 const output = assignRuntimeToolCallIds(validateAdapterResult(await provider.executeAttempt({ request: projection, signal, model: attempt.candidate.id, ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }), ...(typeof routeRequirements.maxOutputTokens === 'number' ? { maxOutputTokens: routeRequirements.maxOutputTokens } : {}), onObservation })), effect.id);
-                const measuredUsage = output.usage === undefined ? { latencyMs: Math.max(0, Date.now() - startedAt) } : { ...output.usage, latencyMs: output.usage.latencyMs ?? Math.max(0, Date.now() - startedAt), ...(output.usage.uncachedInputTokens === undefined && output.usage.inputTokens !== undefined && output.usage.cachedInputTokens !== undefined ? { uncachedInputTokens: Math.max(0, output.usage.inputTokens - output.usage.cachedInputTokens) } : {}) };
+                const measuredUsage = { ...(output.usage ?? {}), visibleOutputChars: output.text.length, latencyMs: output.usage?.latencyMs ?? Math.max(0, Date.now() - startedAt), ...(output.usage?.uncachedInputTokens === undefined && output.usage?.inputTokens !== undefined && output.usage.cachedInputTokens !== undefined ? { uncachedInputTokens: Math.max(0, output.usage.inputTokens - output.usage.cachedInputTokens) } : {}) };
                 usage.set(attempt.attemptId, measuredUsage);
                 if (output.finishReason === 'length' && input.outputSchema !== undefined)
-                    throw Object.assign(new OutputValidationError('adapter', 'OUTPUT_TRUNCATED', 'Model output reached its token limit; increase maxOutputTokens before retrying.'), { retryable: false });
+                    throw Object.assign(new OutputValidationError('adapter', 'OUTPUT_TRUNCATED', 'Model output reached its token limit; incomplete output was rejected.', { outputTokens: output.usage?.outputTokens ?? null, reasoningTokens: output.usage?.reasoningTokens ?? null, visibleOutputChars: output.text.length, maxOutputTokens: routeRequirements.maxOutputTokens ?? config.requirements?.maxOutputTokens ?? null }), { retryable: false });
                 if (output.finishReason === 'refusal') {
                     recordFeedback('refused', 0);
                     throw new OutputValidationError('adapter', 'MODEL_REFUSAL', output.refusal ?? 'Provider refused the request.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-adapters",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/zhuhengtan/Pulse"
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "0.0.77",
-    "@hunterzhu/pulse-runtime": "0.2.1",
-    "@hunterzhu/pulse-tool-sdk": "0.2.1",
+    "@hunterzhu/pulse-runtime": "0.4.0",
+    "@hunterzhu/pulse-tool-sdk": "0.4.0",
     "exceljs": "4.4.0",
     "pdfjs-dist": "4.10.38"
   }