@zyraxon-ai/sdk 19.0.2

package/README.md

@@ -0,0 +1,117 @@
+# ZYRAXON AI SDK
+
+> The official JavaScript/TypeScript SDK for ZYRAXON AI
+
+---
+
+## Overview
+
+The ZYRAXON AI SDK provides a comprehensive set of tools and APIs for developers who want to integrate ZYRAXON's powerful AI capabilities into their own applications. Build chatbots, code editors, voice assistants, and more with ease.
+
+---
+
+## Quick Start
+
+```bash
+npm install @zyraxon-ai/sdk
+```
+
+```typescript
+import { createZyraxonClient } from '@zyraxon-ai/sdk'
+
+const client = createZyraxonClient({
+  baseUrl: 'http://localhost:3000',
+})
+
+const response = await client.chat({
+  message: 'Hello ZYRAXON!',
+})
+
+console.log(response.text)
+```
+
+---
+
+## Documentation
+
+- **[Full SDK Documentation](../../../SDK.md)** — Complete API reference, examples, and guides
+- **[Quick Start Guide](./QUICKSTART.md)** — Get up and running in minutes
+
+---
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **AI Chat** | Send messages and receive responses from 25+ LLM providers |
+| **Streaming** | Real-time streaming responses for better UX |
+| **File Operations** | Read and write files on the server |
+| **Session Management** | Maintain conversation context across messages |
+| **Memory** | Store and retrieve key-value pairs |
+| **TypeScript** | Full TypeScript support with type definitions |
+
+---
+
+## Examples
+
+### Basic Chat
+
+```typescript
+import { createZyraxonClient } from '@zyraxon-ai/sdk'
+
+const client = createZyraxonClient({
+  baseUrl: 'http://localhost:3000',
+})
+
+async function chat() {
+  const response = await client.chat({
+    message: 'Write a Python function to sort a list',
+  })
+
+  console.log(response.text)
+}
+
+chat()
+```
+
+### Streaming Response
+
+```typescript
+const stream = await client.chatStream({
+  message: 'Explain quantum computing',
+})
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.text)
+}
+```
+
+### File Operations
+
+```typescript
+// Read a file
+const file = await client.readFile({ path: 'README.md' })
+console.log(file.content)
+
+// Write a file
+await client.writeFile({
+  path: 'output.txt',
+  content: 'Hello from ZYRAXON SDK!',
+})
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../../CONTRIBUTING.md) before submitting a Pull Request.
+
+---
+
+## License
+
+This project is licensed under the **Zyraxon Sovereign License — X Edition (ZSL-X)**.
+
+---
+
+*Created by OMG / Lx Sayidi — [GitHub](https://github.com/onelpawarai-X)*

package/package.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@zyraxon-ai/sdk",
+  "version": "19.0.2",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "Official JavaScript/TypeScript SDK for ZYRAXON AI — Build AI-powered applications with ease",
+  "homepage": "https://zyraxonai.lovable.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onelpawarai-X/ZYRAXON-AI.git",
+    "directory": "packages/sdk/js"
+  },
+  "bugs": {
+    "url": "https://github.com/onelpawarai-X/ZYRAXON-AI/issues"
+  },
+  "author": "OMG / Lx Sayidi <sayidilx@gmail.com>",
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsgo --noEmit",
+    "build": "bun ./script/build.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./client": "./src/client.ts",
+    "./server": "./src/server.ts",
+    "./v2": "./src/v2/index.ts",
+    "./v2/client": "./src/v2/client.ts",
+    "./v2/gen/client": "./src/v2/gen/client/index.ts",
+    "./v2/server": "./src/v2/server.ts",
+    "./v2/types": "./src/v2/gen/types.gen.ts"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "zyraxon",
+    "ai",
+    "sdk",
+    "llm",
+    "chatbot",
+    "artificial-intelligence",
+    "typescript",
+    "javascript"
+  ],
+  "devDependencies": {
+    "@hey-api/openapi-ts": "0.90.10",
+    "@tsconfig/node22": "catalog:",
+    "@types/cross-spawn": "catalog:",
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "typescript": "catalog:"
+  },
+  "dependencies": {
+    "cross-spawn": "catalog:"
+  }
+}

package/src/client.ts

@@ -0,0 +1,57 @@
+export * from "./gen/types.gen.js"
+
+import { createClient } from "./gen/client/client.gen.js"
+import { type Config } from "./gen/client/types.gen.js"
+import { ZyraxonClient } from "./gen/sdk.gen.js"
+import { wrapClientError } from "./error-interceptor.js"
+export { type Config as ZyraxonClientConfig, ZyraxonClient }
+
+function pick(value: string | null, fallback?: string) {
+  if (!value) return
+  if (!fallback) return value
+  if (value === fallback) return fallback
+  if (value === encodeURIComponent(fallback)) return fallback
+  return value
+}
+
+function rewrite(request: Request, directory?: string) {
+  if (request.method !== "GET" && request.method !== "HEAD") return request
+
+  const value = pick(request.headers.get("x-zyraxon-directory"), directory)
+  if (!value) return request
+
+  const url = new URL(request.url)
+  if (!url.searchParams.has("directory")) {
+    url.searchParams.set("directory", value)
+  }
+
+  const next = new Request(url, request)
+  next.headers.delete("x-zyraxon-directory")
+  return next
+}
+
+export function createZyraxonClient(config?: Config & { directory?: string }) {
+  if (!config?.fetch) {
+    const customFetch: any = (req: any) => {
+      // @ts-ignore
+      req.timeout = false
+      return fetch(req)
+    }
+    config = {
+      ...config,
+      fetch: customFetch,
+    }
+  }
+
+  if (config?.directory) {
+    config.headers = {
+      ...config.headers,
+      "x-zyraxon-directory": encodeURIComponent(config.directory),
+    }
+  }
+
+  const client = createClient(config)
+  client.interceptors.request.use((request) => rewrite(request, config?.directory))
+  client.interceptors.error.use(wrapClientError)
+  return new ZyraxonClient({ client })
+}

package/src/error-interceptor.ts

@@ -0,0 +1,51 @@
+/**
+ * Wrap whatever the generated client decoded from a non-2xx error body
+ * into a real `Error` so downstream formatters (TUI, plugins) get a
+ * useful `.message` instead of `[object Object]` or blank. The original
+ * parsed body and status live under `.cause` for callers that need
+ * structured fields.
+ *
+ * Only fires when the caller used `{ throwOnError: true }`. Callers that
+ * read `result.error` directly (the result-tuple path) get the parsed
+ * body unchanged so existing field-level reads (`.error.name`,
+ * `JSON.stringify(error)`, etc.) are byte-for-byte identical to before.
+ */
+export function wrapClientError(
+  error: unknown,
+  response: Response | undefined,
+  request: Request | undefined,
+  opts: { throwOnError?: boolean } | undefined,
+): unknown {
+  if (!opts?.throwOnError) return error
+  if (error instanceof Error) return error
+
+  // NamedError-shaped responses (the common case for zyraxon 4xx) come
+  // through as POJOs — extract a useful message first, then wrap.
+  if (typeof error === "object" && error !== null && Object.keys(error).length > 0) {
+    const obj = error as { data?: { message?: unknown }; message?: unknown; name?: unknown }
+    const message =
+      (typeof obj.data?.message === "string" && obj.data.message) ||
+      (typeof obj.message === "string" && obj.message) ||
+      (typeof obj.name === "string" && obj.name) ||
+      describe(request, response)
+    return new Error(message, { cause: { body: error, status: response?.status } })
+  }
+
+  if (typeof error === "string" && error.length > 0) {
+    return new Error(error, { cause: { body: error, status: response?.status } })
+  }
+
+  // Empty body / network failure / undefined / null / empty object.
+  const reason = response ? "(empty response body)" : "network error (no response)"
+  return new Error(`zyraxon server ${describe(request, response)}: ${reason}`, {
+    cause: { body: error, status: response?.status },
+  })
+}
+
+function describe(request: Request | undefined, response: Response | undefined) {
+  const method = request?.method ?? "?"
+  const url = request?.url ?? "?"
+  const status = response?.status
+  const statusText = response?.statusText
+  return `${method} ${url}${status ? " → " + status : ""}${statusText ? " " + statusText : ""}`
+}

package/src/gen/client/client.gen.ts

@@ -0,0 +1,212 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from "../core/serverSentEvents.gen.js"
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from "./types.gen.js"
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from "./utils.gen.js"
+
+type ReqInit = Omit<RequestInit, "body" | "headers"> & {
+  body?: any
+  headers: ReturnType<typeof mergeHeaders>
+}
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config)
+
+  const getConfig = (): Config => ({ ..._config })
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config)
+    return getConfig()
+  }
+
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>()
+
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    }
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      })
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts)
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body)
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type")
+    }
+
+    const url = buildUrl(opts)
+
+    return { opts, url }
+  }
+
+  const request: Client["request"] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options)
+    const requestInit: ReqInit = {
+      redirect: "follow",
+      ...opts,
+      body: opts.serializedBody,
+    }
+
+    let request = new Request(url, requestInit)
+
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        request = await fn(request, opts)
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!
+    let response = await _fetch(request)
+
+    for (const fn of interceptors.response._fns) {
+      if (fn) {
+        response = await fn(response, request, opts)
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    }
+
+    if (response.ok) {
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        return opts.responseStyle === "data"
+          ? {}
+          : {
+              data: {},
+              ...result,
+            }
+      }
+
+      const parseAs =
+        (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json"
+
+      let data: any
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]()
+          break
+        case "stream":
+          return opts.responseStyle === "data"
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              }
+      }
+
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data)
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data)
+        }
+      }
+
+      return opts.responseStyle === "data"
+        ? data
+        : {
+            data,
+            ...result,
+          }
+    }
+
+    const textError = await response.text()
+    let jsonError: unknown
+
+    try {
+      jsonError = JSON.parse(textError)
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError
+    let finalError = error
+
+    for (const fn of interceptors.error._fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string
+      }
+    }
+
+    finalError = finalError || ({} as string)
+
+    if (opts.throwOnError) {
+      throw finalError
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === "data"
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        }
+  }
+
+  const makeMethod = (method: Required<Config>["method"]) => {
+    const fn = (options: RequestOptions) => request({ ...options, method })
+    fn.sse = async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options)
+      return createSseClient({
+        ...opts,
+        body: opts.body as BodyInit | null | undefined,
+        headers: opts.headers as unknown as Record<string, string>,
+        method,
+        url,
+      })
+    }
+    return fn
+  }
+
+  return {
+    buildUrl,
+    connect: makeMethod("CONNECT"),
+    delete: makeMethod("DELETE"),
+    get: makeMethod("GET"),
+    getConfig,
+    head: makeMethod("HEAD"),
+    interceptors,
+    options: makeMethod("OPTIONS"),
+    patch: makeMethod("PATCH"),
+    post: makeMethod("POST"),
+    put: makeMethod("PUT"),
+    request,
+    setConfig,
+    trace: makeMethod("TRACE"),
+  } as Client
+}

package/src/gen/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from "../core/auth.gen.js"
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js"
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from "../core/bodySerializer.gen.js"
+export { buildClientParams } from "../core/params.gen.js"
+export { createClient } from "./client.gen.js"
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  OptionsLegacyParser,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from "./types.gen.js"
+export { createConfig, mergeHeaders } from "./utils.gen.js"