@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/auth/credentials.js

@@ -0,0 +1,182 @@
+/**
+ * Credential storage and token refresh for subscription providers.
+ *
+ * Stores OAuth credentials in ~/.eliza/auth/ as JSON files.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { refreshAnthropicToken } from "./anthropic";
+import { refreshCodexToken } from "./openai-codex";
+import { SUBSCRIPTION_PROVIDER_MAP, } from "./types";
+const AUTH_DIR = path.join(process.env.ELIZA_HOME || path.join(os.homedir(), ".eliza"), "auth");
+/** Buffer before expiry to trigger refresh (5 minutes) */
+const REFRESH_BUFFER_MS = 5 * 60 * 1000;
+function ensureAuthDir() {
+    if (!fs.existsSync(AUTH_DIR)) {
+        fs.mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function credentialPath(provider) {
+    return path.join(AUTH_DIR, `${provider}.json`);
+}
+/**
+ * Save credentials for a provider.
+ */
+export function saveCredentials(provider, credentials) {
+    ensureAuthDir();
+    const stored = {
+        provider,
+        credentials,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    fs.writeFileSync(credentialPath(provider), JSON.stringify(stored, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    logger.info(`[auth] Saved ${provider} credentials`);
+}
+/**
+ * Load stored credentials for a provider.
+ */
+export function loadCredentials(provider) {
+    const filePath = credentialPath(provider);
+    try {
+        const data = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+/**
+ * Delete stored credentials for a provider.
+ */
+export function deleteCredentials(provider) {
+    const filePath = credentialPath(provider);
+    try {
+        fs.unlinkSync(filePath);
+        logger.info(`[auth] Deleted ${provider} credentials`);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+}
+/**
+ * Check if credentials exist and are not expired.
+ */
+export function hasValidCredentials(provider) {
+    const stored = loadCredentials(provider);
+    if (!stored)
+        return false;
+    return stored.credentials.expires > Date.now();
+}
+/**
+ * Get a valid access token, refreshing if needed.
+ * Returns null if no credentials stored or refresh fails.
+ */
+export async function getAccessToken(provider) {
+    const stored = loadCredentials(provider);
+    if (!stored)
+        return null;
+    const { credentials } = stored;
+    // Token still valid
+    if (credentials.expires > Date.now() + REFRESH_BUFFER_MS) {
+        return credentials.access;
+    }
+    // Need to refresh
+    logger.info(`[auth] Refreshing ${provider} token...`);
+    try {
+        let refreshed;
+        if (provider === "anthropic-subscription") {
+            refreshed = await refreshAnthropicToken(credentials.refresh);
+        }
+        else if (provider === "openai-codex") {
+            refreshed = await refreshCodexToken(credentials.refresh);
+        }
+        else {
+            logger.error(`[auth] Unknown provider: ${provider}`);
+            return null;
+        }
+        // Save refreshed credentials
+        saveCredentials(provider, refreshed);
+        return refreshed.access;
+    }
+    catch (err) {
+        logger.error(`[auth] Failed to refresh ${provider} token: ${err}`);
+        return null;
+    }
+}
+/**
+ * Get all configured subscription providers and their status.
+ */
+export function getSubscriptionStatus() {
+    const providers = [
+        "anthropic-subscription",
+        "openai-codex",
+    ];
+    return providers.map((provider) => {
+        const stored = loadCredentials(provider);
+        return {
+            provider,
+            configured: stored !== null,
+            valid: stored ? stored.credentials.expires > Date.now() : false,
+            expiresAt: stored?.credentials.expires ?? 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 async function applySubscriptionCredentials(config) {
+    // Anthropic subscription → set ANTHROPIC_API_KEY
+    const anthropicToken = await getAccessToken("anthropic-subscription");
+    if (anthropicToken) {
+        process.env.ANTHROPIC_API_KEY = anthropicToken;
+        logger.info("[auth] Applied Anthropic subscription credentials to environment");
+        // Install Claude stealth interceptor (non-fatal)
+        try {
+            const { applyClaudeCodeStealth } = await import("./apply-stealth");
+            applyClaudeCodeStealth();
+        }
+        catch (err) {
+            logger.warn(`[auth] Failed to apply Claude stealth: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // OpenAI Codex subscription → set OPENAI_API_KEY
+    const codexToken = await getAccessToken("openai-codex");
+    if (codexToken) {
+        process.env.OPENAI_API_KEY = codexToken;
+        logger.info("[auth] Applied OpenAI Codex subscription credentials to environment");
+    }
+    // Auto-set model.primary from subscription provider when not explicitly
+    // configured, so users who connect a subscription don't need to manually
+    // choose a model provider.
+    if (config?.agents?.defaults) {
+        const defaults = config.agents.defaults;
+        const provider = defaults.subscriptionProvider;
+        const modelId = provider ? SUBSCRIPTION_PROVIDER_MAP[provider] : undefined;
+        if (modelId) {
+            if (!defaults.model) {
+                defaults.model = { primary: modelId };
+                logger.info(`[auth] Auto-set model.primary to "${modelId}" from subscription provider`);
+            }
+            else if (!defaults.model.primary) {
+                defaults.model.primary = modelId;
+                logger.info(`[auth] Auto-set model.primary to "${modelId}" from subscription provider`);
+            }
+        }
+    }
+}

package/packages/agent/src/auth/index.d.ts

@@ -0,0 +1,7 @@
+export type { AnthropicFlow } from "./anthropic";
+export { refreshAnthropicToken, startAnthropicLogin } from "./anthropic";
+export { applySubscriptionCredentials, deleteCredentials, getAccessToken, getSubscriptionStatus, hasValidCredentials, loadCredentials, saveCredentials, } from "./credentials";
+export type { CodexFlow } from "./openai-codex";
+export { refreshCodexToken, startCodexLogin } from "./openai-codex";
+export type { OAuthCredentials, StoredCredentials, SubscriptionProvider, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/auth/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EACL,4BAA4B,EAC5B,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,eAAe,GAChB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACpE,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/packages/agent/src/auth/index.js

@@ -0,0 +1,3 @@
+export { refreshAnthropicToken, startAnthropicLogin } from "./anthropic";
+export { applySubscriptionCredentials, deleteCredentials, getAccessToken, getSubscriptionStatus, hasValidCredentials, loadCredentials, saveCredentials, } from "./credentials";
+export { refreshCodexToken, startCodexLogin } from "./openai-codex";

package/packages/agent/src/auth/openai-codex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAI Codex (ChatGPT Plus/Pro subscription) OAuth flow
+ *
+ * Wraps @mariozechner/pi-ai's loginOpenAICodex for server-side use.
+ * Handles local callback server + manual code paste fallback.
+ */
+import type { OAuthCredentials } from "./types";
+export interface CodexFlow {
+    authUrl: string;
+    state: string;
+    /** Submit a manually-pasted code/URL */
+    submitCode: (code: string) => void;
+    /** Wait for credentials (either via callback server or manual code) */
+    credentials: Promise<OAuthCredentials>;
+    /** Close the callback server */
+    close: () => void;
+}
+/**
+ * Start the OpenAI Codex OAuth flow.
+ * Starts a local callback server on port 1455 and returns the auth URL.
+ */
+export declare function startCodexLogin(): Promise<CodexFlow>;
+/**
+ * Refresh an expired OpenAI Codex token.
+ */
+export declare function refreshCodexToken(refreshToken: string): Promise<OAuthCredentials>;
+//# sourceMappingURL=openai-codex.d.ts.map

package/packages/agent/src/auth/openai-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-codex.d.ts","sourceRoot":"","sources":["../../../../../src/auth/openai-codex.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvC,gCAAgC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAwDpD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/packages/agent/src/auth/openai-codex.js

@@ -0,0 +1,72 @@
+/**
+ * OpenAI Codex (ChatGPT Plus/Pro subscription) OAuth flow
+ *
+ * Wraps @mariozechner/pi-ai's loginOpenAICodex for server-side use.
+ * Handles local callback server + manual code paste fallback.
+ */
+import { refreshOpenAICodexToken as _refreshOpenAICodexToken, loginOpenAICodex, } from "@mariozechner/pi-ai";
+/**
+ * Start the OpenAI Codex OAuth flow.
+ * Starts a local callback server on port 1455 and returns the auth URL.
+ */
+export function startCodexLogin() {
+    return new Promise((resolveFlow, rejectFlow) => {
+        let authUrl = "";
+        let flowState = "";
+        let resolveManual = null;
+        let closeServer = null;
+        let credentials;
+        const manualPromise = new Promise((resolve) => {
+            resolveManual = resolve;
+        });
+        try {
+            credentials = loginOpenAICodex({
+                onAuth: ({ url }) => {
+                    authUrl = url;
+                    // Extract state from URL
+                    try {
+                        const parsed = new URL(url);
+                        flowState = parsed.searchParams.get("state") || "";
+                    }
+                    catch {
+                        /* */
+                    }
+                    resolveFlow({
+                        get authUrl() {
+                            return authUrl;
+                        },
+                        state: flowState,
+                        submitCode: (code) => resolveManual?.(code),
+                        credentials,
+                        close: () => closeServer?.(),
+                    });
+                },
+                onPrompt: async () => {
+                    // This is called when the callback server times out
+                    // Wait for manual code submission
+                    return manualPromise;
+                },
+                onManualCodeInput: () => manualPromise,
+                onProgress: () => { },
+                originator: "eliza",
+            });
+            // Prevent unhandled rejections even if no one awaits this promise.
+            void credentials.catch(() => { });
+        }
+        catch (err) {
+            rejectFlow(err);
+            return;
+        }
+        // Capture close from the finally block — pi-ai closes server internally
+        // We just need to cancel the manual wait if needed
+        closeServer = () => {
+            resolveManual?.("");
+        };
+    });
+}
+/**
+ * Refresh an expired OpenAI Codex token.
+ */
+export async function refreshCodexToken(refreshToken) {
+    return _refreshOpenAICodexToken(refreshToken);
+}

package/packages/agent/src/auth/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Subscription auth types for eliza.
+ */
+export interface OAuthCredentials {
+    access: string;
+    refresh: string;
+    expires: number;
+}
+export type SubscriptionProvider = "anthropic-subscription" | "openai-codex";
+/** Maps subscription provider IDs to their model provider short names. */
+export declare const SUBSCRIPTION_PROVIDER_MAP: Record<SubscriptionProvider, string>;
+export interface StoredCredentials {
+    provider: SubscriptionProvider;
+    credentials: OAuthCredentials;
+    createdAt: number;
+    updatedAt: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/agent/src/auth/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/auth/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,oBAAoB,GAAG,wBAAwB,GAAG,cAAc,CAAC;AAE7E,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAG1E,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/packages/agent/src/auth/types.js

@@ -0,0 +1,8 @@
+/**
+ * Subscription auth types for eliza.
+ */
+/** Maps subscription provider IDs to their model provider short names. */
+export const SUBSCRIPTION_PROVIDER_MAP = {
+    "anthropic-subscription": "anthropic",
+    "openai-codex": "openai",
+};

package/packages/agent/src/awareness/registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * AwarenessRegistry — core orchestration layer for the Self-Awareness System.
+ *
+ * Manages contributor registration, summary composition (Layer 1),
+ * detail retrieval (Layer 2), caching, sanitization, and invalidation.
+ *
+ * @architecture All public methods are fault-tolerant: individual contributor
+ * errors are captured and surfaced as `[{id}: unavailable]` markers — the
+ * registry itself NEVER throws from composeSummary / getDetail.
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+import { type AwarenessContributor, type AwarenessInvalidationEvent } from "../contracts/awareness";
+export declare function setGlobalAwarenessRegistry(registry: AwarenessRegistry): void;
+export declare function getGlobalAwarenessRegistry(): AwarenessRegistry | null;
+export declare class AwarenessRegistry {
+    private readonly contributors;
+    private readonly contributorIds;
+    private readonly cache;
+    register(contributor: AwarenessContributor): void;
+    composeSummary(runtime: IAgentRuntime): Promise<string>;
+    getDetail(runtime: IAgentRuntime, module: string, level: "brief" | "full"): Promise<string>;
+    invalidate(event: AwarenessInvalidationEvent): void;
+    private getCachedSummary;
+    private applyGlobalBudget;
+    private composeAllDetails;
+}
+//# sourceMappingURL=registry.d.ts.map

package/packages/agent/src/awareness/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../src/awareness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAKhC,MAAM,wBAAwB,CAAC;AA4BhC,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAE5E;AAED,wBAAgB,0BAA0B,IAAI,iBAAiB,GAAG,IAAI,CAErE;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IAEvD,QAAQ,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI;IAiB3C,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA0BvD,SAAS,CACb,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GAAG,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC;IAuBlB,UAAU,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI;YAQrC,gBAAgB;IAoB9B,OAAO,CAAC,iBAAiB;YAuCX,iBAAiB;CAuBhC"}

package/packages/agent/src/awareness/registry.js

@@ -0,0 +1,161 @@
+import { DEFAULT_CACHE_TTL_MS, SELF_STATUS_SCHEMA_VERSION, SUMMARY_CHAR_LIMIT, SUMMARY_TOTAL_CHAR_LIMIT, } from "../contracts/awareness";
+const SANITIZE_PATTERNS = [
+    /sk-ant-\S+/gi,
+    /sk-\S{20,}/gi,
+    /gsk_\S+/gi,
+    /xai-\S+/gi,
+    /0x[a-fA-F0-9]{64}/gi,
+    /[a-fA-F0-9]{64,}/gi,
+    /ignore\s+(all\s+)?(previous\s+)?instructions/gi,
+    /you are now/gi,
+];
+function sanitize(input) {
+    let output = input;
+    for (const pattern of SANITIZE_PATTERNS) {
+        output = output.replace(pattern, "[REDACTED]");
+    }
+    return output;
+}
+let _globalRegistry = null;
+export function setGlobalAwarenessRegistry(registry) {
+    _globalRegistry = registry;
+}
+export function getGlobalAwarenessRegistry() {
+    return _globalRegistry;
+}
+export class AwarenessRegistry {
+    contributors = [];
+    contributorIds = new Set();
+    cache = new Map();
+    register(contributor) {
+        if (this.contributorIds.has(contributor.id)) {
+            throw new Error(`AwarenessRegistry: duplicate contributor id "${contributor.id}"`);
+        }
+        this.contributorIds.add(contributor.id);
+        const idx = this.contributors.findIndex((c) => c.position > contributor.position);
+        if (idx === -1) {
+            this.contributors.push(contributor);
+        }
+        else {
+            this.contributors.splice(idx, 0, contributor);
+        }
+    }
+    async composeSummary(runtime) {
+        const lines = [];
+        for (const contributor of this.contributors) {
+            let line;
+            try {
+                line = await this.getCachedSummary(contributor, runtime);
+            }
+            catch {
+                line = `[${contributor.id}: unavailable]`;
+            }
+            if (line === "")
+                continue;
+            if (contributor.trusted !== true) {
+                line = sanitize(line);
+            }
+            if (line.length > SUMMARY_CHAR_LIMIT) {
+                line = `${line.slice(0, SUMMARY_CHAR_LIMIT - 3)}...`;
+            }
+            lines.push(line);
+        }
+        const header = `[Self Status v${SELF_STATUS_SCHEMA_VERSION}]`;
+        return this.applyGlobalBudget(lines, header);
+    }
+    async getDetail(runtime, module, level) {
+        if (module === "all") {
+            return this.composeAllDetails(runtime, level);
+        }
+        const contributor = this.contributors.find((c) => c.id === module);
+        if (!contributor) {
+            const available = this.contributors.map((c) => c.id).join(", ");
+            return `[Error: unknown module "${module}". Available: ${available}]`;
+        }
+        if (!contributor.detail) {
+            return `[${contributor.id}: no detail available]`;
+        }
+        try {
+            const detail = await contributor.detail(runtime, level);
+            return contributor.trusted !== true ? sanitize(detail) : detail;
+        }
+        catch {
+            return `[${contributor.id}: unavailable]`;
+        }
+    }
+    invalidate(event) {
+        for (const contributor of this.contributors) {
+            if (contributor.invalidateOn?.includes(event)) {
+                this.cache.delete(contributor.id);
+            }
+        }
+    }
+    async getCachedSummary(contributor, runtime) {
+        const ttl = contributor.cacheTtl ?? DEFAULT_CACHE_TTL_MS;
+        const cached = this.cache.get(contributor.id);
+        const now = Date.now();
+        if (cached && cached.expiresAt > now) {
+            return cached.value;
+        }
+        const value = await contributor.summary(runtime);
+        this.cache.set(contributor.id, {
+            value,
+            expiresAt: now + ttl,
+        });
+        return value;
+    }
+    applyGlobalBudget(lines, header) {
+        const headerLen = header.length + 1;
+        let budget = SUMMARY_TOTAL_CHAR_LIMIT - headerLen;
+        const included = [];
+        let remaining = 0;
+        let bodyLen = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = lines[i].length + 1;
+            if (budget >= lineLen) {
+                bodyLen =
+                    included.length === 0
+                        ? lines[i].length
+                        : bodyLen + 1 + lines[i].length;
+                included.push(lines[i]);
+                budget -= lineLen;
+            }
+            else {
+                remaining = lines.length - i;
+                break;
+            }
+        }
+        if (remaining > 0) {
+            let suffix = `\n[+${remaining} more]`;
+            while (bodyLen + suffix.length + headerLen + 1 > SUMMARY_TOTAL_CHAR_LIMIT &&
+                included.length > 1) {
+                const removed = included.pop();
+                bodyLen -= removed.length + 1;
+                remaining++;
+                suffix = `\n[+${remaining} more]`;
+            }
+            return `${header}\n${included.join("\n")}${suffix}`;
+        }
+        return `${header}\n${included.join("\n")}`;
+    }
+    async composeAllDetails(runtime, level) {
+        const parts = [];
+        for (const contributor of this.contributors) {
+            if (!contributor.detail) {
+                parts.push(`[${contributor.id}: no detail available]`);
+                continue;
+            }
+            try {
+                let detail = await contributor.detail(runtime, level);
+                if (contributor.trusted !== true) {
+                    detail = sanitize(detail);
+                }
+                parts.push(detail);
+            }
+            catch {
+                parts.push(`[${contributor.id}: unavailable]`);
+            }
+        }
+        return parts.join("\n");
+    }
+}

package/packages/agent/src/benchmark-server.d.ts

@@ -0,0 +1,2 @@
+export declare function startBenchmarkServer(): Promise<void>;
+//# sourceMappingURL=benchmark-server.d.ts.map

package/packages/agent/src/benchmark-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark-server.d.ts","sourceRoot":"","sources":["../../../../src/benchmark-server.ts"],"names":[],"mappings":"AA+QA,wBAAsB,oBAAoB,kBAouBzC"}