@bendyline/gezel-inference 0.0.0-stage → 0.1.0

package/dist/http/openai-compat/tool-call-stream-filter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Streaming-safe filter for textual tool-call envelopes emitted by local
+ * models while real tools are active.
+ *
+ * Some chat templates return both ordinary `content` deltas containing the
+ * serialized call and a structured tool call (or content which the provider
+ * promotes to one at end-of-turn). Once a content delta reaches an OpenAI
+ * client it cannot be retracted, so connected agent harnesses otherwise show
+ * the raw markup and then execute the same call in their normal tool UI.
+ *
+ * The filter is deliberately enabled only for requests that supplied tools.
+ * A tool-less request may legitimately ask the model to print these tags.
+ */
+export interface ToolCallStreamObserver {
+    onStart(): void;
+    onBodyDelta(chunk: string): void;
+    onEnd(): void;
+}
+export declare class ToolCallStreamFilter {
+    private readonly observer?;
+    private buffer;
+    private insideToolCall;
+    constructor(observer?: ToolCallStreamObserver | undefined);
+    /** Add one model-content delta and return the portion safe to expose. */
+    push(chunk: string): string;
+    /**
+     * Drain the final non-marker tail. An unclosed tool envelope is discarded:
+     * providers may still salvage its partial arguments into a structured call,
+     * and exposing it now would recreate the duplicate this filter prevents.
+     */
+    flush(): string;
+    private drain;
+}

package/dist/http/openai-compat/tool-call-stream-filter.js

@@ -0,0 +1,110 @@
+/**
+ * Streaming-safe filter for textual tool-call envelopes emitted by local
+ * models while real tools are active.
+ *
+ * Some chat templates return both ordinary `content` deltas containing the
+ * serialized call and a structured tool call (or content which the provider
+ * promotes to one at end-of-turn). Once a content delta reaches an OpenAI
+ * client it cannot be retracted, so connected agent harnesses otherwise show
+ * the raw markup and then execute the same call in their normal tool UI.
+ *
+ * The filter is deliberately enabled only for requests that supplied tools.
+ * A tool-less request may legitimately ask the model to print these tags.
+ */
+const OPEN_MARKERS = ['<|tool_call|>', '<|tool_call>', '<tool_call>'];
+const CLOSE_MARKERS = ['</tool_call|>', '<tool_call|>', '</tool_call>', '<tool_call>'];
+function earliestMarker(source, markers) {
+    const lower = source.toLowerCase();
+    let earliest = null;
+    for (const marker of markers) {
+        const index = lower.indexOf(marker);
+        if (index >= 0 && (earliest === null || index < earliest.index)) {
+            earliest = { index, length: marker.length };
+        }
+    }
+    return earliest;
+}
+/**
+ * Return the first index of a trailing fragment which could become one of the
+ * supplied markers when the next stream chunk arrives.
+ */
+function markerPrefixStart(source, markers) {
+    const lower = source.toLowerCase();
+    const longest = Math.max(...markers.map((marker) => marker.length));
+    const start = Math.max(0, lower.length - longest + 1);
+    for (let index = start; index < lower.length; index += 1) {
+        const tail = lower.slice(index);
+        if (markers.some((marker) => marker.startsWith(tail)))
+            return index;
+    }
+    return lower.length;
+}
+export class ToolCallStreamFilter {
+    observer;
+    buffer = '';
+    insideToolCall = false;
+    constructor(observer) {
+        this.observer = observer;
+    }
+    /** Add one model-content delta and return the portion safe to expose. */
+    push(chunk) {
+        this.buffer += chunk;
+        return this.drain();
+    }
+    /**
+     * Drain the final non-marker tail. An unclosed tool envelope is discarded:
+     * providers may still salvage its partial arguments into a structured call,
+     * and exposing it now would recreate the duplicate this filter prevents.
+     */
+    flush() {
+        if (this.insideToolCall) {
+            if (this.buffer)
+                this.observer?.onBodyDelta(this.buffer);
+            this.observer?.onEnd();
+            this.buffer = '';
+            this.insideToolCall = false;
+            return '';
+        }
+        const output = this.buffer;
+        this.buffer = '';
+        return output;
+    }
+    drain() {
+        let output = '';
+        while (this.buffer.length > 0) {
+            if (this.insideToolCall) {
+                const close = earliestMarker(this.buffer, CLOSE_MARKERS);
+                if (close) {
+                    const body = this.buffer.slice(0, close.index);
+                    if (body)
+                        this.observer?.onBodyDelta(body);
+                    this.buffer = this.buffer.slice(close.index + close.length);
+                    this.insideToolCall = false;
+                    this.observer?.onEnd();
+                    continue;
+                }
+                // Drop body bytes that cannot form the beginning of a split closing
+                // marker, retaining only the ambiguous suffix for the next chunk.
+                const holdback = markerPrefixStart(this.buffer, CLOSE_MARKERS);
+                const body = this.buffer.slice(0, holdback);
+                if (body)
+                    this.observer?.onBodyDelta(body);
+                this.buffer = this.buffer.slice(holdback);
+                return output;
+            }
+            const open = earliestMarker(this.buffer, OPEN_MARKERS);
+            if (open) {
+                output += this.buffer.slice(0, open.index);
+                this.buffer = this.buffer.slice(open.index + open.length);
+                this.insideToolCall = true;
+                this.observer?.onStart();
+                continue;
+            }
+            const holdback = markerPrefixStart(this.buffer, OPEN_MARKERS);
+            output += this.buffer.slice(0, holdback);
+            this.buffer = this.buffer.slice(holdback);
+            return output;
+        }
+        return output;
+    }
+}

package/dist/http/openai-compat/translate.d.ts

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import type { ImageAttachment, ProviderName } from '../../providers/types.js';
+export declare const ChatCompletionRequestSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        role: z.ZodLiteral<"system">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    auto: "auto";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"developer">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    auto: "auto";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    auto: "auto";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodDefault<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    auto: "auto";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>]>>>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"tool">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+                detail: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    auto: "auto";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>]>;
+        tool_call_id: z.ZodString;
+    }, z.core.$strip>], "role">>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    stream_options: z.ZodOptional<z.ZodObject<{
+        include_usage: z.ZodOptional<z.ZodBoolean>;
+        include_progress: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    presence_penalty: z.ZodOptional<z.ZodNumber>;
+    frequency_penalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    reasoning_effort: z.ZodOptional<z.ZodString>;
+    n: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        required: "required";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    response_format: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json_object">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json_schema">;
+        json_schema: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type ChatCompletionRequest = z.infer<typeof ChatCompletionRequestSchema>;
+export interface ResolvedModelTarget {
+    provider: ProviderName;
+    /**
+     * Provider-native model id. May be undefined when the caller passes
+     * a bare provider name (e.g. `"copilot"`) and the provider's own
+     * default model selection should kick in.
+     */
+    model: string | undefined;
+    /**
+     * The original user-facing string the caller supplied — used in the
+     * OpenAI response envelope so the model field round-trips unchanged.
+     */
+    echoModel: string;
+}
+/**
+ * Parse the `model` field into a `(provider, model)` pair. Forward-slash
+ * separators are also accepted (`"llama-cpp/qwen3-4b"`) since some
+ * OpenAI client libraries normalize colons.
+ *
+ * Returns `null` when the prefix is unknown. Each public surface then
+ * applies its own fallback policy (chat uses the fallback gezel;
+ * embeddings still returns `404 model_not_found`).
+ */
+/**
+ * Detect a `gezel:<reference>` model reference. Returns the bare ref
+ * (everything after the colon) when present, `null` otherwise. Callers
+ * route via {@link loadGezelTarget} when this matches; everything else
+ * falls through to {@link resolveModelTarget}.
+ *
+ * Why this exists: a gezel encapsulates a persona + tools + a preferred
+ * underlying model. `model: 'gezel:<role>-<name>'` lets callers (most notably
+ * the VS Code Language Model Chat Provider) route through the gezel
+ * without needing to know which raw provider it currently uses.
+ */
+export declare function parseGezelModelRef(modelField: string): string | null;
+export declare function resolveModelTarget(modelField: string): ResolvedModelTarget | null;
+export interface TranslatedSessionInput {
+    systemMessage: string;
+    prompt: string;
+    priorMessages: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    } | {
+        role: 'assistant';
+        content: string;
+        toolCalls: Array<{
+            id: string;
+            name: string;
+            arguments: string;
+        }>;
+    } | {
+        role: 'tool';
+        content: string;
+        toolCallId: string;
+    }>;
+    /**
+     * Image attachments extracted from the LAST message's `image_url`
+     * parts. Only the last message's images are surfaced because gezel's
+     * `SendAndWaitOpts.attachments` applies to the in-flight prompt, not
+     * to prior turns. Images on prior turns are silently dropped today;
+     * surfacing them would require a session-wide attachment buffer that
+     * no provider currently honors. Bare base64 (no data: prefix) — the
+     * provider-side formatters reshape this for each backend.
+     */
+    attachments: ImageAttachment[];
+}
+/**
+ * Variant of {@link translateMessages} that prepends an extra string
+ * (the gezel's `about.md` persona) to the system message. The prefix
+ * is separated by a blank line so the persona reads as a distinct
+ * block above whatever the caller supplied.
+ *
+ * Used by the `gezel:<id>` model target so the gezel's voice is
+ * honored regardless of what the OpenAI-shaped caller put in
+ * `messages[0]`.
+ */
+export declare function translateMessagesWithPrefix(messages: ChatCompletionRequest['messages'], systemPrefix: string): TranslatedSessionInput;
+/**
+ * Split an OpenAI `messages[]` array into the three pieces gezel's
+ * `LLMSession` consumes:
+ *
+ *   - `systemMessage` — concatenation of every system message, in
+ *     order. Gezel's `SessionOpts.systemMessage` is required (string),
+ *     so an empty messages-with-no-system request still works (we
+ *     default to `""`).
+ *   - `priorMessages` — every non-system message except the very last,
+ *     mapped 1:1 to `{role, content}`. These flow through to providers
+ *     that need explicit history (Ollama, llama.cpp, MLX, Anthropic CLI).
+ *   - `prompt` — the content of the last message, regardless of role.
+ *     OpenAI's contract is that the last message drives the new turn.
+ *
+ * Throws when the last message has no content — the route maps this
+ * to `400 empty_prompt`.
+ */
+export declare function translateMessages(messages: ChatCompletionRequest['messages']): TranslatedSessionInput;
+/**
+ * Fold `priorMessages` into the prompt text for providers that don't
+ * honor explicit history (`LLMProvider.supportsPriorMessages` unset —
+ * Copilot and the CLI providers, whose SDK/subprocess owns its own
+ * transcript). Without this, a stateless OpenAI-shaped caller replaying
+ * the full conversation each request would silently lose everything but
+ * the last message.
+ *
+ * The transcript is rendered as labeled turns above the in-flight
+ * prompt. Lossy by design — the provider sees the history as text, not
+ * as real turns — but honest history beats silent amnesia. Attachments
+ * are untouched (they already ride only on the in-flight prompt).
+ */
+export declare function flattenTranscriptIntoPrompt(input: TranslatedSessionInput): TranslatedSessionInput;