tekimax-ts 0.1.7 → 0.1.9

package/README.md

@@ -1,54 +1,130 @@
 <div align="center">
-  <img src="./public/logos/tekimax-logo-ScreenRGB-2.png" alt="Tekimax SDK Logo" width="200" />
-  <h1>TEKIMAX SDK Typescript</h1>
-  <p><strong>Type-safe Tekimax Client for Node.js, Browser, and Edge.</strong></p>
+  <img src="https://raw.githubusercontent.com/TEKIMAX/tekimax-ts/main/apps/docs/public/tekimax-logo.png" alt="Tekimax SDK Logo" width="200" />
+  <h1>Tekimax TS</h1>
+  <p><strong>Universal AI Adapter Layer.</strong></p>
+  <p>A type-safe, framework-agnostic AI SDK for building AI-powered apps.</p>
+
+[![npm version](https://img.shields.io/npm/v/tekimax-ts.svg)](https://www.npmjs.com/package/tekimax-ts)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-  [![npm version](https://img.shields.io/npm/v/tekimax-ts.svg)](https://www.npmjs.com/package/tekimax-ts)
-  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 </div>
 
 ## 📦 Installation
 
 ```bash
 npm install tekimax-ts
-```
+
+## 🌟 Features
+
+- **Universal API**: One interface for all providers. Switch from OpenAI to Ollama with a single config change.
+- **Type Safety**: End-to-end TypeScript support. Zod schemas for runtime validation.
+- **Zero Latency**: Lightweight adapter pattern with zero runtime overhead.
+- **Zero CVEs**: Hardened supply chain using Chainguard images.
+
+## 💻 Usage
 
 ## 💻 Usage
 
-The SDK provides a `TekimaxClient` that manages authentication, session state, and response parsing.
+### 1. Initialize the Client
+
+The `Tekimax` client is the unified entry point. It wraps any provider (OpenAI, Anthropic, Ollama, etc.) and exposes a consistent multi-modal interface.
+
+```typescript
+import { 
+  Tekimax, 
+  OpenAIProvider, 
+  AnthropicProvider, 
+  OllamaProvider,
+  GeminiProvider 
+} from 'tekimax-ts'
+
+// OpenAI
+const client = new Tekimax({
+    provider: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY })
+})
+
+// Anthropic
+const claude = new Tekimax({
+    provider: new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY })
+})
+
+// Ollama (Local)
+const local = new Tekimax({
+    provider: new OllamaProvider({ baseUrl: 'http://localhost:11434' })
+})
+```
+
+### 2. Multi-Modal Interfaces
+
+The client is organized into cohesive namespaces:
+
+#### Text (Chat)
 
 ```typescript
-import { TekimaxClient } from 'tekimax-ts';
+const response = await client.text.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: 'Hello!' }]
+})
+console.log(response.message.content)
+```
+
+#### Images (Generation & Vision)
 
-const client = new TekimaxClient({
-    apiKey: process.env.TEKIMAX_API_KEY
-});
+```typescript
+// Generate
+const image = await client.images.generate({
+    model: 'dall-e-3',
+    prompt: 'A cyberpunk city',
+    size: '1024x1024'
+})
+
+// Analyze (Vision)
+const analysis = await client.images.analyze({
+    model: 'gpt-4o',
+    image: 'https://example.com/image.png',
+    prompt: 'Describe this scene'
+})
+```
 
-// Simple message
-const response = await client.sendMessage("Explain quantum computing");
-console.log(response.text);
+#### Audio (TTS)
 
-// Continuing a session (preserves context)
-const followUp = await client.sendMessage("How does it relate to encryption?", {
-    previous_response_id: response.id
-});
-console.log(followUp.text);
+```typescript
+const audio = await client.audio.speak({
+    model: 'tts-1',
+    input: 'Hello world',
+    voice: 'alloy'
+})
 ```
 
-## 🧠 Motivation and Overview
+#### Video (Analysis)
 
-Modern LLM systems have converged on similar primitives—messages, function calls, tool usage, and multimodal inputs—but each provider encodes them differently. **Tekimax** standardizes these concepts, enabling:
+```typescript
+const analysis = await client.videos.analyze({
+    model: 'gemini-1.5-flash',
+    video: 'https://example.com/video.mp4',
+    prompt: 'Summarize this clip'
+})
+```
 
-*   **One spec, many providers**: Describe inputs/outputs once; run on OpenAI, Anthropic, Gemini, or local models.
-*   **Composable agentic loops**: Unified streaming, tool invocation, and message orchestration.
-*   **Easier evaluation and routing**: Compare providers, route requests, and log results through a shared schema.
-*   **Blueprints for provider APIs**: Labs and model providers wanting to expose their APIs in a common format can easily do so.
+## 📚 Documentation
+
+For full documentation, guides, and API references, visit **[docs.tekimax.com](https://docs.tekimax.com)**.
+
+## 🧠 Motivation
+
+
+Modern LLM systems have converged on similar primitives: messages, function calls, tool usage, and multimodal inputs but each provider encodes them differently. **Tekimax** standardizes these concepts, enabling:
+
+- **One spec, many providers**: Describe inputs/outputs once; run on OpenAI, Anthropic, Gemini, or local models.
+- **Composable agentic loops**: Unified streaming, tool invocation, and message orchestration.
+- **Easier evaluation and routing**: Compare providers, route requests, and log results through a shared schema.
+- **Blueprints for provider APIs**: Labs and model providers wanting to expose their APIs in a common format can easily do so.
 
 ## 🔑 Key Principles
 
 ### Agentic Loop
 
-All models, to some extent, exhibit agency — the ability to perceive input, reason, act through tools, and reflect on outcomes.
+All models, to some extent, exhibit agency: the ability to perceive input, reason, act through tools, and reflect on outcomes.
 
 The **Tekimax Standard** at its core is designed to expose the power of this agentic loop to developers, making requests that allow the model to do multiple things and yield back a result, whether this is developer-hosted tool calls where control is yielded back to the user, or provider-hosted tools where control is held by the model provider until the model signals an exit criteria.
 
@@ -66,10 +142,47 @@ Tekimax defines a common set of items supported by a quorum of model providers,
 
 Streaming is modeled as a series of semantic events, not raw text or object deltas.
 
-Events describe meaningful transitions. They are either state transitions–`response.in_progress`, `response.completed`–or they can represent a delta from a previous state–`response.output_item.added`, `response.output_text.delta`.
+Events describe meaningful transitions. They are either state transitions (e.g., `response.in_progress`, `response.completed`) or they can represent a delta from a previous state (e.g., `response.output_item.added`, `response.output_text.delta`).
 
 Tekimax defines a common set of streaming events supported by a quorum of model providers, and defines how provider-specific streaming events can be defined.
 
 ### State Machines
 
 Objects in Tekimax are state machines, that is, they can live in one of a finite number of states, such as `in_progress`, `completed`, or `failed`. The spec defines the set of valid states for each state machine in the API.
+
+## 🛡️ Security & Trust
+
+At **Tekimax**, we believe security is a feature, not an afterthought.
+
+- **Zero Vulnerabilities**: We enforce a strict **Zero CVE** policy. Our SDK is audited daily.
+- **Minimal Surface Area**: By optimizing our dependency tree, we identified and **removed 159 unnecessary packages**, drastically reducing the attack surface.
+- **Secured by Chainguard**: Our build pipeline and artifacts rely on [Chainguard Images](https://www.chainguard.dev/chainguard-images)—hardened, minimal container images designed to secure the software supply chain. Chainguard images are stripped of shells, package managers, and other unnecessary tools that attackers often exploit.
+
+Supply chain attacks on the Node.js/npm ecosystem are increasingly common. By building on Chainguard, we ensure that the Tekimax SDK meets the highest standards of integrity and safety for enterprise and production use.
+
+## Get Involved
+
+- We welcome issues and pull requests!
+- Participate in **GitHub Discussions**.
+- See [CONTRIBUTING.md](./CONTRIBUTING.md) for setup instructions.
+
+## Partners
+
+We're looking for Tekimax Partners to join our mission! Partner with us to push the boundaries of Tekimax and build amazing things together.
+
+[LET'S CHAT](mailto:info@tekimax.com?subject=Tekimax%20Partnership)
+
+## Code of Conduct
+
+## Please note that this project is released with a [Contributor Code of Conduct](./CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+
+<div align="center">
+  <p>
+    <strong>Secured by <a href="https://www.chainguard.dev">Chainguard</a></strong><br>
+    Zero-CVE Images for a Safe Supply Chain
+  </p>
+  <p>
+    Built on the <a href="https://openresponses.org">OpenResponses Standard</a> • Generated with <a href="https://kubb.dev">Kubb</a>
+  </p>
+  <sub>Built with ❤️ by the Tekimax Team</sub>
+</div>

package/dist/adapter-BtbeHotF.d.cts

@@ -0,0 +1,81 @@
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface Tool<T = any> extends ToolDefinition {
+    execute: (args: T) => Promise<unknown>;
+}
+interface GenerateTextResult {
+    text: string;
+    toolCalls: Array<ToolCall>;
+    toolResults: Array<{
+        id: string;
+        result: unknown;
+    }>;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'error' | 'unknown';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    warnings?: Array<string>;
+}
+interface Message {
+    role: MessageRole;
+    content: string | null;
+    toolCalls?: Array<ToolCall>;
+    toolCallId?: string;
+    name?: string;
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<Message>;
+    tools?: Array<ToolDefinition>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface ChatResult {
+    message: Message;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface StreamChunk {
+    delta: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+
+interface TekimaxAdapter {
+    name: string;
+    /**
+     * Send a chat completion request.
+     */
+    chat: (options: ChatOptions) => Promise<ChatResult>;
+    /**
+     * Stream a chat completion.
+     */
+    chatStream: (options: ChatOptions) => AsyncIterable<StreamChunk>;
+}
+
+export type { ChatOptions as C, GenerateTextResult as G, Message as M, StreamChunk as S, TekimaxAdapter as T, ChatResult as a, Tool as b, MessageRole as c, ToolCall as d, ToolDefinition as e };

package/dist/adapter-BtbeHotF.d.ts

@@ -0,0 +1,81 @@
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface Tool<T = any> extends ToolDefinition {
+    execute: (args: T) => Promise<unknown>;
+}
+interface GenerateTextResult {
+    text: string;
+    toolCalls: Array<ToolCall>;
+    toolResults: Array<{
+        id: string;
+        result: unknown;
+    }>;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'error' | 'unknown';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    warnings?: Array<string>;
+}
+interface Message {
+    role: MessageRole;
+    content: string | null;
+    toolCalls?: Array<ToolCall>;
+    toolCallId?: string;
+    name?: string;
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<Message>;
+    tools?: Array<ToolDefinition>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface ChatResult {
+    message: Message;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface StreamChunk {
+    delta: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+
+interface TekimaxAdapter {
+    name: string;
+    /**
+     * Send a chat completion request.
+     */
+    chat: (options: ChatOptions) => Promise<ChatResult>;
+    /**
+     * Stream a chat completion.
+     */
+    chatStream: (options: ChatOptions) => AsyncIterable<StreamChunk>;
+}
+
+export type { ChatOptions as C, GenerateTextResult as G, Message as M, StreamChunk as S, TekimaxAdapter as T, ChatResult as a, Tool as b, MessageRole as c, ToolCall as d, ToolDefinition as e };

package/dist/adapter-C5iFgx6o.d.cts

@@ -0,0 +1,162 @@
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface Tool<T = any> extends ToolDefinition {
+    execute: (args: T) => Promise<unknown>;
+}
+interface GenerateTextResult {
+    text: string;
+    toolCalls: Array<ToolCall>;
+    toolResults: Array<{
+        id: string;
+        result: unknown;
+    }>;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'error' | 'unknown';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    warnings?: Array<string>;
+}
+interface Message {
+    role: MessageRole;
+    content: string | null;
+    toolCalls?: Array<ToolCall>;
+    toolCallId?: string;
+    name?: string;
+}
+interface ImageGenerationOptions {
+    prompt: string;
+    model?: string;
+    n?: number;
+    size?: string;
+    quality?: string;
+    style?: string;
+    response_format?: 'url' | 'b64_json';
+    user?: string;
+}
+interface ImageEditOptions extends ImageGenerationOptions {
+    image: string | Blob | Buffer;
+    mask?: string | Blob | Buffer;
+}
+interface ImageContent {
+    url?: string;
+    b64_json?: string;
+    revised_prompt?: string;
+}
+interface ImageResult {
+    created: number;
+    data: ImageContent[];
+}
+interface SpeechGenerationOptions {
+    input: string;
+    model?: string;
+    voice: string;
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    speed?: number;
+}
+interface SpeechResult {
+    buffer: ArrayBuffer;
+    headers?: Record<string, string>;
+}
+interface VideoGenerationOptions {
+    prompt: string;
+    model?: string;
+    aspect_ratio?: string;
+    duration_seconds?: number;
+}
+interface VideoContent {
+    url?: string;
+    b64_json?: string;
+}
+interface VideoResult {
+    data: VideoContent[];
+}
+interface VideoAnalysisOptions {
+    video: string | Blob | Buffer;
+    prompt?: string;
+    model: string;
+    messages?: Array<Message>;
+}
+interface VideoAnalysisResult {
+    content: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<Message>;
+    tools?: Array<ToolDefinition>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface ChatResult {
+    message: Message;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface StreamChunk {
+    delta: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+
+interface AIProvider {
+    name: string;
+    /**
+     * Send a chat completion request.
+     */
+    chat: (options: ChatOptions) => Promise<ChatResult>;
+    /**
+     * Stream a chat completion.
+     */
+    chatStream: (options: ChatOptions) => AsyncIterable<StreamChunk>;
+    /**
+     * Generate an image.
+     */
+    generateImage?: (options: ImageGenerationOptions) => Promise<ImageResult>;
+    /**
+     * Edit an image.
+     */
+    editImage?: (options: ImageEditOptions) => Promise<ImageResult>;
+    /**
+     * Generate speech from text (TTS).
+     */
+    generateSpeech?: (options: SpeechGenerationOptions) => Promise<SpeechResult>;
+    /**
+     * Generate a video.
+     */
+    generateVideo?: (options: VideoGenerationOptions) => Promise<VideoResult>;
+    /**
+     * Analyze a video (Video-to-Text).
+     */
+    analyzeVideo?: (options: VideoAnalysisOptions) => Promise<VideoAnalysisResult>;
+}
+
+export type { AIProvider as A, ChatOptions as C, GenerateTextResult as G, ImageGenerationOptions as I, Message as M, StreamChunk as S, Tool as T, VideoGenerationOptions as V, ChatResult as a, ImageResult as b, ImageEditOptions as c, SpeechGenerationOptions as d, SpeechResult as e, VideoResult as f, VideoAnalysisOptions as g, VideoAnalysisResult as h, ImageContent as i, MessageRole as j, ToolCall as k, ToolDefinition as l, VideoContent as m };

package/dist/adapter-C5iFgx6o.d.ts

@@ -0,0 +1,162 @@
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface Tool<T = any> extends ToolDefinition {
+    execute: (args: T) => Promise<unknown>;
+}
+interface GenerateTextResult {
+    text: string;
+    toolCalls: Array<ToolCall>;
+    toolResults: Array<{
+        id: string;
+        result: unknown;
+    }>;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'error' | 'unknown';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    warnings?: Array<string>;
+}
+interface Message {
+    role: MessageRole;
+    content: string | null;
+    toolCalls?: Array<ToolCall>;
+    toolCallId?: string;
+    name?: string;
+}
+interface ImageGenerationOptions {
+    prompt: string;
+    model?: string;
+    n?: number;
+    size?: string;
+    quality?: string;
+    style?: string;
+    response_format?: 'url' | 'b64_json';
+    user?: string;
+}
+interface ImageEditOptions extends ImageGenerationOptions {
+    image: string | Blob | Buffer;
+    mask?: string | Blob | Buffer;
+}
+interface ImageContent {
+    url?: string;
+    b64_json?: string;
+    revised_prompt?: string;
+}
+interface ImageResult {
+    created: number;
+    data: ImageContent[];
+}
+interface SpeechGenerationOptions {
+    input: string;
+    model?: string;
+    voice: string;
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    speed?: number;
+}
+interface SpeechResult {
+    buffer: ArrayBuffer;
+    headers?: Record<string, string>;
+}
+interface VideoGenerationOptions {
+    prompt: string;
+    model?: string;
+    aspect_ratio?: string;
+    duration_seconds?: number;
+}
+interface VideoContent {
+    url?: string;
+    b64_json?: string;
+}
+interface VideoResult {
+    data: VideoContent[];
+}
+interface VideoAnalysisOptions {
+    video: string | Blob | Buffer;
+    prompt?: string;
+    model: string;
+    messages?: Array<Message>;
+}
+interface VideoAnalysisResult {
+    content: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<Message>;
+    tools?: Array<ToolDefinition>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface ChatResult {
+    message: Message;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface StreamChunk {
+    delta: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+
+interface AIProvider {
+    name: string;
+    /**
+     * Send a chat completion request.
+     */
+    chat: (options: ChatOptions) => Promise<ChatResult>;
+    /**
+     * Stream a chat completion.
+     */
+    chatStream: (options: ChatOptions) => AsyncIterable<StreamChunk>;
+    /**
+     * Generate an image.
+     */
+    generateImage?: (options: ImageGenerationOptions) => Promise<ImageResult>;
+    /**
+     * Edit an image.
+     */
+    editImage?: (options: ImageEditOptions) => Promise<ImageResult>;
+    /**
+     * Generate speech from text (TTS).
+     */
+    generateSpeech?: (options: SpeechGenerationOptions) => Promise<SpeechResult>;
+    /**
+     * Generate a video.
+     */
+    generateVideo?: (options: VideoGenerationOptions) => Promise<VideoResult>;
+    /**
+     * Analyze a video (Video-to-Text).
+     */
+    analyzeVideo?: (options: VideoAnalysisOptions) => Promise<VideoAnalysisResult>;
+}
+
+export type { AIProvider as A, ChatOptions as C, GenerateTextResult as G, ImageGenerationOptions as I, Message as M, StreamChunk as S, Tool as T, VideoGenerationOptions as V, ChatResult as a, ImageResult as b, ImageEditOptions as c, SpeechGenerationOptions as d, SpeechResult as e, VideoResult as f, VideoAnalysisOptions as g, VideoAnalysisResult as h, ImageContent as i, MessageRole as j, ToolCall as k, ToolDefinition as l, VideoContent as m };