@animalabs/membrane 0.5.55 → 0.5.64

package/src/providers/openai-completions.ts

@@ -41,6 +41,7 @@ interface CompletionsRequest {
   top_p?: number;
   presence_penalty?: number;
   frequency_penalty?: number;
+  repetition_penalty?: number;
   stop?: string[];
   stream?: boolean;
 }
@@ -194,6 +195,19 @@ export class OpenAICompletionsAdapter implements ProviderAdapter {
       let accumulated = '';
       let finishReason = 'stop';
 
+      // Post-facto truncation of the adapter's own eotToken.
+      // The adapter serializes the prompt with this.eotToken and sends it as an
+      // API stop string, but some backends leak the stop string into streamed
+      // output. Since the bot-level formatter may use a different (or empty)
+      // turn-end token, downstream post-facto checks can't be relied on to
+      // catch it — the layer that introduced the token must truncate it.
+      // emittedLen tracks how much of `accumulated` has been emitted; a tail of
+      // eot.length-1 chars is held back in case the token is split across chunks.
+      const eot = this.eotToken;
+      let emittedLen = 0;
+      let eotFound = false;
+
+      streamLoop:
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
@@ -210,7 +224,28 @@ export class OpenAICompletionsAdapter implements ProviderAdapter {
 
             if (text) {
               accumulated += text;
-              callbacks.onChunk(text);
+              if (eot) {
+                const idx = accumulated.indexOf(eot);
+                if (idx !== -1) {
+                  // Truncate at the token, flush the un-emitted prefix, stop
+                  accumulated = accumulated.slice(0, idx);
+                  if (accumulated.length > emittedLen) {
+                    callbacks.onChunk(accumulated.slice(emittedLen));
+                  }
+                  emittedLen = accumulated.length;
+                  eotFound = true;
+                  finishReason = 'stop';
+                  break streamLoop;
+                }
+                // Emit all but a held-back tail that could be a partial token
+                const safeLen = Math.max(emittedLen, accumulated.length - (eot.length - 1));
+                if (safeLen > emittedLen) {
+                  callbacks.onChunk(accumulated.slice(emittedLen, safeLen));
+                  emittedLen = safeLen;
+                }
+              } else {
+                callbacks.onChunk(text);
+              }
             }
 
             if (parsed.choices?.[0]?.finish_reason) {
@@ -222,6 +257,14 @@ export class OpenAICompletionsAdapter implements ProviderAdapter {
         }
       }
 
+      // Flush any held-back tail if the token never completed
+      if (eot && !eotFound && accumulated.length > emittedLen) {
+        callbacks.onChunk(accumulated.slice(emittedLen));
+      }
+      if (eotFound) {
+        try { await reader.cancel(); } catch { /* stream already closed */ }
+      }
+
       return this.buildStreamedResponse(accumulated, finishReason, request.model, completionsRequest);
 
     } catch (error) {
@@ -383,6 +426,10 @@ export class OpenAICompletionsAdapter implements ProviderAdapter {
       params.frequency_penalty = request.frequencyPenalty;
     }
 
+    if (request.repetitionPenalty !== undefined) {
+      params.repetition_penalty = request.repetitionPenalty;
+    }
+
     if (stopSequences.length > 0) {
       params.stop = stopSequences;
     }
@@ -419,7 +466,16 @@ export class OpenAICompletionsAdapter implements ProviderAdapter {
 
   private parseResponse(response: CompletionsResponse, requestedModel: string, rawRequest: unknown): ProviderResponse {
     const choice = response.choices[0];
-    const text = choice?.text ?? '';
+    let text = choice?.text ?? '';
+
+    // Post-facto truncation of the adapter's own eotToken — some backends
+    // leak the stop string into the output (see stream() for details)
+    if (this.eotToken) {
+      const idx = text.indexOf(this.eotToken);
+      if (idx !== -1) {
+        text = text.slice(0, idx);
+      }
+    }
 
     return {
       content: this.textToContent(text),

package/src/providers/openai.ts

@@ -399,6 +399,10 @@ export class OpenAIAdapter implements ProviderAdapter {
       params.frequency_penalty = request.frequencyPenalty;
     }
 
+    if (request.repetitionPenalty !== undefined) {
+      params.repetition_penalty = request.repetitionPenalty;
+    }
+
     // Reasoning models (o1, o3, o4) don't support stop sequences
     // OpenAI limits stop sequences to 4 — truncate to fit
     if (request.stopSequences && request.stopSequences.length > 0 && !noStopSupport(model)) {

package/src/types/content.ts

@@ -113,6 +113,12 @@ export interface ThinkingContent {
 
 export interface RedactedThinkingContent {
   type: 'redacted_thinking';
+  /**
+   * Encrypted reasoning payload from the provider. Opaque — must be
+   * round-tripped verbatim in assistant turns or the block is worthless
+   * (the API decrypts it to reconstruct prior reasoning).
+   */
+  data: string;
 }
 
 // ============================================================================

package/src/types/provider.ts

@@ -215,6 +215,9 @@ export interface ProviderRequest {
   /** Frequency penalty */
   frequencyPenalty?: number;
 
+  /** Repetition penalty (multiplicative, vLLM/HuggingFace style) */
+  repetitionPenalty?: number;
+
   /** Stop sequences */
   stopSequences?: string[];
   
@@ -232,6 +235,13 @@ export interface ProviderRequestOptions {
   idleTimeoutMs?: number;
   /** Called with the raw API request body right before fetch */
   onRequest?: (rawRequest: unknown) => void;
+  /**
+   * Wrap native thinking deltas in <thinking>...</thinking> tags on the
+   * onChunk stream. Used by the XML formatter path so its tag-based parser
+   * tracks thinking blocks; without this, native thinking content streams
+   * indistinguishably from visible text.
+   */
+  wrapThinkingTags?: boolean;
 }
 
 export interface ProviderResponse {

package/src/types/request.ts

@@ -30,11 +30,22 @@ export interface GenerationConfig {
   
   /** Frequency penalty (provider-specific) */
   frequencyPenalty?: number;
-  
+
+  /** Repetition penalty — multiplicative (vLLM/HuggingFace style, typically 1.0-1.2) */
+  repetitionPenalty?: number;
+
   /** Enable thinking/reasoning mode */
   thinking?: {
     enabled: boolean;
     budgetTokens?: number;
+    /** Thinking type for the API: 'enabled' (default, explicit budget) or 'adaptive' (model-managed) */
+    type?: 'enabled' | 'adaptive';
+    /**
+     * Controls how thinking content is returned: 'summarized' (readable summary)
+     * or 'omitted' (empty thinking field, signature only). Models like Fable 5 /
+     * Opus 4.7+ default to 'omitted' — set 'summarized' to receive thinking text.
+     */
+    display?: 'summarized' | 'omitted';
   };
   
   /** Image generation config (Gemini) */

package/src/types/tools.ts

@@ -59,18 +59,28 @@ export type ToolResultContentBlock =
 export interface ToolContext {
   /** The raw text that contained the tool calls */
   rawText: string;
-  
+
   /** Text before the tool calls (already streamed to user) */
   preamble: string;
-  
+
   /** Current depth in tool execution loop */
   depth: number;
-  
+
   /** Previous tool results in this execution chain */
   previousResults: ToolResult[];
-  
+
   /** Accumulated output so far */
   accumulated: string;
+
+  /**
+   * Normalized content blocks of the current assistant round, in provider
+   * order (thinking / redacted_thinking / text / tool_use). Present on the
+   * native-tools yielding path. Consumers persisting the assistant turn
+   * should use these verbatim instead of rebuilding from `preamble` +
+   * `calls` — signed thinking blocks must precede their tool_use in the
+   * same turn or the next request fails API validation.
+   */
+  roundContent?: import('./content.js').ContentBlock[];
 }
 
 // ============================================================================