tekimax-ts 0.1.6 → 0.1.8

package/README.md

@@ -1,22 +1,12 @@
 <div align="center">
-  <img src="./public/logos/tekimax-logo-ScreenRGB-2.png" alt="Tekimax SDK Logo" width="200" />
-  <h1>Tekimax TypeScript SDK</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>A type-safe, framework-agnostic AI SDK for building AI-powered apps.</strong></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)
-</div>
-
-## 📖 Overview
-
-The **Tekimax TypeScript SDK** provides fully typed interfaces for the Tekimax API. Generated via [Kubb](https://kubb.dev/), it ensures your application stays in sync with the latest API definitions.
+[![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)
 
-## ✨ Features
-
-- **Full TypeScript Support**: strict typing for all API request/response bodies.
-- **Runtime Validation**: Optional Zod schemas for validating data at runtime.
-- **Universal**: Works in Node.js, React/Vite/Next.js, and Cloudflare Workers.
-- **Tree-Shakeable**: Import only what you need.
+</div>
 
 ## 📦 Installation
 
@@ -26,117 +16,147 @@ npm install tekimax-ts
 
 ## 💻 Usage
 
-### Importing Types
+### 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 { 
-  UserMessageItemParam, 
-  CreateResponseBody 
-} from 'tekimax-ts';
-
-// Strongly typed message object
-const userMessage: UserMessageItemParam = {
-  type: 'message',
-  role: 'user',
-  content: [
-    {
-      type: 'input_text',
-      text: 'Explain quantum computing'
-    }
-  ]
-};
+import { Tekimax, OpenAIProvider } from 'tekimax-ts'
+
+const client = new Tekimax({
+    provider: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY })
+})
 ```
 
-### formatting a Request
+### 2. Multi-Modal Interfaces
+
+The client is organized into cohesive namespaces:
+
+#### Text (Chat)
 
 ```typescript
-import { CreateResponseBody } from 'tekimax-ts';
-
-const requestPayload: CreateResponseBody = {
-  model: 'tekimax-1.0',
-  items: [userMessage],
-  stream: true
-};
-
-// Send to API with Authentication and Error Handling
-try {
-  const response = await fetch('https://api.tekimax.com/v1/generate', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': 'Bearer YOUR_API_KEY'
-    },
-    body: JSON.stringify(requestPayload)
-  });
-
-  if (!response.ok) {
-    throw new Error(`API Error: ${response.status} ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  console.log('Response:', data);
-  
-} catch (error) {
-  console.error('Failed to generate response:', error);
-}
+const response = await client.text.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: 'Hello!' }]
+})
+console.log(response.message.content)
 ```
 
-### Advanced: Custom Configuration
-
-You can extend the generated types to build your own robust client wrapper:
+#### Images (Generation & Vision)
 
 ```typescript
-import { CreateResponseBody, RequiredItemParam } from 'tekimax-ts';
+// 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'
+})
+```
 
-interface TekimaxConfig {
-    apiKey: string;
-    baseUrl?: string;
-}
+#### Audio (TTS)
 
-class TekimaxClient {
-    constructor(private config: TekimaxConfig) {}
+```typescript
+const audio = await client.audio.speak({
+    model: 'tts-1',
+    input: 'Hello world',
+    voice: 'alloy'
+})
+```
+
+#### Video (Analysis)
 
-    async generate(body: CreateResponseBody) {
-        // Implementation...
-    }
-}
+```typescript
+const analysis = await client.videos.analyze({
+    model: 'gemini-1.5-flash',
+    video: 'https://example.com/video.mp4',
+    prompt: 'Summarize this clip'
+})
 ```
 
-## 🛠️ Development
+## 📚 Documentation
 
-This SDK is generated from a centralized OpenAPI specification.
+For full documentation, guides, and API references, visit **[docs.tekimax.com](https://docs.tekimax.com)**.
 
-### Regenerate Code
+## 🧠 Motivation
 
-If the spec changes, run:
 
-```bash
-npm run generate
-```
+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:
 
-### Build
+- **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.
 
-```bash
-npm run build
-```
+## 🔑 Key Principles
 
-### Secure Container Build
+### Agentic Loop
 
-This SDK can be built inside a **Chainguard** container for maximum security and reproducibility.
+All models, to some extent, exhibit agency: the ability to perceive input, reason, act through tools, and reflect on outcomes.
 
-```bash
-# Build using the hardened Chainguard Node.js image
-docker build -f Dockerfile -t tekimax-ts .
-```
+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.
+
+Tekimax defines a common pattern for defining control flow in the agent loop, a set of item definitions for developer-controlled tools, and pattern for defining provider and router-hosted tools.
+
+### Items → Items
+
+Items are the fundamental unit of context in Tekimax: they represent an atomic unit of model output, tool invocation, or reasoning state. Items are bidirectional, they can be provided as inputs to the model, or as outputs from the model.
+
+Each item type has a defined schema that binds it and contains properties specific to its unique purpose.
+
+Tekimax defines a common set of items supported by a quorum of model providers, and defines how provider-specific item types can be defined.
+
+### Semantic Events
+
+Streaming is modeled as a series of semantic events, not raw text or object deltas.
+
+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)
 
-### 🛡️ Security Verification
+## Code of Conduct
 
-*   **Scanner**: Trivy (v0.69.0)
-*   **Date**: 2026-01-31
-*   **Result**: ✅ **0 Vulnerabilities** (Clean)
-*   **Base Image**: `cgr.dev/chainguard/node:latest-dev`
+## 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 };