@zyraxon-ai/sdk 19.0.2

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from "./client.js"
+export * from "./server.js"
+
+import { createZyraxonClient } from "./client.js"
+import { createZyraxonServer } from "./server.js"
+import type { ServerOptions } from "./server.js"
+
+export async function createZyraxon(options?: ServerOptions) {
+  const server = await createZyraxonServer({
+    ...options,
+  })
+
+  const client = createZyraxonClient({
+    baseUrl: server.url,
+  })
+
+  return {
+    client,
+    server,
+  }
+}

package/src/process.ts

@@ -0,0 +1,31 @@
+import { type ChildProcess, spawnSync } from "node:child_process"
+
+// Duplicated from `packages/zyraxon/src/util/process.ts` because the SDK cannot
+// import `zyraxon` without creating a cycle (`zyraxon` depends on `@zyraxon-ai/sdk`).
+export function stop(proc: ChildProcess) {
+  if (proc.exitCode !== null || proc.signalCode !== null) return
+  if (process.platform === "win32" && proc.pid) {
+    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true })
+    if (!out.error && out.status === 0) return
+  }
+  proc.kill()
+}
+
+export function bindAbort(proc: ChildProcess, signal?: AbortSignal, onAbort?: () => void) {
+  if (!signal) return () => {}
+  const abort = () => {
+    clear()
+    stop(proc)
+    onAbort?.()
+  }
+  const clear = () => {
+    signal.removeEventListener("abort", abort)
+    proc.off("exit", clear)
+    proc.off("error", clear)
+  }
+  signal.addEventListener("abort", abort, { once: true })
+  proc.on("exit", clear)
+  proc.on("error", clear)
+  if (signal.aborted) abort()
+  return clear
+}

package/src/server.ts

@@ -0,0 +1,134 @@
+import launch from "cross-spawn"
+import { type Config } from "./gen/types.gen.js"
+import { stop, bindAbort } from "./process.js"
+
+export type ServerOptions = {
+  hostname?: string
+  port?: number
+  signal?: AbortSignal
+  timeout?: number
+  config?: Config
+}
+
+export type TuiOptions = {
+  project?: string
+  model?: string
+  session?: string
+  agent?: string
+  signal?: AbortSignal
+  config?: Config
+}
+
+export async function createZyraxonServer(options?: ServerOptions) {
+  options = Object.assign(
+    {
+      hostname: "127.0.0.1",
+      port: 4096,
+      timeout: 5000,
+    },
+    options ?? {},
+  )
+
+  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`]
+  if (options.config?.logLevel) args.push(`--log-level=${options.config.logLevel}`)
+
+  const proc = launch(`zyraxon`, args, {
+    env: {
+      ...process.env,
+      ZYRAXON_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
+    },
+  })
+  let clear = () => {}
+
+  const url = await new Promise<string>((resolve, reject) => {
+    const id = setTimeout(() => {
+      clear()
+      stop(proc)
+      reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`))
+    }, options.timeout)
+    let output = ""
+    let resolved = false
+    proc.stdout?.on("data", (chunk) => {
+      if (resolved) return
+      output += chunk.toString()
+      const lines = output.split("\n")
+      for (const line of lines) {
+        if (line.startsWith("zyraxon server listening")) {
+          const match = line.match(/on\s+(https?:\/\/[^\s]+)/)
+          if (!match) {
+            clear()
+            stop(proc)
+            clearTimeout(id)
+            reject(new Error(`Failed to parse server url from output: ${line}`))
+            return
+          }
+          clearTimeout(id)
+          resolved = true
+          resolve(match[1]!)
+          return
+        }
+      }
+    })
+    proc.stderr?.on("data", (chunk) => {
+      output += chunk.toString()
+    })
+    proc.on("exit", (code) => {
+      clearTimeout(id)
+      let msg = `Server exited with code ${code}`
+      if (output.trim()) {
+        msg += `\nServer output: ${output}`
+      }
+      reject(new Error(msg))
+    })
+    proc.on("error", (error) => {
+      clearTimeout(id)
+      reject(error)
+    })
+    clear = bindAbort(proc, options.signal, () => {
+      clearTimeout(id)
+      reject(options.signal?.reason)
+    })
+  })
+
+  return {
+    url,
+    close() {
+      clear()
+      stop(proc)
+    },
+  }
+}
+
+export function createZyraxonTui(options?: TuiOptions) {
+  const args = []
+
+  if (options?.project) {
+    args.push(`--project=${options.project}`)
+  }
+  if (options?.model) {
+    args.push(`--model=${options.model}`)
+  }
+  if (options?.session) {
+    args.push(`--session=${options.session}`)
+  }
+  if (options?.agent) {
+    args.push(`--agent=${options.agent}`)
+  }
+
+  const proc = launch(`zyraxon`, args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ZYRAXON_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
+    },
+  })
+
+  const clear = bindAbort(proc, options?.signal)
+
+  return {
+    close() {
+      clear()
+      stop(proc)
+    },
+  }
+}

package/src/v2/client.ts

@@ -0,0 +1,93 @@
+export * from "./gen/types.gen.js"
+export type { FileSystemEntry as LocationFileSystemEntry } 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, encode?: (value: string) => string) {
+  if (!value) return
+  if (!fallback) return value
+  if (value === fallback) return fallback
+  if (encode && value === encode(fallback)) return fallback
+  return value
+}
+
+function rewrite(request: Request, values: { directory?: string; workspace?: string }) {
+  if (request.method !== "GET" && request.method !== "HEAD") return request
+
+  const url = new URL(request.url)
+  let changed = false
+
+  for (const [name, key] of [
+    ["x-zyraxon-directory", "directory"],
+    ["x-zyraxon-workspace", "workspace"],
+  ] as const) {
+    const value = pick(
+      request.headers.get(name),
+      key === "directory" ? values.directory : values.workspace,
+      key === "directory" ? encodeURIComponent : undefined,
+    )
+    if (!value) continue
+    for (const query of url.pathname.startsWith("/api/") ? [key, `location[${key}]`] : [key]) {
+      if (!url.searchParams.has(query)) {
+        url.searchParams.set(query, value)
+      }
+    }
+    changed = true
+  }
+
+  if (!changed) return request
+
+  const next = new Request(url, request)
+  next.headers.delete("x-zyraxon-directory")
+  next.headers.delete("x-zyraxon-workspace")
+  return next
+}
+
+export function createZyraxonClient(config?: Config & { directory?: string; experimental_workspaceID?: 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),
+    }
+  }
+
+  if (config?.experimental_workspaceID) {
+    config.headers = {
+      ...config.headers,
+      "x-zyraxon-workspace": config.experimental_workspaceID,
+    }
+  }
+
+  const client = createClient(config)
+  client.interceptors.request.use((request) =>
+    rewrite(request, {
+      directory: config?.directory,
+      workspace: config?.experimental_workspaceID,
+    }),
+  )
+  client.interceptors.response.use((response) => {
+    const contentType = response.headers.get("content-type")
+    if (contentType === "text/html")
+      throw new Error("Request is not supported by this version of Zyraxon Server (Server responded with text/html)")
+
+    return response
+  })
+  client.interceptors.error.use(wrapClientError)
+  return new ZyraxonClient({ client })
+}

package/src/v2/data.ts

@@ -0,0 +1,32 @@
+import type { Part, UserMessage } from "./client.js"
+
+export const message = {
+  user(input: Omit<UserMessage, "role" | "time" | "id"> & { parts: Omit<Part, "id" | "sessionID" | "messageID">[] }): {
+    info: UserMessage
+    parts: Part[]
+  } {
+    const { parts: _parts, ...rest } = input
+
+    const info: UserMessage = {
+      ...rest,
+      id: "asdasd",
+      time: {
+        created: Date.now(),
+      },
+      role: "user",
+    }
+
+    return {
+      info,
+      parts: input.parts.map(
+        (part) =>
+          ({
+            ...part,
+            id: "asdasd",
+            messageID: info.id,
+            sessionID: info.sessionID,
+          }) as Part,
+      ),
+    }
+  },
+}

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

@@ -0,0 +1,285 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from "../core/serverSentEvents.gen.js"
+import type { HttpMethod } from "../core/types.gen.js"
+import { getValidRequestBody } from "../core/utils.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 !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body)
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === 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: getValidRequestBody(opts),
+    }
+
+    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: Response
+
+    try {
+      response = await _fetch(request)
+    } catch (error) {
+      // Handle fetch exceptions (AbortError, network errors, etc.)
+      let finalError = error
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = (await fn(error, undefined as any, request, opts)) as unknown
+        }
+      }
+
+      finalError = finalError || ({} as unknown)
+
+      if (opts.throwOnError) {
+        throw finalError
+      }
+
+      // Return error response
+      return opts.responseStyle === "data"
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response: undefined as any,
+          }
+    }
+
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request, opts)
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    }
+
+    if (response.ok) {
+      const parseAs =
+        (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json"
+
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData: any
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]()
+            break
+          case "formData":
+            emptyData = new FormData()
+            break
+          case "stream":
+            emptyData = response.body
+            break
+          case "json":
+          default:
+            emptyData = {}
+            break
+        }
+        return opts.responseStyle === "data"
+          ? emptyData
+          : {
+              data: emptyData,
+              ...result,
+            }
+      }
+
+      let data: any
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "text":
+          data = await response[parseAs]()
+          break
+        case "json": {
+          // Some servers return 200 with no Content-Length and empty body.
+          // response.json() would throw; read as text and parse if non-empty.
+          const text = await response.text()
+          data = text ? JSON.parse(text) : {}
+          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 makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) => request({ ...options, method })
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => 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,
+      onRequest: async (url, init) => {
+        let request = new Request(url, init)
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request = await fn(request, opts)
+          }
+        }
+        return request
+      },
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    })
+  }
+
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE"),
+    },
+    trace: makeMethodFn("TRACE"),
+  } as Client
+}

package/src/v2/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 { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js"
+export { createClient } from "./client.gen.js"
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from "./types.gen.js"
+export { createConfig, mergeHeaders } from "./utils.gen.js"