@elizaos/autonomous 2.0.0-alpha.37

package/dist/packages/autonomous/src/api/whatsapp-routes.js

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readJsonBody as parseJsonBody, sendJson } from "./http-helpers";
+const MAX_BODY_BYTES = 1_048_576;
+export const MAX_PAIRING_SESSIONS = 10;
+async function readJsonBody(req, res) {
+    return parseJsonBody(req, res, { maxBytes: MAX_BODY_BYTES });
+}
+function json(res, data, status = 200) {
+    sendJson(res, data, status);
+}
+export async function handleWhatsAppRoute(req, res, pathname, method, state, deps) {
+    if (!pathname.startsWith("/api/whatsapp"))
+        return false;
+    if (method === "POST" && pathname === "/api/whatsapp/pair") {
+        const body = await readJsonBody(req, res);
+        let accountId;
+        try {
+            accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim()
+                ? body.accountId.trim()
+                : "default");
+        }
+        catch (err) {
+            json(res, { error: err.message }, 400);
+            return true;
+        }
+        const isReplacing = state.whatsappPairingSessions.has(accountId);
+        if (!isReplacing &&
+            state.whatsappPairingSessions.size >= MAX_PAIRING_SESSIONS) {
+            json(res, {
+                error: `Too many concurrent pairing sessions (max ${MAX_PAIRING_SESSIONS})`,
+            }, 429);
+            return true;
+        }
+        const authDir = path.join(state.workspaceDir, "whatsapp-auth", accountId);
+        state.whatsappPairingSessions.get(accountId)?.stop();
+        const session = deps.createWhatsAppPairingSession({
+            authDir,
+            accountId,
+            onEvent: (event) => {
+                state.broadcastWs?.(event);
+                if (event.status === "connected") {
+                    if (!state.config.connectors)
+                        state.config.connectors = {};
+                    state.config.connectors.whatsapp = {
+                        ...(state.config.connectors.whatsapp ?? {}),
+                        authDir,
+                        enabled: true,
+                    };
+                    try {
+                        state.saveConfig();
+                    }
+                    catch {
+                        /* test envs */
+                    }
+                }
+            },
+        });
+        state.whatsappPairingSessions.set(accountId, session);
+        try {
+            await session.start();
+            json(res, { ok: true, accountId, status: session.getStatus() });
+        }
+        catch (err) {
+            json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/whatsapp/status") {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        let accountId;
+        try {
+            accountId = deps.sanitizeAccountId(url.searchParams.get("accountId") || "default");
+        }
+        catch (err) {
+            json(res, { error: err.message }, 400);
+            return true;
+        }
+        const session = state.whatsappPairingSessions.get(accountId);
+        let serviceConnected = false;
+        let servicePhone = null;
+        if (state.runtime) {
+            try {
+                const waService = state.runtime.getService("whatsapp");
+                if (waService) {
+                    serviceConnected = Boolean(waService.connected);
+                    servicePhone = waService.phoneNumber ?? null;
+                }
+            }
+            catch {
+                /* service not yet registered */
+            }
+        }
+        json(res, {
+            accountId,
+            status: session?.getStatus() ?? "idle",
+            authExists: deps.whatsappAuthExists(state.workspaceDir, accountId),
+            serviceConnected,
+            servicePhone,
+        });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/whatsapp/pair/stop") {
+        const body = await readJsonBody(req, res);
+        let accountId;
+        try {
+            accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim()
+                ? body.accountId.trim()
+                : "default");
+        }
+        catch (err) {
+            json(res, { error: err.message }, 400);
+            return true;
+        }
+        const session = state.whatsappPairingSessions.get(accountId);
+        if (session) {
+            session.stop();
+            state.whatsappPairingSessions.delete(accountId);
+        }
+        json(res, { ok: true, accountId, status: "idle" });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/whatsapp/disconnect") {
+        const body = await readJsonBody(req, res);
+        let accountId;
+        try {
+            accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim()
+                ? body.accountId.trim()
+                : "default");
+        }
+        catch (err) {
+            json(res, { error: err.message }, 400);
+            return true;
+        }
+        const session = state.whatsappPairingSessions.get(accountId);
+        if (session) {
+            session.stop();
+            state.whatsappPairingSessions.delete(accountId);
+        }
+        try {
+            await deps.whatsappLogout(state.workspaceDir, accountId);
+        }
+        catch (logoutErr) {
+            console.warn(`[whatsapp] Logout failed for ${accountId}, deleting auth files directly:`, logoutErr instanceof Error ? logoutErr.message : String(logoutErr));
+            const authDir = path.join(state.workspaceDir, "whatsapp-auth", accountId);
+            try {
+                fs.rmSync(authDir, { recursive: true, force: true });
+            }
+            catch {
+                /* may not exist */
+            }
+        }
+        if (state.config.connectors) {
+            delete state.config.connectors.whatsapp;
+            try {
+                state.saveConfig();
+            }
+            catch {
+                /* test envs */
+            }
+        }
+        json(res, { ok: true, accountId });
+        return true;
+    }
+    return false;
+}
+export function applyWhatsAppQrOverride(plugins, workspaceDir) {
+    try {
+        const waCredsPath = path.join(workspaceDir, "whatsapp-auth", "default", "creds.json");
+        if (fs.existsSync(waCredsPath)) {
+            const waPlugin = plugins.find((plugin) => plugin.id === "whatsapp");
+            if (waPlugin) {
+                waPlugin.validationErrors = [];
+                waPlugin.configured = true;
+                waPlugin.qrConnected = true;
+            }
+        }
+    }
+    catch {
+        /* workspace dir may not exist */
+    }
+}

package/dist/packages/autonomous/src/api/zip-utils.d.ts

@@ -0,0 +1,8 @@
+interface ZipEntryInput {
+    name: string;
+    data: Buffer | Uint8Array | string;
+    mtime?: Date;
+}
+export declare function createZipArchive(entries: ZipEntryInput[]): Buffer;
+export {};
+//# sourceMappingURL=zip-utils.d.ts.map

package/dist/packages/autonomous/src/api/zip-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-utils.d.ts","sourceRoot":"","sources":["../../../../../src/api/zip-utils.ts"],"names":[],"mappings":"AAAA,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IACnC,KAAK,CAAC,EAAE,IAAI,CAAC;CACd;AA0DD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM,CAmEjE"}

package/dist/packages/autonomous/src/api/zip-utils.js

@@ -0,0 +1,115 @@
+const CRC32_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i += 1) {
+    let crc = i;
+    for (let j = 0; j < 8; j += 1) {
+        if ((crc & 1) === 1) {
+            crc = (crc >>> 1) ^ 0xedb88320;
+        }
+        else {
+            crc >>>= 1;
+        }
+    }
+    CRC32_TABLE[i] = crc >>> 0;
+}
+function normalizeZipEntryName(name) {
+    const normalized = name.replaceAll("\\", "/").replace(/^\/+/, "");
+    if (!normalized)
+        throw new Error("ZIP entry name cannot be empty");
+    if (normalized.includes("\0")) {
+        throw new Error("ZIP entry name contains invalid null byte");
+    }
+    const parts = normalized.split("/");
+    for (const part of parts) {
+        if (part === "." || part === "..") {
+            throw new Error(`ZIP entry name is not safe: ${name}`);
+        }
+    }
+    return normalized;
+}
+function toBuffer(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (typeof data === "string")
+        return Buffer.from(data, "utf-8");
+    return Buffer.from(data);
+}
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        const index = (crc ^ byte) & 0xff;
+        crc = (crc >>> 8) ^ (CRC32_TABLE[index] ?? 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function toDosDateTime(date) {
+    const year = Math.min(Math.max(date.getFullYear(), 1980), 2107);
+    const month = Math.min(Math.max(date.getMonth() + 1, 1), 12);
+    const day = Math.min(Math.max(date.getDate(), 1), 31);
+    const hours = Math.min(Math.max(date.getHours(), 0), 23);
+    const minutes = Math.min(Math.max(date.getMinutes(), 0), 59);
+    const seconds = Math.min(Math.max(Math.floor(date.getSeconds() / 2), 0), 29);
+    const dosDate = ((year - 1980) << 9) | (month << 5) | day;
+    const dosTime = (hours << 11) | (minutes << 5) | seconds;
+    return { date: dosDate & 0xffff, time: dosTime & 0xffff };
+}
+export function createZipArchive(entries) {
+    if (entries.length > 0xffff) {
+        throw new Error("ZIP export supports up to 65535 files");
+    }
+    const fileParts = [];
+    const centralDirectoryParts = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = normalizeZipEntryName(entry.name);
+        const nameBuffer = Buffer.from(name, "utf-8");
+        const dataBuffer = toBuffer(entry.data);
+        const checksum = crc32(dataBuffer);
+        const { date, time } = toDosDateTime(entry.mtime ?? new Date());
+        const localHeader = Buffer.alloc(30 + nameBuffer.length);
+        localHeader.writeUInt32LE(0x04034b50, 0); // local file header signature
+        localHeader.writeUInt16LE(20, 4); // version needed to extract
+        localHeader.writeUInt16LE(0, 6); // general purpose bit flag
+        localHeader.writeUInt16LE(0, 8); // compression method: store
+        localHeader.writeUInt16LE(time, 10);
+        localHeader.writeUInt16LE(date, 12);
+        localHeader.writeUInt32LE(checksum, 14);
+        localHeader.writeUInt32LE(dataBuffer.length, 18); // compressed size
+        localHeader.writeUInt32LE(dataBuffer.length, 22); // uncompressed size
+        localHeader.writeUInt16LE(nameBuffer.length, 26);
+        localHeader.writeUInt16LE(0, 28); // extra field length
+        nameBuffer.copy(localHeader, 30);
+        const centralHeader = Buffer.alloc(46 + nameBuffer.length);
+        centralHeader.writeUInt32LE(0x02014b50, 0); // central file header signature
+        centralHeader.writeUInt16LE(20, 4); // version made by
+        centralHeader.writeUInt16LE(20, 6); // version needed to extract
+        centralHeader.writeUInt16LE(0, 8); // general purpose bit flag
+        centralHeader.writeUInt16LE(0, 10); // compression method: store
+        centralHeader.writeUInt16LE(time, 12);
+        centralHeader.writeUInt16LE(date, 14);
+        centralHeader.writeUInt32LE(checksum, 16);
+        centralHeader.writeUInt32LE(dataBuffer.length, 20); // compressed size
+        centralHeader.writeUInt32LE(dataBuffer.length, 24); // uncompressed size
+        centralHeader.writeUInt16LE(nameBuffer.length, 28);
+        centralHeader.writeUInt16LE(0, 30); // extra field length
+        centralHeader.writeUInt16LE(0, 32); // file comment length
+        centralHeader.writeUInt16LE(0, 34); // disk number start
+        centralHeader.writeUInt16LE(0, 36); // internal file attrs
+        centralHeader.writeUInt32LE(0, 38); // external file attrs
+        centralHeader.writeUInt32LE(offset, 42); // relative offset of local header
+        nameBuffer.copy(centralHeader, 46);
+        fileParts.push(localHeader, dataBuffer);
+        centralDirectoryParts.push(centralHeader);
+        offset += localHeader.length + dataBuffer.length;
+    }
+    const centralDirectory = Buffer.concat(centralDirectoryParts);
+    const endOfCentralDirectory = Buffer.alloc(22);
+    endOfCentralDirectory.writeUInt32LE(0x06054b50, 0); // EOCD signature
+    endOfCentralDirectory.writeUInt16LE(0, 4); // number of this disk
+    endOfCentralDirectory.writeUInt16LE(0, 6); // disk where central directory starts
+    endOfCentralDirectory.writeUInt16LE(entries.length, 8); // number of central dir records on this disk
+    endOfCentralDirectory.writeUInt16LE(entries.length, 10); // total number of records
+    endOfCentralDirectory.writeUInt32LE(centralDirectory.length, 12);
+    endOfCentralDirectory.writeUInt32LE(offset, 16); // offset of central directory
+    endOfCentralDirectory.writeUInt16LE(0, 20); // comment length
+    return Buffer.concat([...fileParts, centralDirectory, endOfCentralDirectory]);
+}

package/dist/packages/autonomous/src/auth/anthropic.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Anthropic OAuth flow (Claude Pro/Max subscription)
+ *
+ * Wraps @mariozechner/pi-ai's loginAnthropic for server-side use.
+ * The pi-ai callback API is adapted to a start/exchange pattern
+ * for HTTP route handlers.
+ */
+import type { OAuthCredentials } from "./types";
+export interface AnthropicFlow {
+    authUrl: string;
+    /** Provide the authorization code (format: code#state) to complete the flow */
+    submitCode: (code: string) => void;
+    /** Resolves with credentials once submitCode() is called */
+    credentials: Promise<OAuthCredentials>;
+}
+/**
+ * Start the Anthropic OAuth flow.
+ * Returns an auth URL and a way to submit the code + get credentials.
+ */
+export declare function startAnthropicLogin(): Promise<AnthropicFlow>;
+/**
+ * Refresh an expired Anthropic token.
+ */
+export declare function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials>;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/packages/autonomous/src/auth/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../../../src/auth/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,4DAA4D;IAC5D,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACxC;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC,CA2BlE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/dist/packages/autonomous/src/auth/anthropic.js

@@ -0,0 +1,40 @@
+/**
+ * Anthropic OAuth flow (Claude Pro/Max subscription)
+ *
+ * Wraps @mariozechner/pi-ai's loginAnthropic for server-side use.
+ * The pi-ai callback API is adapted to a start/exchange pattern
+ * for HTTP route handlers.
+ */
+import { refreshAnthropicToken as _refreshAnthropicToken, loginAnthropic, } from "@mariozechner/pi-ai";
+/**
+ * Start the Anthropic OAuth flow.
+ * Returns an auth URL and a way to submit the code + get credentials.
+ */
+export async function startAnthropicLogin() {
+    let authUrl = "";
+    let resolveCode = null;
+    let resolveUrlReady = null;
+    const codePromise = new Promise((resolve) => {
+        resolveCode = resolve;
+    });
+    const urlReady = new Promise((resolve) => {
+        resolveUrlReady = resolve;
+    });
+    const credentials = loginAnthropic((url) => {
+        authUrl = url;
+        resolveUrlReady?.();
+    }, () => codePromise);
+    // Wait for the onAuthUrl callback to fire before returning
+    await urlReady;
+    return {
+        authUrl,
+        submitCode: (code) => resolveCode?.(code),
+        credentials,
+    };
+}
+/**
+ * Refresh an expired Anthropic token.
+ */
+export async function refreshAnthropicToken(refreshToken) {
+    return _refreshAnthropicToken(refreshToken);
+}

package/dist/packages/autonomous/src/auth/apply-stealth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Walk up from `startDir` until we find a directory containing package.json
+ * with name "miladyai". Returns the directory path, or falls back to `startDir`.
+ */
+/** @internal Exported for testing only. */
+export declare function findProjectRoot(startDir: string): string;
+export declare function applyClaudeCodeStealth(): void;
+//# sourceMappingURL=apply-stealth.d.ts.map

package/dist/packages/autonomous/src/auth/apply-stealth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-stealth.d.ts","sourceRoot":"","sources":["../../../../../src/auth/apply-stealth.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBxD;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAO7C"}

package/dist/packages/autonomous/src/auth/apply-stealth.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { installClaudeCodeStealthFetchInterceptor } from "./claude-code-stealth";
+/**
+ * Walk up from `startDir` until we find a directory containing package.json
+ * with name "miladyai". Returns the directory path, or falls back to `startDir`.
+ */
+/** @internal Exported for testing only. */
+export function findProjectRoot(startDir) {
+    let dir = startDir;
+    const { root } = path.parse(dir);
+    while (dir !== root) {
+        const pkgPath = path.join(dir, "package.json");
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (typeof pkg.name === "string" &&
+                pkg.name.toLowerCase() === "miladyai") {
+                return dir;
+            }
+        }
+        catch {
+            /* keep searching */
+        }
+        dir = path.dirname(dir);
+    }
+    return startDir;
+}
+export function applyClaudeCodeStealth() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey?.startsWith("sk-ant-oat")) {
+        return;
+    }
+    installClaudeCodeStealthFetchInterceptor();
+}

package/dist/packages/autonomous/src/auth/claude-code-stealth.d.ts

@@ -0,0 +1,2 @@
+export declare function installClaudeCodeStealthFetchInterceptor(): void;
+//# sourceMappingURL=claude-code-stealth.d.ts.map

package/dist/packages/autonomous/src/auth/claude-code-stealth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code-stealth.d.ts","sourceRoot":"","sources":["../../../../../src/auth/claude-code-stealth.ts"],"names":[],"mappings":"AAqDA,wBAAgB,wCAAwC,IAAI,IAAI,CAuF/D"}

package/dist/packages/autonomous/src/auth/claude-code-stealth.js

@@ -0,0 +1,104 @@
+const STEALTH_GUARD = Symbol.for("milady.claudeCodeStealthInstalled");
+const CLAUDE_CODE_VERSION = "2.1.2";
+const CLAUDE_CODE_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+const ANTHROPIC_BETA = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
+function isSetupToken(value) {
+    return typeof value === "string" && value.startsWith("sk-ant-oat");
+}
+function getUrl(input) {
+    try {
+        if (typeof input === "string") {
+            return new URL(input);
+        }
+        if (input instanceof URL) {
+            return input;
+        }
+        return new URL(input.url);
+    }
+    catch {
+        return null;
+    }
+}
+function addSystemPrefix(body) {
+    if (!body || typeof body !== "object") {
+        return body;
+    }
+    const next = body;
+    const prefix = { type: "text", text: CLAUDE_CODE_SYSTEM_PREFIX };
+    if (Array.isArray(next.system)) {
+        const hasPrefix = next.system.some((block) => block?.text?.startsWith("You are Claude Code"));
+        if (!hasPrefix) {
+            next.system.unshift(prefix);
+        }
+    }
+    else if (typeof next.system === "string") {
+        next.system = [prefix, { type: "text", text: next.system }];
+    }
+    else {
+        next.system = [prefix];
+    }
+    return next;
+}
+export function installClaudeCodeStealthFetchInterceptor() {
+    if (globalThis[STEALTH_GUARD]) {
+        return;
+    }
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    const stealthFetch = async function stealthFetch(input, init) {
+        const url = getUrl(input);
+        if (!url || url.hostname !== "api.anthropic.com") {
+            return originalFetch(input, init);
+        }
+        const request = input instanceof Request ? input : null;
+        const headers = new Headers(init?.headers ?? request?.headers ?? undefined);
+        const apiKey = headers.get("x-api-key");
+        const authHeader = headers.get("authorization");
+        const bearerToken = authHeader?.startsWith("Bearer ")
+            ? authHeader.slice(7)
+            : null;
+        const setupToken = isSetupToken(apiKey)
+            ? apiKey
+            : isSetupToken(bearerToken)
+                ? bearerToken
+                : null;
+        if (!setupToken) {
+            return originalFetch(input, init);
+        }
+        headers.delete("x-api-key");
+        headers.set("authorization", `Bearer ${setupToken}`);
+        headers.set("anthropic-beta", ANTHROPIC_BETA);
+        headers.set("user-agent", `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`);
+        headers.set("x-app", "cli");
+        let body = init?.body ?? request?.body;
+        if (typeof body === "string") {
+            try {
+                const parsed = JSON.parse(body);
+                const updated = addSystemPrefix(parsed);
+                body = JSON.stringify(updated);
+                console.log(`[stealth] Patched Anthropic request for ${String(updated.model ?? "unknown-model")}`);
+            }
+            catch {
+                console.log("[stealth] Anthropic request body was not JSON; skipping system prefix");
+            }
+        }
+        const nextInit = {
+            ...init,
+            headers,
+            body: init ? body : undefined,
+        };
+        if (request && !init) {
+            const nextRequest = new Request(request, {
+                headers,
+                body: typeof body === "string" ? body : undefined,
+            });
+            return originalFetch(nextRequest);
+        }
+        return originalFetch(input, nextInit);
+    };
+    if ("preconnect" in globalThis.fetch) {
+        stealthFetch.preconnect = globalThis.fetch.preconnect;
+    }
+    globalThis.fetch = stealthFetch;
+    globalThis[STEALTH_GUARD] = true;
+    console.log("[stealth] Claude Code setup token runtime support enabled");
+}

package/dist/packages/autonomous/src/auth/credentials.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Credential storage and token refresh for subscription providers.
+ *
+ * Stores OAuth credentials in ~/.milady/auth/ as JSON files.
+ */
+import { type OAuthCredentials, type StoredCredentials, type SubscriptionProvider } from "./types";
+/**
+ * Save credentials for a provider.
+ */
+export declare function saveCredentials(provider: SubscriptionProvider, credentials: OAuthCredentials): void;
+/**
+ * Load stored credentials for a provider.
+ */
+export declare function loadCredentials(provider: SubscriptionProvider): StoredCredentials | null;
+/**
+ * Delete stored credentials for a provider.
+ */
+export declare function deleteCredentials(provider: SubscriptionProvider): void;
+/**
+ * Check if credentials exist and are not expired.
+ */
+export declare function hasValidCredentials(provider: SubscriptionProvider): boolean;
+/**
+ * Get a valid access token, refreshing if needed.
+ * Returns null if no credentials stored or refresh fails.
+ */
+export declare function getAccessToken(provider: SubscriptionProvider): Promise<string | null>;
+/**
+ * Get all configured subscription providers and their status.
+ */
+export declare function getSubscriptionStatus(): Array<{
+    provider: SubscriptionProvider;
+    configured: boolean;
+    valid: boolean;
+    expiresAt: number | null;
+}>;
+/**
+ * Apply subscription credentials to the environment.
+ * Called at startup to make credentials available to elizaOS plugins.
+ *
+ * When a `config` is provided and the active subscription provider has
+ * credentials, `model.primary` is auto-set so the user doesn't need to
+ * configure it manually.
+ */
+export declare function applySubscriptionCredentials(config?: {
+    agents?: {
+        defaults?: {
+            subscriptionProvider?: string;
+            model?: {
+                primary?: string;
+            };
+        };
+    };
+}): Promise<void>;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/packages/autonomous/src/auth/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../../../../src/auth/credentials.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEtB,KAAK,oBAAoB,EAC1B,MAAM,SAAS,CAAC;AAoBjB;;GAEG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,oBAAoB,EAC9B,WAAW,EAAE,gBAAgB,GAC5B,IAAI,CAaN;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,oBAAoB,GAC7B,iBAAiB,GAAG,IAAI,CAW1B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAUtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAI3E;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+BxB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,KAAK,CAAC;IAC7C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC,CAcD;AAED;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAAC,MAAM,CAAC,EAAE;IAC1D,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE;YAAE,oBAAoB,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE;gBAAE,OAAO,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAC;KAC5E,CAAC;CACH,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDhB"}