@omnicross/core 0.1.0

package/dist/transformer/transformers/OpenCodeGoTransformer.js

@@ -0,0 +1,48 @@
+// src/transformer/transformers/OpenCodeGoTransformer.ts
+var OpenCodeGoTransformer = class {
+  static TransformerName = "opencodego";
+  name = "opencodego";
+  endPoint = "/v1/chat/completions";
+  logger;
+  async auth(request, _provider, _context) {
+    return { body: request, config: { headers: {} } };
+  }
+  /**
+   * Unified → OpenAI Chat Completions.
+   * Unified IS chat completions shape; this is mostly stripping `meta` and
+   * normalizing string-content single-block messages.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const messages = request.messages.map((m) => {
+      const content = m.content;
+      if (Array.isArray(content) && content.length === 1 && content[0]?.type === "text") {
+        return { ...m, content: content[0].text };
+      }
+      return m;
+    });
+    const out = {
+      model: request.model,
+      messages,
+      stream: request.stream
+    };
+    if (request.temperature !== void 0) out.temperature = request.temperature;
+    if (request.max_tokens !== void 0) out.max_tokens = request.max_tokens;
+    if (request.tools && request.tools.length > 0) out.tools = request.tools;
+    if (request.tool_choice !== void 0) out.tool_choice = request.tool_choice;
+    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
+      out.reasoning_effort = request.reasoning.effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions response → Unified.
+   * The upstream's response shape already matches Unified — pass through.
+   * The endpoint AnthropicTransformer re-encodes to Anthropic for the SDK.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+};
+export {
+  OpenCodeGoTransformer
+};

package/dist/transformer/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transformer/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/transformer/types.d.cts

@@ -0,0 +1,405 @@
+/**
+ * TransformerService Types
+ *
+ * Type definitions for the Transformer system, providing unified
+ * request/response formats and transformer chain configuration.
+ *
+ * @module transformer/types
+ */
+/**
+ * Thinking effort level for reasoning models
+ */
+type ThinkLevel = 'none' | 'low' | 'medium' | 'high';
+/**
+ * Thinking content with optional signature for extended context
+ */
+interface ThinkingContent {
+    content: string;
+    signature?: string;
+}
+/**
+ * Reasoning configuration for request
+ */
+interface ReasoningConfig {
+    /** OpenAI-style effort level */
+    effort?: ThinkLevel;
+    /** Anthropic-style max tokens for thinking */
+    max_tokens?: number;
+    /** Whether reasoning is enabled */
+    enabled?: boolean;
+}
+/**
+ * Text content block
+ */
+interface TextContent {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type?: string;
+    };
+}
+/**
+ * Image content block
+ */
+interface ImageContent {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+    media_type?: string;
+}
+/**
+ * Union of all content types
+ */
+type MessageContent = TextContent | ImageContent;
+/**
+ * Tool call definition
+ */
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Unified message format that works across all providers
+ */
+interface UnifiedMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string | null | MessageContent[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    cache_control?: {
+        type?: string;
+    };
+    thinking?: ThinkingContent;
+}
+/**
+ * Tool parameter schema
+ */
+interface ToolParameterSchema {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean;
+    $schema?: string;
+}
+/**
+ * Unified tool definition
+ */
+interface UnifiedTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: ToolParameterSchema;
+    };
+}
+/**
+ * Tool choice configuration
+ */
+type ToolChoice = 'auto' | 'none' | 'required' | string | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+/**
+ * Unified chat request format
+ */
+interface UnifiedChatRequest {
+    messages: UnifiedMessage[];
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: UnifiedTool[];
+    tool_choice?: ToolChoice;
+    reasoning?: ReasoningConfig;
+    /**
+     * Internal-only routing metadata. Populated by callers (CompletionService /
+     * the host's engine adapters and proxy servers) so the usage-capture hook can attribute
+     * the recorded event to a chat message, session, engine origin, and api key.
+     *
+     * **Must not be serialised into the outbound HTTP body.** The transformer chain
+     * passes this object alongside the request internally; transformers that build
+     * provider request payloads must drop `meta` from their output.
+     */
+    meta?: UnifiedChatRequestMeta;
+}
+/**
+ * Routing metadata threaded through the transformer chain so the usage-capture
+ * hook can identify which chat message / session / api key produced the call.
+ * See `UnifiedChatRequest.meta`.
+ */
+interface UnifiedChatRequestMeta {
+    /** Host message id of the assistant message being produced, when known. */
+    messageId?: string | null;
+    /** Parent assistant message id (for subagent dispatches that have a parent). */
+    parentMessageId?: string | null;
+    /** Host session id, when applicable. */
+    sessionId?: string | null;
+    /** Which engine path is making the call. See `UsageEngineOrigin`. */
+    engineOrigin?: 'completion' | 'claude-sdk' | 'claude-sdk-direct' | 'codex-ingress' | (string & {});
+    /** The api-key-pool entry id selected for this request. */
+    apiKeyId?: string | null;
+}
+/**
+ * URL citation annotation
+ */
+interface UrlCitation {
+    url: string;
+    title: string;
+    content: string;
+    start_index: number;
+    end_index: number;
+}
+/**
+ * Response annotation
+ */
+interface Annotation {
+    type: 'url_citation';
+    url_citation?: UrlCitation;
+}
+/**
+ * Unified chat response format
+ */
+interface UnifiedChatResponse {
+    id: string;
+    model: string;
+    content: string | null;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        /**
+         * Anthropic prompt-cache hit count. Optional — providers without prompt
+         * caching omit it. Counted from the response's raw usage block by the
+         * provider's transformer.
+         */
+        cache_read_input_tokens?: number;
+        /** Anthropic prompt-cache write count. Optional, see `cache_read_input_tokens`. */
+        cache_creation_input_tokens?: number;
+        /** OpenAI o1 / Anthropic extended-thinking — already part of completion_tokens by some providers. */
+        reasoning_tokens?: number;
+    };
+    tool_calls?: ToolCall[];
+    annotations?: Annotation[];
+}
+/**
+ * Stream chunk format
+ */
+interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices?: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            thinking?: {
+                content?: string;
+                signature?: string;
+            };
+            tool_calls?: Array<{
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+                index?: number;
+            }>;
+            annotations?: Annotation[];
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        completion_tokens?: number;
+        prompt_tokens?: number;
+        total_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+        output_tokens_details?: {
+            reasoning_tokens?: number;
+        };
+    };
+}
+/**
+ * LLM Provider configuration (runtime format)
+ */
+interface LLMProvider {
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    models: string[];
+    transformer?: TransformerChainConfig;
+    /**
+     * Resolved Google **Code Assist** project id, threaded onto the transformer
+     * provider object by the subscription dispatch seam (SubscriptionDispatcher /
+     * openaiResponsesIngress) so `GeminiCodeAssistTransformer.transformRequestIn`
+     * can embed it in the top-level envelope. `undefined` is the valid fresh
+     * free-tier value (sending a project on free/legacy-tier → Precondition
+     * Failed). Only ever set for the gemini subscription profile; inert otherwise.
+     */
+    geminiProject?: string;
+}
+/**
+ * Model route information
+ */
+interface ModelRoute {
+    provider: string;
+    model: string;
+    fullModel: string;
+}
+/**
+ * Request routing information
+ */
+interface RequestRouteInfo {
+    provider: LLMProvider;
+    originalModel: string;
+    targetModel: string;
+}
+/**
+ * Transformer options passed during instantiation
+ */
+interface TransformerOptions {
+    [key: string]: unknown;
+}
+/**
+ * Context passed through transformer chain
+ */
+interface TransformerContext {
+    /** Original request object */
+    req?: unknown;
+    /** Logger instance */
+    logger?: TransformerLogger;
+    /** Provider name */
+    providerName?: string;
+    /** Additional context data */
+    [key: string]: unknown;
+}
+/**
+ * Logger interface for transformers
+ */
+interface TransformerLogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Transformer interface - defines the contract for all transformers
+ */
+interface Transformer {
+    /** Unique name for the transformer */
+    name?: string;
+    /** API endpoint path (e.g., '/v1/chat/completions') */
+    endPoint?: string;
+    /** Logger instance */
+    logger?: TransformerLogger;
+    /**
+     * Transform incoming request (provider-specific → unified format)
+     * Called when request enters the transformer chain
+     */
+    transformRequestIn?: (request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, unknown>>;
+    /**
+     * Transform outgoing request (unified → provider-specific format)
+     * Called before sending to LLM provider
+     */
+    transformRequestOut?: (request: unknown, context: TransformerContext) => Promise<UnifiedChatRequest>;
+    /**
+     * Transform incoming response (provider-specific → unified format)
+     * Called after receiving response from provider
+     */
+    transformResponseIn?: (response: Response, context?: TransformerContext) => Promise<Response>;
+    /**
+     * Transform outgoing response (unified → client format)
+     * Called before returning response to client
+     */
+    transformResponseOut?: (response: Response, context: TransformerContext) => Promise<Response>;
+    /**
+     * Handle authentication for the request
+     */
+    auth?: (request: unknown, provider: LLMProvider, context: TransformerContext) => Promise<unknown>;
+}
+/**
+ * Transformer constructor interface
+ */
+interface TransformerConstructor {
+    new (options?: TransformerOptions): Transformer;
+    TransformerName?: string;
+}
+/**
+ * Individual transformer reference in chain
+ * Can be a string name or [name, options] tuple
+ */
+type TransformerReference = string | [string, TransformerOptions];
+/**
+ * Model-specific transformer configuration
+ */
+interface ModelTransformerConfig {
+    use?: TransformerReference[];
+}
+/**
+ * Transformer chain configuration for a provider
+ */
+interface TransformerChainConfig {
+    /** Provider-level transformers applied to all models */
+    use?: TransformerReference[];
+    /** Model-specific transformer overrides */
+    [modelName: string]: ModelTransformerConfig | TransformerReference[] | undefined;
+}
+/**
+ * Resolved transformer chain (instances ready to execute)
+ */
+interface ResolvedTransformerChain {
+    /** Provider-level transformer instances */
+    providerTransformers: Transformer[];
+    /** Model-specific transformer instances */
+    modelTransformers: Transformer[];
+}
+/**
+ * Result of request transformation
+ */
+interface TransformRequestResult {
+    /** Transformed request body */
+    requestBody: unknown;
+    /** Additional request configuration */
+    config: RequestConfig;
+    /** Whether to bypass further transformations */
+    bypass: boolean;
+}
+/**
+ * Request configuration for HTTP call
+ */
+interface RequestConfig {
+    /** Request URL */
+    url?: URL | string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Additional fetch options */
+    [key: string]: unknown;
+}
+/**
+ * Transformer registration from configuration
+ */
+interface TransformerConfigEntry {
+    name: string;
+    type?: 'class' | 'module';
+    path?: string;
+    options?: TransformerOptions;
+}
+/**
+ * Service configuration
+ */
+interface TransformerServiceConfig {
+    transformers?: TransformerConfigEntry[];
+}
+
+export type { Annotation, ImageContent, LLMProvider, MessageContent, ModelRoute, ModelTransformerConfig, ReasoningConfig, RequestConfig, RequestRouteInfo, ResolvedTransformerChain, StreamChunk, TextContent, ThinkLevel, ThinkingContent, ToolCall, ToolChoice, ToolParameterSchema, TransformRequestResult, Transformer, TransformerChainConfig, TransformerConfigEntry, TransformerConstructor, TransformerContext, TransformerLogger, TransformerOptions, TransformerReference, TransformerServiceConfig, UnifiedChatRequest, UnifiedChatRequestMeta, UnifiedChatResponse, UnifiedMessage, UnifiedTool, UrlCitation };