Chat & Deep Reasoning

import { useState, useCallback } from 'react';

const GATEWAY_URL = "https://tiny-shape-e3d1.mukulgupta0014.workers.dev";
const MASTER_KEY = "sk_live_master_gateway_key_2026";

export function useOmniAI() {
  const [response, setResponse] = useState("");
  const [isGenerating, setIsGenerating] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const askModel = useCallback(async (prompt: string, model = "meta/llama-3.2-11b-vision-instruct") => {
    setIsGenerating(true);
    setResponse("");
    setError(null);

    try {
      const res = await fetch(`${GATEWAY_URL}/v1/chat/completions`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "Authorization": `Bearer ${MASTER_KEY}`
        },
        body: JSON.stringify({
          model,
          messages: [{ role: "user", content: prompt }],
          stream: true
        })
      });

      if (!res.ok) throw new Error(`Gateway returned HTTP ${res.status}`);

      const reader = res.body?.getReader();
      if (!reader) throw new Error("No readable stream");

      const decoder = new TextDecoder();
      let accumulated = "";

      while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        const chunk = decoder.decode(value, { stream: true });
        const lines = chunk.split("\n");

        for (const line of lines) {
          const trimmed = line.trim();
          if (trimmed.startsWith("data:") && !trimmed.includes("[DONE]")) {
            try {
              const data = JSON.parse(trimmed.replace(/^data:\s*/, ''));
              const delta = data.choices?.[0]?.delta?.content || "";
              accumulated += delta;
              setResponse(accumulated);
            } catch (e) {}
          }
        }
      }
    } catch (err: any) {
      setError(err.message);
    } finally {
      setIsGenerating(false);
    }
  }, []);

  return { askModel, response, isGenerating, error };
}

async function generateAIResponse(prompt, onToken) {
  const res = await fetch("https://tiny-shape-e3d1.mukulgupta0014.workers.dev/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer sk_live_master_gateway_key_2026"
    },
    body: JSON.stringify({
      model: "meta/llama-3.2-11b-vision-instruct",
      messages: [{ role: "user", content: prompt }],
      stream: true
    })
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    const chunk = decoder.decode(value);
    for (const line of chunk.split("\n")) {
      if (line.startsWith("data:") && !line.includes("[DONE]")) {
        try {
          const content = JSON.parse(line.slice(5)).choices[0].delta.content;
          if (content) onToken(content);
        } catch (e) {}
      }
    }
  }
}

import os
from openai import OpenAI

# 1. Initialize client pointing directly to your OmniAI Gateway
client = OpenAI(
    base_url="https://tiny-shape-e3d1.mukulgupta0014.workers.dev/v1",
    api_key="sk_live_master_gateway_key_2026"
)

# 2. Call any of the 59 models (e.g. DeepSeek R1, Groq, Codestral, Gemini 2.0 Flash)
response = client.chat.completions.create(
    model="deepseek-r1", # or "cerebras/llama-3.3-70b", "codestral", "gemini-2.0-flash"
    messages=[
        {"role": "system", "content": "You are a master desktop automation copilot."},
        {"role": "user", "content": "Generate a Python script to monitor clipboard history with timestamp."}
    ],
    stream=True
)

# 3. Stream output tokens to terminal or desktop UI
for chunk in response:
    content = chunk.choices[0].delta.content or ""
    print(content, end="", flush=True)

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class OmniAIDesktopClient
{
    private static readonly HttpClient client = new HttpClient();
    private const string GatewayUrl = "https://tiny-shape-e3d1.mukulgupta0014.workers.dev/v1/chat/completions";
    private const string MasterKey = "sk_live_master_gateway_key_2026";

    public static async Task<string> AskAIAsync(string prompt, string model = "meta/llama-3.2-11b-vision-instruct")
    {
        var requestBody = new
        {
            model = model,
            messages = new[] { new { role = "user", content = prompt } },
            stream = false
        };

        var request = new HttpRequestMessage(HttpMethod.Post, GatewayUrl);
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", MasterKey);
        request.Content = new StringContent(JsonSerializer.Serialize(requestBody), Encoding.UTF8, "application/json");

        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.GetProperty("choices")[0].GetProperty("message").GetProperty("content").GetString();
    }
}

{
  "manifest_version": 3,
  "name": "ClipIQ AI Assistant",
  "version": "1.0.0",
  "permissions": [
    "storage",
    "clipboardRead"
  ],
  "host_permissions": [
    "https://*.workers.dev/*",
    "https://tiny-shape-e3d1.mukulgupta0014.workers.dev/*"
  ],
  "background": {
    "service_worker": "background.js",
    "type": "module"
  },
  "action": {
    "default_popup": "popup.html"
  }
}

const GATEWAY_URL = "https://tiny-shape-e3d1.mukulgupta0014.workers.dev";
const MASTER_KEY = "sk_live_master_gateway_key_2026";

// Listen for connection from popup or sidebar
chrome.runtime.onConnect.addListener((port) => {
  if (port.name !== "omniai-stream") return;

  port.onMessage.addListener(async (msg) => {
    if (msg.type === "GENERATE_AI") {
      try {
        const res = await fetch(`${GATEWAY_URL}/v1/chat/completions`, {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${MASTER_KEY}`
          },
          body: JSON.stringify({
            model: msg.model || "meta/llama-3.2-11b-vision-instruct",
            messages: msg.messages,
            stream: true
          })
        });

        if (!res.ok) {
          port.postMessage({ type: "ERROR", error: `HTTP ${res.status}` });
          return;
        }

        const reader = res.body.getReader();
        const decoder = new TextDecoder();

        while (true) {
          const { done, value } = await reader.read();
          if (done) break;

          const chunk = decoder.decode(value);
          const lines = chunk.split("\n");

          for (const line of lines) {
            const trimmed = line.trim();
            if (trimmed.startsWith("data:") && !trimmed.includes("[DONE]")) {
              try {
                const data = JSON.parse(trimmed.replace("data:", "").trim());
                const token = data.choices?.[0]?.delta?.content || "";
                if (token) port.postMessage({ type: "TOKEN", token });
              } catch (e) {}
            }
          }
        }
        port.postMessage({ type: "DONE" });
      } catch (err) {
        port.postMessage({ type: "ERROR", error: err.message });
      }
    }
  });
});

// Connect long-lived port to background service worker
const port = chrome.runtime.connect({ name: "omniai-stream" });

port.onMessage.addListener((msg) => {
  if (msg.type === "TOKEN") {
    document.getElementById("output").textContent += msg.token;
  } else if (msg.type === "DONE") {
    console.log("Streaming finished");
  } else if (msg.type === "ERROR") {
    alert("Error: " + msg.error);
  }
});

// Trigger generation
function sendPrompt(userText) {
  document.getElementById("output").textContent = "";
  port.postMessage({
    type: "GENERATE_AI",
    model: "meta/llama-3.2-11b-vision-instruct",
    messages: [{ role: "user", content: userText }]
  });
}