@uncoil.dev/sdk 0.0.0-stage → 0.6.0

package/dist/integrations/vercel-ai.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncoilMiddleware = uncoilMiddleware;
+const observation_1 = require("./observation");
+function usageOf(usage = {}) {
+    return {
+        input_tokens: usage.inputTokens ?? usage.promptTokens ?? 0,
+        output_tokens: usage.outputTokens ?? usage.completionTokens ?? 0,
+    };
+}
+function textOf(result) {
+    if (typeof result.text === "string")
+        return result.text;
+    if (Array.isArray(result.content))
+        return result.content.filter((part) => part?.type === "text").map((part) => part.text ?? "").join("");
+    return "";
+}
+/**
+ * One-line tracing for the Vercel AI SDK. Pass it to `wrapLanguageModel`:
+ *
+ *   const model = wrapLanguageModel({ model: openai("gpt-4o"), middleware: uncoilMiddleware() });
+ *
+ * Every `generateText`, `streamText` or `generateObject` call made with that model becomes an Uncoil step.
+ */
+function uncoilMiddleware(options = {}) {
+    const start = (model, params) => (0, observation_1.observation)(model?.provider?.split?.(".")[0] ?? "vercel-ai", model?.modelId ?? "unknown", params, options);
+    return {
+        async wrapGenerate({ doGenerate, params, model }) {
+            const obs = start(model, params);
+            try {
+                const result = await doGenerate();
+                if (result.usage)
+                    obs.usage(usageOf(result.usage));
+                obs.data.metadata = { ...obs.data.metadata, finishReason: result.finishReason };
+                obs.finish(textOf(result));
+                return result;
+            }
+            catch (error) {
+                obs.finish(undefined, error);
+                throw error;
+            }
+        },
+        async wrapStream({ doStream, params, model }) {
+            const obs = start(model, params);
+            let result;
+            try {
+                result = await doStream();
+            }
+            catch (error) {
+                obs.finish(undefined, error);
+                throw error;
+            }
+            let text = "";
+            const watcher = new TransformStream({
+                transform(part, controller) {
+                    if (part?.type === "text-delta") {
+                        obs.token();
+                        text = (text + (part.delta ?? part.textDelta ?? "")).slice(0, 10000);
+                    }
+                    else if (part?.type === "finish" && part.usage)
+                        obs.usage(usageOf(part.usage));
+                    else if (part?.type === "error")
+                        obs.finish(text, part.error ?? new Error("Stream failed"));
+                    controller.enqueue(part);
+                },
+                flush() { obs.finish(text); },
+                cancel() { obs.finish(text, undefined, true); },
+            });
+            return { ...result, stream: result.stream.pipeThrough(watcher) };
+        },
+    };
+}

package/dist/login.d.ts

@@ -0,0 +1,37 @@
+import { type KeyObject } from "crypto";
+import { type UncoilRegion } from "./index";
+export interface LoginOptions {
+    region?: UncoilRegion;
+    host?: string;
+    /** Create a project with this name instead of picking one in the browser. */
+    newProject?: string;
+    /** Do not try to open a browser; only print the address and code. */
+    browser?: boolean;
+    envFile?: string;
+    cwd?: string;
+    /** Print machine-readable lines instead of text. */
+    json?: boolean;
+    /** Test hooks. */
+    out?: (line: string) => void;
+    sleep?: (ms: number) => Promise<void>;
+    open?: (url: string) => void;
+    now?: () => number;
+}
+export interface LoginResult {
+    ok: boolean;
+    message: string;
+    projectId?: string;
+    projectName?: string;
+    envFile?: string;
+}
+/** Sets or replaces variables in an env file's text and keeps every other line as it was. */
+export declare function upsertEnv(content: string, vars: Record<string, string | undefined>): string;
+/** True when .gitignore text already keeps this file out of git. */
+export declare function gitignoreCovers(content: string, fileName: string): boolean;
+/** Reads UNCOIL_* variables from env files into process.env without overriding values already set. Used by the CLI only. */
+export declare function loadUncoilEnv(cwd: string, files?: string[]): void;
+/** Adds the env file to .gitignore when this is a git repo that would otherwise commit the key. Returns true if it changed the file. */
+export declare function ensureGitignored(dir: string, envFile: string): boolean;
+export declare function decryptKey(privateKey: KeyObject, encrypted: string): string;
+/** Browser sign-in for the terminal. Never prints or logs the key; it is written only to the env file. */
+export declare function runLogin(options?: LoginOptions): Promise<LoginResult>;

package/dist/login.js

@@ -0,0 +1,214 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertEnv = upsertEnv;
+exports.gitignoreCovers = gitignoreCovers;
+exports.loadUncoilEnv = loadUncoilEnv;
+exports.ensureGitignored = ensureGitignored;
+exports.decryptKey = decryptKey;
+exports.runLogin = runLogin;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+const KEY_NAME = "UNCOIL_API_KEY";
+const PROJECT_ID_NAME = "UNCOIL_PROJECT_ID";
+const REGION_NAME = "UNCOIL_REGION";
+/** Sets or replaces variables in an env file's text and keeps every other line as it was. */
+function upsertEnv(content, vars) {
+    const lines = content === "" ? [] : content.replace(/\r\n/g, "\n").split("\n");
+    if (lines.length && lines[lines.length - 1] === "")
+        lines.pop();
+    for (const [name, value] of Object.entries(vars)) {
+        const pattern = new RegExp(`^\\s*(export\\s+)?${name}\\s*=`);
+        const index = lines.findIndex((line) => pattern.test(line));
+        if (value === undefined) {
+            if (index >= 0)
+                lines.splice(index, 1);
+            continue;
+        }
+        const next = `${name}=${value}`;
+        if (index >= 0)
+            lines[index] = next;
+        else
+            lines.push(next);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** True when .gitignore text already keeps this file out of git. */
+function gitignoreCovers(content, fileName) {
+    const base = path.basename(fileName);
+    const broad = base.startsWith(".env") ? [".env*", ".env.*", ".env*.local", ".env.*.local", "*.local"] : [];
+    return content.split(/\r?\n/).map((line) => line.trim().replace(/^\//, "")).some((line) => Boolean(line) && !line.startsWith("#") && !line.startsWith("!") && (line === base || broad.includes(line)));
+}
+function insideGitRepo(dir) {
+    for (let current = path.resolve(dir);; current = path.dirname(current)) {
+        if (fs.existsSync(path.join(current, ".git")))
+            return true;
+        if (path.dirname(current) === current)
+            return false;
+    }
+}
+/** Reads UNCOIL_* variables from env files into process.env without overriding values already set. Used by the CLI only. */
+function loadUncoilEnv(cwd, files = [".env.local", ".env"]) {
+    for (const file of files) {
+        let text;
+        try {
+            text = fs.readFileSync(path.resolve(cwd, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split(/\r?\n/)) {
+            const match = /^\s*(?:export\s+)?(UNCOIL_[A-Z0-9_]+)\s*=\s*(.*?)\s*$/.exec(line);
+            if (!match || process.env[match[1]] !== undefined)
+                continue;
+            process.env[match[1]] = match[2].replace(/^(["'])(.*)\1$/, "$2");
+        }
+    }
+}
+/** Adds the env file to .gitignore when this is a git repo that would otherwise commit the key. Returns true if it changed the file. */
+function ensureGitignored(dir, envFile) {
+    if (!insideGitRepo(dir))
+        return false;
+    const target = path.join(dir, ".gitignore");
+    const existing = fs.existsSync(target) ? fs.readFileSync(target, "utf8") : "";
+    if (gitignoreCovers(existing, envFile))
+        return false;
+    const prefix = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    fs.writeFileSync(target, `${existing}${prefix}${path.basename(envFile)}\n`);
+    return true;
+}
+/** Opens the address in the person's browser. Failure is fine: the address is always printed too. */
+function openBrowser(url) {
+    try {
+        const command = process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+        const child = (0, child_process_1.spawn)(command[0], [...command[1]], { stdio: "ignore", detached: true });
+        child.on("error", () => undefined);
+        child.unref();
+    }
+    catch { /* the printed address still works */ }
+}
+function decryptKey(privateKey, encrypted) {
+    return (0, crypto_1.privateDecrypt)({ key: privateKey, padding: crypto_1.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" }, Buffer.from(encrypted, "base64")).toString("utf8");
+}
+function loginHost(options) {
+    const envRegion = (process.env.UNCOIL_REGION ?? process.env.TRACIFY_REGION)?.trim().toLowerCase();
+    const region = options.region ?? (envRegion === "us" || envRegion === "eu" ? envRegion : "eu");
+    return { region, host: (options.host || (process.env.UNCOIL_HOST ?? process.env.TRACIFY_HOST) || index_1.UNCOIL_REGION_HOSTS[region]).replace(/\/$/, "") };
+}
+async function post(url, body) {
+    const response = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(15000) });
+    let data = null;
+    try {
+        data = await response.json();
+    }
+    catch { /* not JSON */ }
+    return { status: response.status, data };
+}
+/** Browser sign-in for the terminal. Never prints or logs the key; it is written only to the env file. */
+async function runLogin(options = {}) {
+    const out = options.out ?? ((line) => console.log(line));
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const now = options.now ?? Date.now;
+    const cwd = options.cwd ?? process.cwd();
+    const envFile = options.envFile ?? ".env.local";
+    const { region, host } = loginHost(options);
+    const say = (event, text, extra = {}) => out(options.json ? JSON.stringify({ event, ...extra, message: text }) : text);
+    const nodeMajor = Number(process.versions?.node?.split(".")[0]);
+    if (typeof fetch !== "function" || nodeMajor < 18)
+        return { ok: false, message: "Uncoil login needs Node 18 or newer." };
+    const { publicKey, privateKey } = (0, crypto_1.generateKeyPairSync)("rsa", { modulusLength: 2048 });
+    const spki = publicKey.export({ type: "spki", format: "der" }).toString("base64");
+    let started;
+    try {
+        started = await post(`${host}/api/cli/login/start`, { publicKey: spki, newProjectName: options.newProject });
+    }
+    catch (error) {
+        return { ok: false, message: `Could not reach ${host} (${error?.message ?? error}). Check your internet connection.` };
+    }
+    if (started.status === 429)
+        return { ok: false, message: started.data?.error || "Too many sign-in attempts. Try again in a few minutes." };
+    if (started.status !== 200 || !started.data?.deviceCode)
+        return { ok: false, message: started.data?.error || `Uncoil could not start the sign-in (${started.status}).` };
+    const { deviceCode, userCode, verificationUrl, expiresAt } = started.data;
+    const interval = Math.max(2, Number(started.data.interval) || 3) * 1000;
+    say("waiting", `Open this page to sign in: ${verificationUrl}\nCode: ${userCode}\nWaiting for you to confirm in the browser…`, { url: verificationUrl, code: userCode, expiresAt });
+    if (options.browser !== false)
+        (options.open ?? openBrowser)(verificationUrl);
+    let waitMs = interval;
+    while (now() < expiresAt + 120000) {
+        await sleep(waitMs);
+        let polled;
+        try {
+            polled = await post(`${host}/api/cli/login/poll`, { deviceCode });
+        }
+        catch {
+            continue;
+        }
+        if (polled.status === 429) {
+            waitMs = Math.min(waitMs * 2, 15000);
+            continue;
+        }
+        waitMs = interval;
+        const status = polled.data?.status;
+        if (status === "pending")
+            continue;
+        if (status === "denied")
+            return { ok: false, message: "Sign-in was cancelled in the browser." };
+        if (status === "expired" || polled.status >= 400)
+            return { ok: false, message: "The sign-in code expired. Run the command again." };
+        if (status === "approved") {
+            let apiKey;
+            try {
+                apiKey = decryptKey(privateKey, polled.data.encryptedKey);
+            }
+            catch {
+                return { ok: false, message: "Could not read the key Uncoil sent. Run the command again." };
+            }
+            const target = path.resolve(cwd, envFile);
+            const before = fs.existsSync(target) ? fs.readFileSync(target, "utf8") : "";
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, upsertEnv(before, { [KEY_NAME]: apiKey, [PROJECT_ID_NAME]: String(polled.data.projectId), [REGION_NAME]: region === "us" ? "us" : undefined }), { mode: 0o600 });
+            const ignored = ensureGitignored(path.dirname(target), envFile);
+            const projectName = String(polled.data.projectName ?? "");
+            const message = `Connected to project "${projectName}" (${region.toUpperCase()}). Key saved to ${envFile}.${ignored ? ` Added ${path.basename(envFile)} to .gitignore.` : ""}`;
+            say("connected", message, { projectId: String(polled.data.projectId), projectName, envFile });
+            return { ok: true, message, projectId: String(polled.data.projectId), projectName, envFile };
+        }
+    }
+    return { ok: false, message: "Timed out waiting for the browser. Run the command again." };
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@uncoil.dev/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.6.0",
+  "description": "Observability, runtime enforcement, and tracing for AI agents.",
+  "homepage": "https://www.uncoil.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Uncoil-dev/Uncoil.git",
+    "directory": "packages/ts-sdk"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "uncoil": "dist/cli.js",
+    "uncoil-doctor": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "bugs": {
+    "url": "https://github.com/Uncoil-dev/Uncoil/issues"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "observability",
+    "tracing",
+    "llm",
+    "llm-observability",
+    "agent-tracing",
+    "opentelemetry",
+    "cost-tracking",
+    "langchain",
+    "openai",
+    "anthropic"
+  ],
+  "author": "Uncoil Team",
+  "license": "MIT",
+  "sideEffects": false,
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.134.0",
+    "@langchain/core": "^1.2.17",
+    "@langchain/langgraph": "^1.5.0",
+    "@types/node": "^20.0.0",
+    "openai": "^7.34.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.10"
+  }
+}