@azmxailabs/agent-sdk 0.1.0 → 0.2.0

package/README.md

@@ -215,7 +215,7 @@ MIT — see [LICENSE](./LICENSE).
 
 ## About AZMX AI
 
-AZMX AI is a native (~7 MB) AI coding agent that runs on your machine, with your keys (BYOK across 11+ providers, or fully offline via Ollama / LM Studio). Every write is gated by per-call approval. No account, no telemetry. Free forever for individuals.
+AZMX AI is a native AI coding agent that runs on your machine, with your keys (BYOK across 11+ providers, or fully offline via Ollama / LM Studio). Every write is gated by per-call approval. No account, no telemetry. Free forever for individuals.
 
 - Homepage: https://azmx.ai
 - Docs: https://azmx.ai/docs

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+/**
+ * azmx — a headless AZMX agent CLI. Run a turn from the terminal / a pipe / CI,
+ * streaming the answer to stdout. The parity + scripting entry point the desktop
+ * app didn't have.
+ *
+ *   azmx "explain this error" < build.log
+ *   azmx code "write a python function to reverse a string"
+ *   cat main.rs | azmx code "review this for bugs"
+ *   azmx -m gpt-5.5 "summarize the news"                 # cloud BYOK
+ *   AZMX_BASE_URL=http://localhost:8757/v1 azmx code "…" # sovereign REVA / local
+ *
+ * BYOK direct, no proxy, no telemetry — same primitives as the app (the SDK's
+ * ProviderRouter + provider adapters). Keys come from the environment.
+ */
+import { ProviderRouter } from "./providers/router.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { OpenAIProvider } from "./providers/openai.js";
+const HELP = `azmx — headless AZMX agent CLI
+
+USAGE
+  azmx [code] <prompt>          run a turn; stream the answer to stdout
+  <cmd> | azmx [code] [prompt]  read piped stdin as context (prompt optional)
+
+OPTIONS
+  -m, --model <id>       model id / local slot (default: provider default, or "sutra" for code)
+  -s, --system <text>    override the system prompt
+      --base-url <url>   OpenAI-compatible endpoint (REVA/Ollama/LM Studio/proxy)
+      --temperature <n>  sampling temperature
+      --max-tokens <n>   max output tokens
+      --no-stream        buffer the whole reply, then print
+  -h, --help             this help
+
+PROVIDER (auto-detected from the environment, in order)
+  --base-url / AZMX_BASE_URL   → OpenAI-compatible (key: AZMX_API_KEY, else "local")
+  ANTHROPIC_API_KEY            → Anthropic
+  OPENAI_API_KEY               → OpenAI
+  (else) http://127.0.0.1:8757/v1 → the sovereign REVA runtime, if it's running
+
+'azmx code' adds a concise coding system prompt and defaults to a code model.`;
+function parseArgs(argv) {
+    const a = { code: false, stream: true, help: false, prompt: "" };
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        const next = () => argv[++i];
+        if (t === "-h" || t === "--help")
+            a.help = true;
+        else if (t === "--no-stream")
+            a.stream = false;
+        else if (t === "-m" || t === "--model")
+            a.model = next();
+        else if (t === "-s" || t === "--system")
+            a.system = next();
+        else if (t === "--base-url")
+            a.baseUrl = next();
+        else if (t === "--temperature")
+            a.temperature = Number(next());
+        else if (t === "--max-tokens")
+            a.maxTokens = Number(next());
+        else if (t === "code" && rest.length === 0 && !a.prompt)
+            a.code = true;
+        else
+            rest.push(t);
+    }
+    a.prompt = rest.join(" ").trim();
+    return a;
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return "";
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(c);
+    return Buffer.concat(chunks).toString("utf8").trim();
+}
+/** Pick a provider + model from flags/env. Returns the router alias to call with. */
+function buildRouter(a) {
+    const router = new ProviderRouter();
+    const codeModelFallback = a.code ? "sutra" : undefined;
+    const baseUrl = a.baseUrl ?? process.env.AZMX_BASE_URL;
+    let provider;
+    let model;
+    if (baseUrl) {
+        model = a.model ?? process.env.AZMX_MODEL ?? codeModelFallback ?? "bija";
+        provider = new OpenAIProvider({ apiKey: process.env.AZMX_API_KEY || "local", model, baseUrl });
+    }
+    else if (process.env.ANTHROPIC_API_KEY) {
+        model = a.model ?? "claude-sonnet-4-6";
+        provider = new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY, model });
+    }
+    else if (process.env.OPENAI_API_KEY) {
+        model = a.model ?? (a.code ? "gpt-5.3-codex" : "gpt-5.5");
+        provider = new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY, model });
+    }
+    else {
+        // Sovereign default: the local REVA runtime (no key, offline). Works when the
+        // AZMX app / `reva serve` is up; otherwise the request fails with a clear error.
+        model = a.model ?? codeModelFallback ?? "bija";
+        provider = new OpenAIProvider({ apiKey: "local", model, baseUrl: "http://127.0.0.1:8757/v1" });
+    }
+    router.register(model, provider, { default: true });
+    return { router, model };
+}
+const CODE_SYSTEM = "You are AZMX, an expert coding agent. Be direct and correct. Prefer working code over prose; " +
+    "when you show code, make it complete and runnable. Match the style of any code the user shows.";
+async function main() {
+    const a = parseArgs(process.argv.slice(2));
+    if (a.help) {
+        process.stdout.write(HELP + "\n");
+        return;
+    }
+    const piped = await readStdin();
+    let userText = a.prompt;
+    if (piped)
+        userText = userText ? `${userText}\n\n---\n${piped}` : piped;
+    if (!userText) {
+        process.stderr.write("azmx: no prompt (pass one as an argument or pipe stdin). Try `azmx --help`.\n");
+        process.exitCode = 2;
+        return;
+    }
+    const { router, model } = buildRouter(a);
+    const messages = [];
+    const system = a.system ?? (a.code ? CODE_SYSTEM : undefined);
+    if (system)
+        messages.push({ role: "system", content: system });
+    messages.push({ role: "user", content: userText });
+    const controller = new AbortController();
+    const onSig = () => controller.abort();
+    process.on("SIGINT", onSig);
+    process.on("SIGTERM", onSig);
+    const req = {
+        model,
+        messages,
+        temperature: a.temperature,
+        maxTokens: a.maxTokens,
+        signal: controller.signal,
+    };
+    try {
+        if (a.stream) {
+            for await (const chunk of router.stream(req)) {
+                if (chunk.delta)
+                    process.stdout.write(chunk.delta);
+            }
+            process.stdout.write("\n");
+        }
+        else {
+            const r = await router.complete(req);
+            process.stdout.write(r.text + "\n");
+        }
+    }
+    catch (e) {
+        process.stderr.write(`\nazmx: ${e.message}\n`);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/providers/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./types.js";
 export * from "./router.js";
 export * from "./anthropic.js";
+export * from "./openai.js";
 export * from "./ollama.js";

package/dist/providers/index.js

@@ -1,4 +1,5 @@
 export * from "./types.js";
 export * from "./router.js";
 export * from "./anthropic.js";
+export * from "./openai.js";
 export * from "./ollama.js";

package/dist/providers/openai.d.ts

@@ -0,0 +1,36 @@
+import type { ChatRequest, ChatResponse, Provider, StreamChunk } from "./types.js";
+export interface OpenAIProviderOptions {
+    /** Bearer key. For a no-auth local endpoint (REVA / Ollama / LM Studio) pass any placeholder. */
+    apiKey: string;
+    /** Provider model id, e.g. "gpt-5.5", or a local slot like "sutra"/"bija" for REVA. */
+    model: string;
+    /**
+     * API base, including the version segment. Default OpenAI. Point this at any
+     * OpenAI-compatible server — REVA (`http://localhost:8757/v1`), Ollama
+     * (`http://localhost:11434/v1`), LM Studio, vLLM, OpenRouter, Groq, …
+     */
+    baseUrl?: string;
+    defaultMaxTokens?: number;
+    fetch?: typeof fetch;
+}
+/**
+ * OpenAI Chat Completions adapter — POST {baseUrl}/chat/completions.
+ *
+ * BYOK direct (no AZMX proxy). Because the wire shape is the OpenAI standard,
+ * this single adapter also drives every OpenAI-compatible backend — including
+ * the sovereign REVA runtime and local Ollama/LM Studio — just by changing
+ * `baseUrl`. That's what lets the CLI run fully offline on your own models.
+ */
+export declare class OpenAIProvider implements Provider {
+    readonly name = "openai";
+    private apiKey;
+    private model;
+    private baseUrl;
+    private defaultMaxTokens?;
+    private fetch;
+    constructor(opts: OpenAIProviderOptions);
+    complete(req: ChatRequest): Promise<ChatResponse>;
+    stream(req: ChatRequest): AsyncIterable<StreamChunk>;
+    private buildBody;
+    private headers;
+}

package/dist/providers/openai.js

@@ -0,0 +1,149 @@
+/**
+ * OpenAI Chat Completions adapter — POST {baseUrl}/chat/completions.
+ *
+ * BYOK direct (no AZMX proxy). Because the wire shape is the OpenAI standard,
+ * this single adapter also drives every OpenAI-compatible backend — including
+ * the sovereign REVA runtime and local Ollama/LM Studio — just by changing
+ * `baseUrl`. That's what lets the CLI run fully offline on your own models.
+ */
+export class OpenAIProvider {
+    name = "openai";
+    apiKey;
+    model;
+    baseUrl;
+    defaultMaxTokens;
+    fetch;
+    constructor(opts) {
+        if (!opts.apiKey)
+            throw new Error("OpenAIProvider: apiKey is required (use a placeholder for a no-auth local endpoint)");
+        if (!opts.model)
+            throw new Error("OpenAIProvider: model is required");
+        this.apiKey = opts.apiKey;
+        this.model = opts.model;
+        this.baseUrl = (opts.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+        this.defaultMaxTokens = opts.defaultMaxTokens;
+        this.fetch = opts.fetch ?? fetch;
+    }
+    async complete(req) {
+        const res = await this.fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(this.buildBody(req, false)),
+            signal: req.signal,
+        });
+        if (!res.ok)
+            throw await httpError(res);
+        const data = (await res.json());
+        const choice = data.choices?.[0];
+        return {
+            text: choice?.message?.content ?? "",
+            finishReason: choice?.finish_reason ?? "stop",
+            usage: data.usage
+                ? { inputTokens: data.usage.prompt_tokens ?? 0, outputTokens: data.usage.completion_tokens ?? 0 }
+                : undefined,
+            raw: data,
+        };
+    }
+    async *stream(req) {
+        const res = await this.fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(this.buildBody(req, true)),
+            signal: req.signal,
+        });
+        if (!res.ok)
+            throw await httpError(res);
+        // Some OpenAI-compatible servers (e.g. the sovereign REVA runtime) ignore `stream:true`
+        // and return one buffered JSON completion. Detect that by content-type and yield it whole,
+        // so streaming callers still get the text instead of nothing.
+        const ctype = res.headers.get("content-type") ?? "";
+        if (!ctype.includes("event-stream")) {
+            const data = (await res.json());
+            const choice = data.choices?.[0];
+            const text = choice?.message?.content ?? "";
+            if (text)
+                yield { delta: text };
+            yield {
+                delta: "",
+                done: true,
+                finishReason: choice?.finish_reason ?? "stop",
+                usage: data.usage
+                    ? { inputTokens: data.usage.prompt_tokens ?? 0, outputTokens: data.usage.completion_tokens ?? 0 }
+                    : undefined,
+            };
+            return;
+        }
+        if (!res.body)
+            throw new Error("OpenAIProvider: streaming response had no body");
+        let usage;
+        let finishReason;
+        for await (const data of sseData(res.body)) {
+            if (data === "[DONE]")
+                break;
+            let parsed;
+            try {
+                parsed = JSON.parse(data);
+            }
+            catch {
+                continue;
+            }
+            const choice = parsed.choices?.[0];
+            if (choice?.delta?.content)
+                yield { delta: choice.delta.content };
+            if (choice?.finish_reason)
+                finishReason = choice.finish_reason;
+            if (parsed.usage) {
+                usage = { inputTokens: parsed.usage.prompt_tokens ?? 0, outputTokens: parsed.usage.completion_tokens ?? 0 };
+            }
+        }
+        yield { delta: "", done: true, finishReason: finishReason ?? "stop", usage };
+    }
+    buildBody(req, stream) {
+        return {
+            model: this.model,
+            messages: req.messages.map((m) => ({ role: m.role, content: m.content })),
+            temperature: req.temperature,
+            max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+            stop: req.stop,
+            stream,
+            ...(req.providerOptions ?? {}),
+        };
+    }
+    headers() {
+        return { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}` };
+    }
+}
+async function httpError(res) {
+    let body = "";
+    try {
+        body = await res.text();
+    }
+    catch {
+        /* ignore */
+    }
+    return new Error(`OpenAI-compatible HTTP ${res.status}: ${body.slice(0, 500)}`);
+}
+/** Yield the `data:` payload of each SSE event from a streaming body. */
+async function* sseData(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n\n")) !== -1) {
+            const chunk = buf.slice(0, nl);
+            buf = buf.slice(nl + 2);
+            let data = "";
+            for (const line of chunk.split("\n")) {
+                if (line.startsWith("data:"))
+                    data += line.slice(5).trim();
+            }
+            if (data)
+                yield data;
+        }
+    }
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@azmxailabs/agent-sdk",
-  "version": "0.1.0",
-  "description": "Build approval-gated AI agents with the same primitives that power AZMX AI — BYOK provider router, approval gate, deny-list, hash-chained audit log. Secure by default, BYOK direct (no proxy), no telemetry.",
+  "version": "0.2.0",
+  "description": "Build approval-gated AI agents with the same primitives that power AZMX AI — BYOK provider router (Anthropic / OpenAI / any OpenAI-compatible incl. local REVA & Ollama), approval gate, deny-list, hash-chained audit log. Ships a headless `azmx` CLI. Secure by default, BYOK direct (no proxy), no telemetry.",
   "license": "MIT",
   "type": "module",
+  "bin": {
+    "azmx": "./dist/cli.js"
+  },
   "homepage": "https://azmx.ai",
   "repository": {
     "type": "git",