@nodetool-ai/runtime 0.7.0-rc.11

package/dist/context.js

@@ -0,0 +1,1455 @@
+/**
+ * ProcessingContext – runtime context for node execution.
+ *
+ * Port of src/nodetool/workflows/processing_context.py.
+ *
+ * Provides:
+ *   - Message queue for emitting ProcessingMessages.
+ *   - Cache get/set interface.
+ *   - Output normalization (sanitize memory URIs, etc.).
+ *   - Asset handling with pluggable storage adapters.
+ */
+import { randomUUID } from "node:crypto";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+/**
+ * In-memory cache adapter (default for tests and single-process execution).
+ */
+export class MemoryCache {
+    _store = new Map();
+    async get(key) {
+        const entry = this._store.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expires !== null && Date.now() > entry.expires) {
+            this._store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttlSeconds) {
+        const expires = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null;
+        this._store.set(key, { value, expires });
+    }
+    async has(key) {
+        return (await this.get(key)) !== undefined;
+    }
+    async delete(key) {
+        this._store.delete(key);
+    }
+}
+function isWithinRoot(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function normalizeStorageKey(key) {
+    const cleaned = normalize(key.replaceAll("\\", "/")).replace(/^\/+/, "");
+    if (!cleaned ||
+        cleaned === "." ||
+        cleaned.startsWith("..") ||
+        cleaned.includes(`..${sep}`)) {
+        throw new Error(`Invalid storage key: ${key}`);
+    }
+    return cleaned;
+}
+function joinStorageKey(prefix, key) {
+    const normalizedKey = normalizeStorageKey(key);
+    if (!prefix)
+        return normalizedKey;
+    const normalizedPrefix = normalizeStorageKey(prefix);
+    return `${normalizedPrefix}/${normalizedKey}`;
+}
+/**
+ * In-memory storage adapter useful for tests and single-process ephemeral runs.
+ */
+export class InMemoryStorageAdapter {
+    _store = new Map();
+    async store(key, data, _contentType) {
+        const normalized = normalizeStorageKey(key);
+        this._store.set(normalized, new Uint8Array(data));
+        return `memory://${normalized}`;
+    }
+    async retrieve(uri) {
+        if (!uri.startsWith("memory://"))
+            return null;
+        const key = uri.slice("memory://".length);
+        const value = this._store.get(key);
+        return value ? new Uint8Array(value) : null;
+    }
+    async exists(uri) {
+        if (!uri.startsWith("memory://"))
+            return false;
+        const key = uri.slice("memory://".length);
+        return this._store.has(key);
+    }
+}
+/**
+ * File-system storage adapter rooted to a single base directory.
+ */
+export class FileStorageAdapter {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = resolve(rootDir);
+    }
+    resolvePathFromKey(key) {
+        const normalized = normalizeStorageKey(key);
+        const absolute = resolve(join(this.rootDir, normalized));
+        if (!isWithinRoot(this.rootDir, absolute)) {
+            throw new Error(`Storage key escapes root: ${key}`);
+        }
+        return absolute;
+    }
+    resolvePathFromUri(uri) {
+        let absolute = null;
+        if (uri.startsWith("file://")) {
+            try {
+                absolute = resolve(fileURLToPath(uri));
+            }
+            catch {
+                // Invalid file:// URI — treat as unresolvable.
+                return null;
+            }
+        }
+        else if (uri.startsWith("/api/storage/") ||
+            uri.startsWith("api/storage/")) {
+            const key = uri.replace(/^\/?api\/storage\//, "");
+            absolute = this.resolvePathFromKey(key);
+        }
+        else if (/^https?:\/\//.test(uri)) {
+            try {
+                const parsed = new URL(uri);
+                if (parsed.pathname.startsWith("/api/storage/")) {
+                    const key = parsed.pathname.replace(/^\/api\/storage\//, "");
+                    absolute = this.resolvePathFromKey(key);
+                }
+            }
+            catch {
+                // Malformed URL — treat as unresolvable.
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (absolute === null || !isWithinRoot(this.rootDir, absolute)) {
+            return null;
+        }
+        return absolute;
+    }
+    async store(key, data, _contentType) {
+        const absolutePath = this.resolvePathFromKey(key);
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, data);
+        return pathToFileURL(absolutePath).toString();
+    }
+    async retrieve(uri) {
+        const absolutePath = this.resolvePathFromUri(uri);
+        if (!absolutePath)
+            return null;
+        try {
+            return await readFile(absolutePath);
+        }
+        catch {
+            // File not found or unreadable — caller handles null.
+            return null;
+        }
+    }
+    async exists(uri) {
+        const absolutePath = this.resolvePathFromUri(uri);
+        if (!absolutePath)
+            return false;
+        try {
+            await access(absolutePath);
+            return true;
+        }
+        catch {
+            // File does not exist or is inaccessible.
+            return false;
+        }
+    }
+}
+/**
+ * S3-backed storage adapter with injected client operations.
+ *
+ * This avoids hard-coupling runtime to any specific SDK while providing
+ * predictable URI behavior (`s3://bucket/key`).
+ */
+export class S3StorageAdapter {
+    bucket;
+    prefix;
+    client;
+    constructor(opts) {
+        if (!opts.bucket) {
+            throw new Error("S3 bucket is required");
+        }
+        this.bucket = opts.bucket;
+        this.client = opts.client;
+        this.prefix = opts.prefix ? normalizeStorageKey(opts.prefix) : null;
+    }
+    keyForStore(key) {
+        return joinStorageKey(this.prefix ?? undefined, key);
+    }
+    parseUri(uri) {
+        if (!uri.startsWith("s3://"))
+            return null;
+        const withoutScheme = uri.slice("s3://".length);
+        const slashIndex = withoutScheme.indexOf("/");
+        if (slashIndex <= 0 || slashIndex === withoutScheme.length - 1) {
+            return null;
+        }
+        const bucket = withoutScheme.slice(0, slashIndex);
+        const key = withoutScheme.slice(slashIndex + 1);
+        return { bucket, key };
+    }
+    async store(key, data, contentType) {
+        const objectKey = this.keyForStore(key);
+        await this.client.putObject({
+            bucket: this.bucket,
+            key: objectKey,
+            body: data,
+            contentType
+        });
+        return `s3://${this.bucket}/${objectKey}`;
+    }
+    async retrieve(uri) {
+        const parsed = this.parseUri(uri);
+        if (!parsed)
+            return null;
+        if (parsed.bucket !== this.bucket)
+            return null;
+        return this.client.getObject(parsed);
+    }
+    async exists(uri) {
+        const parsed = this.parseUri(uri);
+        if (!parsed)
+            return false;
+        if (parsed.bucket !== this.bucket)
+            return false;
+        return this.client.headObject(parsed);
+    }
+}
+/**
+ * Resolve paths relative to a configured workspace root.
+ *
+ * Supported path forms:
+ * - /workspace/foo/bar.txt
+ * - workspace/foo/bar.txt
+ * - absolute paths (treated as workspace-relative)
+ * - relative paths
+ */
+export function resolveWorkspacePath(workspaceDir, path) {
+    if (workspaceDir == null) {
+        throw new Error("No workspace is assigned. File operations require a user-defined workspace. Please configure a workspace before performing disk I/O operations.");
+    }
+    if (workspaceDir === "") {
+        throw new Error("Workspace directory is required");
+    }
+    const workspaceRoot = resolve(workspaceDir);
+    const normalizedPath = path.replaceAll("\\", "/");
+    let relativePath;
+    if (normalizedPath.startsWith("/workspace/")) {
+        relativePath = normalizedPath.slice("/workspace/".length);
+    }
+    else if (normalizedPath.startsWith("workspace/")) {
+        relativePath = normalizedPath.slice("workspace/".length);
+    }
+    else if (isAbsolute(normalizedPath) ||
+        /^[A-Za-z]:\//.test(normalizedPath)) {
+        if (normalizedPath.startsWith("/")) {
+            relativePath = normalizedPath.slice(1);
+        }
+        else {
+            relativePath = normalizedPath.replace(/^[A-Za-z]:\//, "");
+        }
+    }
+    else {
+        relativePath = normalizedPath;
+    }
+    const absPath = resolve(join(workspaceRoot, relativePath));
+    if (!isWithinRoot(workspaceRoot, absPath)) {
+        throw new Error(`Resolved path '${absPath}' is outside the workspace directory.`);
+    }
+    return absPath;
+}
+// ---------------------------------------------------------------------------
+// ProcessingContext
+// ---------------------------------------------------------------------------
+export class ProcessingContext {
+    jobId;
+    workflowId;
+    userId;
+    workspaceDir;
+    assetOutputMode;
+    environment;
+    /** Message queue: all emitted processing messages. */
+    _messages = [];
+    /** Latest node status by node id. */
+    _nodeStatuses = new Map();
+    /** Latest edge status by edge id. */
+    _edgeStatuses = new Map();
+    /** Optional message listener (for real-time streaming). */
+    _onMessage = null;
+    /** Cache adapter. */
+    cache;
+    /** Storage adapter (optional, for asset handling). */
+    storage;
+    /** Variables shared across node execution. */
+    _variables;
+    /** Optional async secret resolver. */
+    _secretResolver = null;
+    /** Fetch function used by HTTP helpers. */
+    _fetch;
+    /** Optional temporary URL resolver for stored assets. */
+    _tempUrlResolver = null;
+    /** Optional async provider resolver by provider id. */
+    _providerResolver = null;
+    /** Optional model-layer adapters used to mirror Python ProcessingContext APIs. */
+    _modelInterfaces = null;
+    /** Provider cache keyed by provider id. */
+    _providers = new Map();
+    /** In-context memory URI cache (memory:// key-value objects). */
+    _memory = new Map();
+    /** Optional control event dispatcher (set by workflow runner). */
+    _sendControlEvent = null;
+    /** Optional executor resolver for sub-workflow execution. */
+    _resolveExecutor = null;
+    /** Optional node type resolver for sub-workflow graph hydration. */
+    _resolveNodeType = null;
+    /** Total cost tracked for operations executed via this context. */
+    _totalCost = 0;
+    /** Per-operation cost entries. */
+    _operationCosts = [];
+    constructor(opts) {
+        this.jobId = opts.jobId;
+        this.workflowId = opts.workflowId ?? null;
+        this.userId = opts.userId ?? "default";
+        this.workspaceDir = opts.workspaceDir ?? null;
+        this.assetOutputMode = opts.assetOutputMode ?? "python";
+        this.cache = opts.cache ?? new MemoryCache();
+        this.storage = opts.storage ?? null;
+        this._onMessage = opts.onMessage ?? null;
+        this._variables = { ...(opts.variables ?? {}) };
+        const env = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (typeof v === "string")
+                env[k] = v;
+        }
+        this.environment = { ...env, ...(opts.environment ?? {}) };
+        this._secretResolver = opts.secretResolver ?? null;
+        this._fetch =
+            opts.fetchFn ??
+                ((input, init) => fetch(input, init));
+        this._tempUrlResolver = opts.tempUrlResolver ?? null;
+        this._modelInterfaces = opts.modelInterfaces ?? null;
+    }
+    copy() {
+        const next = new ProcessingContext({
+            jobId: this.jobId,
+            workflowId: this.workflowId,
+            userId: this.userId,
+            workspaceDir: this.workspaceDir,
+            assetOutputMode: this.assetOutputMode,
+            cache: this.cache,
+            storage: this.storage,
+            onMessage: this._onMessage ?? undefined,
+            variables: { ...this._variables },
+            environment: { ...this.environment },
+            fetchFn: this._fetch,
+            secretResolver: this._secretResolver ?? undefined,
+            tempUrlResolver: this._tempUrlResolver ?? undefined
+        });
+        next._providerResolver = this._providerResolver;
+        next._modelInterfaces = this._modelInterfaces;
+        next._sendControlEvent = this._sendControlEvent;
+        next._providers = new Map(this._providers);
+        next._totalCost = this._totalCost;
+        next._operationCosts = this._operationCosts.map((c) => ({ ...c }));
+        return next;
+    }
+    // -----------------------------------------------------------------------
+    // Provider resolution
+    // -----------------------------------------------------------------------
+    setProviderResolver(resolver) {
+        this._providerResolver = resolver;
+    }
+    setModelInterfaces(modelInterfaces) {
+        this._modelInterfaces = modelInterfaces;
+    }
+    // -----------------------------------------------------------------------
+    // Control event dispatch
+    // -----------------------------------------------------------------------
+    /**
+     * Set the control event dispatcher (called by the workflow runner).
+     * This allows agent nodes to dispatch control events to controlled nodes
+     * and await their results.
+     */
+    setSendControlEvent(fn) {
+        this._sendControlEvent = fn;
+    }
+    /**
+     * Dispatch a control event to a target node and await its output.
+     * Returns null if no control event dispatcher is configured.
+     */
+    async sendControlEvent(targetNodeId, properties) {
+        if (!this._sendControlEvent)
+            return null;
+        return this._sendControlEvent(targetNodeId, properties);
+    }
+    // -----------------------------------------------------------------------
+    // Sub-workflow executor resolution
+    // -----------------------------------------------------------------------
+    setResolveExecutor(fn) {
+        this._resolveExecutor = fn;
+    }
+    get resolveExecutor() {
+        return this._resolveExecutor;
+    }
+    setResolveNodeType(fn) {
+        this._resolveNodeType = fn;
+    }
+    get resolveNodeType() {
+        return this._resolveNodeType;
+    }
+    /**
+     * Check if control event dispatch is available.
+     */
+    get hasControlEventSupport() {
+        return this._sendControlEvent !== null;
+    }
+    registerProvider(providerId, provider) {
+        this._providers.set(providerId, provider);
+    }
+    async getProvider(providerId) {
+        if (!providerId || providerId.trim() === "") {
+            throw new Error("providerId is required");
+        }
+        const cached = this._providers.get(providerId);
+        if (cached)
+            return cached;
+        if (!this._providerResolver) {
+            const { getRegisteredProvider } = await import("./providers/index.js");
+            const reg = getRegisteredProvider(providerId);
+            if (!reg) {
+                throw new Error(`No provider registered for "${providerId}"`);
+            }
+            // Resolve any missing secret kwargs from the context's own secret resolver
+            const kwargs = { ...reg.kwargs };
+            for (const [key, value] of Object.entries(kwargs)) {
+                if (!value) {
+                    const envVal = process.env[key];
+                    if (envVal) {
+                        kwargs[key] = envVal;
+                    }
+                    else {
+                        const secret = await this.getSecret(key);
+                        if (secret) {
+                            kwargs[key] = secret;
+                        }
+                    }
+                }
+            }
+            const resolved = new reg.cls(kwargs);
+            this._providers.set(providerId, resolved);
+            resolved.setMessageEmitter((msg) => this.postMessage(msg));
+            return resolved;
+        }
+        const resolved = await this._providerResolver(providerId);
+        this._providers.set(providerId, resolved);
+        resolved.setMessageEmitter((msg) => this.postMessage(msg));
+        return resolved;
+    }
+    async get_provider(providerId) {
+        return this.getProvider(providerId);
+    }
+    // -----------------------------------------------------------------------
+    // Secrets / Variables API
+    // -----------------------------------------------------------------------
+    setSecretResolver(resolver) {
+        this._secretResolver = resolver;
+    }
+    setTempUrlResolver(resolver) {
+        this._tempUrlResolver = resolver;
+    }
+    async getSecret(key) {
+        if (!this._secretResolver)
+            return null;
+        const value = await this._secretResolver(key, this.userId);
+        return value ?? null;
+    }
+    async getSecretRequired(key) {
+        const value = await this.getSecret(key);
+        if (value === null || value === "") {
+            throw new Error(`Missing required secret: ${key}`);
+        }
+        return value;
+    }
+    async get_secret(key) {
+        return this.getSecret(key);
+    }
+    async get_secret_required(key) {
+        return this.getSecretRequired(key);
+    }
+    get(key, defaultValue) {
+        if (Object.prototype.hasOwnProperty.call(this._variables, key)) {
+            return this._variables[key];
+        }
+        return defaultValue;
+    }
+    set(key, value) {
+        this._variables[key] = value;
+        void this.persistVariableIfNeeded(key, value);
+        if (key.startsWith("memory://")) {
+            this._memory.set(key, value);
+        }
+    }
+    async storeStepResult(key, value) {
+        const path = this.workspacePathFor(`${key}.json`);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, JSON.stringify(value, null, 2), "utf8");
+        this._variables[key] = { __workspace_result__: `${key}.json` };
+        return path;
+    }
+    async loadStepResult(key, defaultValue) {
+        const marker = this._variables[key];
+        if (marker &&
+            typeof marker === "object" &&
+            "__workspace_result__" in marker) {
+            const rel = marker
+                .__workspace_result__;
+            const path = this.workspacePathFor(String(rel));
+            try {
+                const raw = await readFile(path, "utf8");
+                return JSON.parse(raw);
+            }
+            catch {
+                // File missing or corrupt — fall back to default.
+                return defaultValue;
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(this._variables, key)) {
+            return this._variables[key];
+        }
+        return defaultValue;
+    }
+    workspacePathFor(fileName) {
+        if (!this.workspaceDir) {
+            throw new Error("workspace_dir is required to persist workflow variables");
+        }
+        return resolveWorkspacePath(this.workspaceDir, fileName);
+    }
+    async persistVariableIfNeeded(key, value) {
+        if (!this.workspaceDir)
+            return;
+        if (value === undefined || value === null)
+            return;
+        if (typeof value === "function" ||
+            typeof value === "symbol" ||
+            typeof value === "bigint")
+            return;
+        const filePath = this.workspacePathFor(`var_${key}.json`);
+        try {
+            await mkdir(dirname(filePath), { recursive: true });
+            await writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
+        }
+        catch {
+            // Best-effort persistence.
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Node result cache helpers
+    // -----------------------------------------------------------------------
+    generateNodeCacheKey(nodeType, nodeProps) {
+        const normalizedProps = nodeProps && typeof nodeProps === "object"
+            ? JSON.stringify(nodeProps, Object.keys(nodeProps).sort())
+            : JSON.stringify(nodeProps ?? null);
+        return `${this.userId}:${nodeType}:${normalizedProps}`;
+    }
+    async getCachedResult(nodeType, nodeProps) {
+        const key = this.generateNodeCacheKey(nodeType, nodeProps);
+        return this.cache.get(key);
+    }
+    async cacheResult(nodeType, nodeProps, result, ttlSeconds = 3600) {
+        const key = this.generateNodeCacheKey(nodeType, nodeProps);
+        await this.cache.set(key, result, ttlSeconds);
+    }
+    // -----------------------------------------------------------------------
+    // Message queue API
+    // -----------------------------------------------------------------------
+    /**
+     * Emit a processing message.
+     * Appended to the internal queue and forwarded to listener if set.
+     */
+    emit(msg) {
+        this._messages.push(msg);
+        this._notifyMessage();
+        if (msg.type === "node_update" && msg.node_id) {
+            this._nodeStatuses.set(msg.node_id, msg);
+        }
+        if (msg.type === "edge_update" && msg.edge_id) {
+            this._edgeStatuses.set(msg.edge_id, msg);
+        }
+        if (this._onMessage) {
+            this._onMessage(msg);
+        }
+    }
+    postMessage(msg) {
+        this.emit(msg);
+    }
+    post_message(msg) {
+        this.emit(msg);
+    }
+    /** Get all emitted messages. */
+    getMessages() {
+        return this._messages;
+    }
+    hasMessages() {
+        return this._messages.length > 0;
+    }
+    popMessage() {
+        return this._messages.shift();
+    }
+    _messageResolve = null;
+    /** Notify that a new message has been pushed. */
+    _notifyMessage() {
+        if (this._messageResolve) {
+            const resolve = this._messageResolve;
+            this._messageResolve = null;
+            resolve();
+        }
+    }
+    async popMessageAsync() {
+        while (this._messages.length === 0) {
+            await new Promise((r) => {
+                this._messageResolve = r;
+            });
+        }
+        return this._messages.shift();
+    }
+    async pop_message_async() {
+        return this.popMessageAsync();
+    }
+    getNodeStatuses() {
+        return Object.fromEntries(this._nodeStatuses);
+    }
+    getEdgeStatuses() {
+        return Object.fromEntries(this._edgeStatuses);
+    }
+    /** Clear the message queue. */
+    clearMessages() {
+        this._messages = [];
+    }
+    clear_messages() {
+        this.clearMessages();
+    }
+    trackOperationCost(operation, cost, metadata) {
+        const safeCost = Number.isFinite(cost) ? cost : 0;
+        this._totalCost += safeCost;
+        this._operationCosts.push({
+            operation,
+            cost: safeCost,
+            timestamp: new Date().toISOString(),
+            ...(metadata ?? {})
+        });
+    }
+    addToTotalCost(cost) {
+        const safeCost = Number.isFinite(cost) ? cost : 0;
+        this._totalCost += safeCost;
+    }
+    resetTotalCost() {
+        this._totalCost = 0;
+        this._operationCosts = [];
+    }
+    getTotalCost() {
+        return this._totalCost;
+    }
+    getOperationCosts() {
+        return this._operationCosts;
+    }
+    // -----------------------------------------------------------------------
+    // Memory cache helpers
+    // -----------------------------------------------------------------------
+    clearMemory(pattern) {
+        if (!pattern) {
+            this._memory.clear();
+            return;
+        }
+        for (const key of this._memory.keys()) {
+            if (key.includes(pattern)) {
+                this._memory.delete(key);
+            }
+        }
+    }
+    getMemoryStats() {
+        const byPrefix = {};
+        for (const key of this._memory.keys()) {
+            const withoutScheme = key.replace(/^memory:\/\//, "");
+            const prefix = withoutScheme.includes("/")
+                ? withoutScheme.split("/")[0]
+                : withoutScheme;
+            byPrefix[prefix] = (byPrefix[prefix] ?? 0) + 1;
+        }
+        return { total: this._memory.size, byPrefix };
+    }
+    // -----------------------------------------------------------------------
+    // HTTP helpers
+    // -----------------------------------------------------------------------
+    async httpRequestWithRetries(method, url, opts = {}) {
+        const retry = opts.retry ?? {};
+        const maxRetries = retry.maxRetries ?? 3;
+        const backoffMs = retry.backoffMs ?? 500;
+        const retryStatuses = retry.retryStatuses ?? [
+            408, 425, 429, 500, 502, 503, 504
+        ];
+        const headers = {
+            "User-Agent": "nodetool-ts-runtime/0.1",
+            Accept: "*/*",
+            ...(opts.headers ?? {})
+        };
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+            try {
+                const response = await this._fetch(url, {
+                    ...opts,
+                    method,
+                    headers
+                });
+                if (retryStatuses.includes(response.status) &&
+                    attempt < maxRetries - 1) {
+                    const retryAfter = response.headers.get("Retry-After");
+                    const retryDelay = retryAfter ? Number(retryAfter) * 1000 : NaN;
+                    const delayMs = Number.isFinite(retryDelay)
+                        ? retryDelay
+                        : backoffMs * 2 ** attempt;
+                    await new Promise((r) => setTimeout(r, Math.max(0, delayMs)));
+                    continue;
+                }
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status} ${response.statusText} for ${method} ${url}`);
+                }
+                return response;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= maxRetries - 1)
+                    break;
+                const delayMs = backoffMs * 2 ** attempt;
+                await new Promise((r) => setTimeout(r, delayMs));
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`HTTP request failed: ${method} ${url}`);
+    }
+    async httpGet(url, opts = {}) {
+        return this.httpRequestWithRetries("GET", url, opts);
+    }
+    async httpPost(url, opts = {}) {
+        return this.httpRequestWithRetries("POST", url, opts);
+    }
+    async httpPatch(url, opts = {}) {
+        return this.httpRequestWithRetries("PATCH", url, opts);
+    }
+    async httpPut(url, opts = {}) {
+        return this.httpRequestWithRetries("PUT", url, opts);
+    }
+    async httpDelete(url, opts = {}) {
+        return this.httpRequestWithRetries("DELETE", url, opts);
+    }
+    async httpHead(url, opts = {}) {
+        return this.httpRequestWithRetries("HEAD", url, opts);
+    }
+    async downloadFile(url, opts = {}) {
+        const response = await this.httpGet(url, opts);
+        const arr = await response.arrayBuffer();
+        return new Uint8Array(arr);
+    }
+    async downloadText(url, opts = {}) {
+        const response = await this.httpGet(url, opts);
+        return response.text();
+    }
+    async http_get(url, opts = {}) {
+        return this.httpGet(url, opts);
+    }
+    async http_post(url, opts = {}) {
+        return this.httpPost(url, opts);
+    }
+    async http_patch(url, opts = {}) {
+        return this.httpPatch(url, opts);
+    }
+    async http_put(url, opts = {}) {
+        return this.httpPut(url, opts);
+    }
+    async http_delete(url, opts = {}) {
+        return this.httpDelete(url, opts);
+    }
+    async http_head(url, opts = {}) {
+        return this.httpHead(url, opts);
+    }
+    requireModelInterface(name) {
+        const fn = this._modelInterfaces?.[name];
+        if (!fn) {
+            throw new Error(`ProcessingContext model interface '${String(name)}' is not configured`);
+        }
+        return fn;
+    }
+    async getJob(jobId) {
+        const fn = this.requireModelInterface("getJob");
+        return fn({ userId: this.userId, jobId });
+    }
+    async get_job(jobId) {
+        return this.getJob(jobId);
+    }
+    async createAsset(args) {
+        const fn = this.requireModelInterface("createAsset");
+        const content = args.content ?? args.instructions;
+        if (!content) {
+            throw new Error("Asset content is required");
+        }
+        return fn({
+            userId: this.userId,
+            workflowId: this.workflowId,
+            jobId: this.jobId,
+            name: args.name,
+            contentType: args.contentType,
+            content,
+            parentId: args.parentId ?? null,
+            nodeId: args.nodeId ?? null
+        });
+    }
+    async create_asset(args) {
+        return this.createAsset(args);
+    }
+    resolveSandboxFilePath(path) {
+        if (this.workspaceDir == null || this.workspaceDir === "") {
+            throw new Error("workspaceDir is required for sandbox file operations");
+        }
+        const workspaceRoot = resolve(this.workspaceDir);
+        const normalizedPath = path.replaceAll("\\", "/");
+        if ((isAbsolute(normalizedPath) || /^[A-Za-z]:\//.test(normalizedPath)) &&
+            isWithinRoot(workspaceRoot, resolve(normalizedPath))) {
+            return resolve(normalizedPath);
+        }
+        return resolveWorkspacePath(this.workspaceDir, path);
+    }
+    static guessMimeFromPath(path) {
+        const ext = extname(path).toLowerCase();
+        const byExt = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".webp": "image/webp",
+            ".gif": "image/gif",
+            ".bmp": "image/bmp",
+            ".svg": "image/svg+xml",
+            ".wav": "audio/wav",
+            ".mp3": "audio/mpeg",
+            ".ogg": "audio/ogg",
+            ".flac": "audio/flac",
+            ".m4a": "audio/mp4",
+            ".mp4": "video/mp4",
+            ".webm": "video/webm",
+            ".mov": "video/quicktime",
+            ".txt": "text/plain",
+            ".md": "text/markdown",
+            ".json": "application/json",
+            ".pdf": "application/pdf",
+            ".csv": "text/csv"
+        };
+        return byExt[ext] ?? "application/octet-stream";
+    }
+    static assetTypeForMime(mime) {
+        if (mime.startsWith("image/"))
+            return "image";
+        if (mime.startsWith("audio/"))
+            return "audio";
+        if (mime.startsWith("video/"))
+            return "video";
+        if (mime.startsWith("text/"))
+            return "text";
+        if (mime === "application/pdf")
+            return "document";
+        return "asset";
+    }
+    parseAssetIdCandidates(assetId) {
+        const trimmed = assetId.trim();
+        if (!trimmed) {
+            return [];
+        }
+        const raw = trimmed.startsWith("asset://") ? trimmed.slice("asset://".length) : trimmed;
+        const primary = raw.split(/[/?#]/)[0];
+        if (!primary) {
+            return [];
+        }
+        const withoutExt = primary.replace(/\.[^.]+$/, "");
+        return Array.from(new Set([primary, withoutExt].filter(Boolean)));
+    }
+    async assetToSandbox(assetId, path) {
+        const outputPath = this.resolveSandboxFilePath(path);
+        const uriCandidates = new Set();
+        const idCandidates = this.parseAssetIdCandidates(assetId);
+        const trimmed = assetId.trim();
+        const resolutionAttempts = [];
+        if (trimmed.includes("://") && !trimmed.startsWith("asset://")) {
+            uriCandidates.add(trimmed);
+        }
+        for (const candidate of idCandidates) {
+            for (const prefix of ["memory://", "file://", "s3://"]) {
+                uriCandidates.add(`${prefix}${candidate}`);
+                uriCandidates.add(`${prefix}assets/${candidate}`);
+            }
+        }
+        let bytes = null;
+        if (this.storage) {
+            for (const uri of uriCandidates) {
+                try {
+                    const retrieved = await this.storage.retrieve(uri);
+                    if (retrieved) {
+                        bytes = retrieved;
+                        break;
+                    }
+                    resolutionAttempts.push(`storage miss: ${uri}`);
+                }
+                catch (error) {
+                    resolutionAttempts.push(`storage error: ${uri} (${error instanceof Error ? error.message : String(error)})`);
+                }
+            }
+        }
+        if (!bytes) {
+            let baseUrl = (this.environment.NODETOOL_API_URL ??
+                process.env.NODETOOL_API_URL ??
+                "http://localhost:7777");
+            while (baseUrl.endsWith("/")) {
+                baseUrl = baseUrl.slice(0, -1);
+            }
+            for (const candidate of idCandidates) {
+                try {
+                    const metaResponse = await this.httpGet(`${baseUrl}/api/assets/${encodeURIComponent(candidate)}`);
+                    const metadata = (await metaResponse.json());
+                    const getUrl = metadata.get_url;
+                    const uri = metadata.uri;
+                    if (typeof getUrl === "string" && getUrl) {
+                        const downloadUrl = getUrl.startsWith("/")
+                            ? `${baseUrl}${getUrl}`
+                            : getUrl;
+                        bytes = await this.downloadFile(downloadUrl, {
+                            retry: { maxRetries: 1, backoffMs: 200 }
+                        });
+                        resolutionAttempts.push(`downloaded: ${downloadUrl}`);
+                        break;
+                    }
+                    if (typeof uri === "string" && this.storage) {
+                        const retrieved = await this.storage.retrieve(uri);
+                        if (retrieved) {
+                            bytes = retrieved;
+                            resolutionAttempts.push(`storage hit via metadata: ${uri}`);
+                            break;
+                        }
+                        resolutionAttempts.push(`storage miss via metadata: ${uri}`);
+                    }
+                }
+                catch (error) {
+                    resolutionAttempts.push(`api lookup error for ${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        if (!bytes) {
+            const details = resolutionAttempts.length > 0
+                ? ` Attempts: ${resolutionAttempts.join("; ")}`
+                : "";
+            throw new Error(`Unable to resolve asset '${assetId}' to sandbox bytes.${details}`);
+        }
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, bytes);
+        return outputPath;
+    }
+    async asset_to_sandbox(asset_id, path) {
+        return this.assetToSandbox(asset_id, path);
+    }
+    async sandboxToAsset(path) {
+        const filePath = this.resolveSandboxFilePath(path);
+        const bytes = await readFile(filePath);
+        const contentType = ProcessingContext.guessMimeFromPath(filePath);
+        const created = (await this.createAsset({
+            name: basename(filePath),
+            contentType,
+            content: bytes
+        }));
+        const type = ProcessingContext.assetTypeForMime(contentType);
+        const assetId = typeof created.id === "string" ? created.id : null;
+        const uri = assetId !== null
+            ? `asset://${assetId}`
+            : typeof created.uri === "string"
+                ? created.uri
+                : pathToFileURL(filePath).toString();
+        return {
+            type,
+            uri,
+            asset_id: assetId
+        };
+    }
+    async sandbox_to_asset(path) {
+        return this.sandboxToAsset(path);
+    }
+    async createMessage(req) {
+        if (!req.thread_id) {
+            throw new Error("Thread ID is required");
+        }
+        const fn = this.requireModelInterface("createMessage");
+        return fn({ userId: this.userId, req });
+    }
+    async create_message(req) {
+        return this.createMessage(req);
+    }
+    async getThreadMessages(threadId, limit = 10, startKey = null, reverse = false) {
+        const fn = this.requireModelInterface("getMessages");
+        return fn({
+            userId: this.userId,
+            threadId,
+            limit,
+            startKey,
+            reverse
+        });
+    }
+    async get_messages(thread_id, limit = 10, start_key = null, reverse = false) {
+        return this.getThreadMessages(thread_id, limit, start_key, reverse);
+    }
+    async assetsToDataUri(value) {
+        return this.normalizeOutputValue(value, "data_uri");
+    }
+    async assetsToStorageUrl(value) {
+        return this.normalizeOutputValue(value, "storage_url");
+    }
+    async assetsToWorkspaceFiles(value) {
+        return this.normalizeOutputValue(value, "workspace");
+    }
+    async uploadAssetsToTemp(value) {
+        return this.normalizeOutputValue(value, "temp_url");
+    }
+    // -----------------------------------------------------------------------
+    // Provider prediction pipeline
+    // -----------------------------------------------------------------------
+    emitPrediction(status, req, id, data, error, startedAt) {
+        this.emit({
+            type: "prediction",
+            id,
+            user_id: this.userId,
+            node_id: req.nodeId ?? "",
+            workflow_id: req.workflowId ?? this.workflowId ?? null,
+            provider: req.provider,
+            model: req.model,
+            status,
+            params: req.params ?? {},
+            data: data ?? null,
+            error: error ?? null,
+            duration: startedAt ? Date.now() - startedAt : null
+        });
+    }
+    /**
+     * Resolve /api/storage/ URIs in message content to data URIs so providers
+     * can fetch them without needing a base URL.
+     */
+    async resolveMessageMediaUris(messages) {
+        if (!this.storage)
+            return messages;
+        const resolved = [];
+        for (const msg of messages) {
+            if (!Array.isArray(msg.content)) {
+                resolved.push(msg);
+                continue;
+            }
+            const parts = [];
+            for (const part of msg.content) {
+                if (part.type === "image_url" &&
+                    part.image.uri &&
+                    !part.image.uri.startsWith("data:") &&
+                    !part.image.uri.startsWith("http")) {
+                    const bytes = await this.storage.retrieve(part.image.uri);
+                    if (bytes) {
+                        const ext = part.image.uri.split(".").pop()?.toLowerCase() ?? "png";
+                        const mime = {
+                            png: "image/png",
+                            jpg: "image/jpeg",
+                            jpeg: "image/jpeg",
+                            gif: "image/gif",
+                            webp: "image/webp"
+                        };
+                        const mimeType = mime[ext] ?? part.image.mimeType ?? "image/png";
+                        const b64 = Buffer.from(bytes).toString("base64");
+                        parts.push({
+                            type: "image_url",
+                            image: { uri: `data:${mimeType};base64,${b64}`, mimeType }
+                        });
+                        continue;
+                    }
+                }
+                if (part.type === "audio" &&
+                    part.audio.uri &&
+                    !part.audio.uri.startsWith("data:") &&
+                    !part.audio.uri.startsWith("http")) {
+                    const bytes = await this.storage.retrieve(part.audio.uri);
+                    if (bytes) {
+                        const ext = part.audio.uri.split(".").pop()?.toLowerCase() ?? "mp3";
+                        const mime = {
+                            mp3: "audio/mpeg",
+                            wav: "audio/wav",
+                            ogg: "audio/ogg",
+                            m4a: "audio/mp4",
+                            flac: "audio/flac"
+                        };
+                        const mimeType = mime[ext] ?? part.audio.mimeType ?? "audio/mpeg";
+                        const b64 = Buffer.from(bytes).toString("base64");
+                        parts.push({
+                            type: "audio",
+                            audio: { uri: `data:${mimeType};base64,${b64}`, mimeType }
+                        });
+                        continue;
+                    }
+                }
+                parts.push(part);
+            }
+            resolved.push({ ...msg, content: parts });
+        }
+        return resolved;
+    }
+    async dispatchCapability(provider, req) {
+        const params = req.params ?? {};
+        switch (req.capability) {
+            case "generate_message":
+                return provider.generateMessageTraced({
+                    messages: await this.resolveMessageMediaUris(params.messages ?? []),
+                    model: req.model,
+                    tools: params.tools,
+                    toolChoice: params.tool_choice,
+                    maxTokens: params.max_tokens,
+                    temperature: params.temperature,
+                    topP: params.top_p,
+                    presencePenalty: params.presence_penalty,
+                    frequencyPenalty: params.frequency_penalty
+                });
+            case "text_to_image":
+                return provider.textToImage({
+                    prompt: String(params.prompt ?? ""),
+                    model: { id: req.model, name: req.model, provider: req.provider },
+                    width: params.width,
+                    height: params.height,
+                    aspectRatio: params.aspect_ratio,
+                    resolution: params.resolution,
+                    negativePrompt: params.negative_prompt,
+                    quality: params.quality
+                });
+            case "image_to_image":
+                return provider.imageToImage(params.image, {
+                    prompt: String(params.prompt ?? ""),
+                    model: { id: req.model, name: req.model, provider: req.provider },
+                    negativePrompt: params.negative_prompt,
+                    targetWidth: params.target_width,
+                    targetHeight: params.target_height,
+                    aspectRatio: params.aspect_ratio,
+                    resolution: params.resolution,
+                    strength: params.strength,
+                    quality: params.quality
+                });
+            case "text_to_video":
+                return provider.textToVideo({
+                    prompt: String(params.prompt ?? ""),
+                    model: { id: req.model, name: req.model, provider: req.provider },
+                    negativePrompt: params.negative_prompt,
+                    numFrames: params.num_frames,
+                    durationSeconds: params.duration_seconds,
+                    aspectRatio: params.aspect_ratio,
+                    resolution: params.resolution
+                });
+            case "image_to_video":
+                return provider.imageToVideo(params.image, {
+                    prompt: params.prompt,
+                    model: { id: req.model, name: req.model, provider: req.provider },
+                    negativePrompt: params.negative_prompt,
+                    numFrames: params.num_frames,
+                    durationSeconds: params.duration_seconds,
+                    aspectRatio: params.aspect_ratio,
+                    resolution: params.resolution
+                });
+            case "automatic_speech_recognition":
+                return provider.automaticSpeechRecognition({
+                    audio: params.audio,
+                    model: req.model,
+                    language: params.language,
+                    prompt: params.prompt,
+                    temperature: params.temperature
+                });
+            case "generate_embedding":
+                return provider.generateEmbedding({
+                    text: params.text ?? "",
+                    model: req.model,
+                    dimensions: params.dimensions
+                });
+            default:
+                throw new Error(`Capability '${req.capability}' requires streaming API`);
+        }
+    }
+    async runProviderPrediction(req) {
+        const id = randomUUID();
+        const startedAt = Date.now();
+        this.emitPrediction("running", req, id, null, undefined, startedAt);
+        try {
+            const provider = await this.getProvider(req.provider);
+            const output = await this.dispatchCapability(provider, req);
+            this.emitPrediction("completed", req, id, output, undefined, startedAt);
+            return output;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitPrediction("failed", req, id, null, message, startedAt);
+            throw error;
+        }
+    }
+    async *streamProviderPrediction(req) {
+        const id = randomUUID();
+        const startedAt = Date.now();
+        this.emitPrediction("running", req, id, null, undefined, startedAt);
+        try {
+            const provider = await this.getProvider(req.provider);
+            const params = req.params ?? {};
+            if (req.capability === "generate_messages") {
+                for await (const item of provider.generateMessagesTraced({
+                    messages: await this.resolveMessageMediaUris(params.messages ?? []),
+                    model: req.model,
+                    tools: params.tools,
+                    maxTokens: params.max_tokens,
+                    temperature: params.temperature,
+                    topP: params.top_p,
+                    presencePenalty: params.presence_penalty,
+                    frequencyPenalty: params.frequency_penalty,
+                    audio: params.audio,
+                    threadId: params.thread_id
+                })) {
+                    yield item;
+                }
+            }
+            else if (req.capability === "text_to_speech") {
+                for await (const item of provider.textToSpeech({
+                    text: String(params.text ?? ""),
+                    model: req.model,
+                    voice: params.voice,
+                    speed: params.speed
+                })) {
+                    yield item;
+                }
+            }
+            else {
+                throw new Error(`Capability '${req.capability}' is not streamable`);
+            }
+            this.emitPrediction("completed", req, id, null, undefined, startedAt);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitPrediction("failed", req, id, null, message, startedAt);
+            throw error;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Output normalization
+    // -----------------------------------------------------------------------
+    /**
+     * Sanitize memory URIs from output values before sending to client.
+     * Replaces internal memory:// URIs with safe placeholders.
+     *
+     * Port of sanitize_memory_uris_for_client() from types.py.
+     */
+    static sanitizeForClient(value) {
+        if (value === null || value === undefined)
+            return value;
+        const binary = ProcessingContext.toClientBytes(value);
+        if (binary)
+            return binary;
+        if (Array.isArray(value)) {
+            return value.map((v) => ProcessingContext.sanitizeForClient(v));
+        }
+        if (typeof value !== "object")
+            return value;
+        const obj = value;
+        const uri = obj.uri;
+        const isAssetLike = "type" in obj && typeof uri === "string";
+        if (isAssetLike && uri.startsWith("memory://")) {
+            const sanitized = { ...obj };
+            if (sanitized.data !== undefined && sanitized.data !== null) {
+                sanitized.uri = "";
+            }
+            else if (sanitized.asset_id) {
+                sanitized.uri = `asset://${String(sanitized.asset_id)}`;
+            }
+            else {
+                sanitized.uri = "";
+            }
+            const result = {};
+            for (const [k, v] of Object.entries(sanitized)) {
+                if (k === "uri" || k === "data" || k === "asset_id") {
+                    result[k] = v;
+                }
+                else {
+                    result[k] = ProcessingContext.sanitizeForClient(v);
+                }
+            }
+            return result;
+        }
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            result[k] = ProcessingContext.sanitizeForClient(v);
+        }
+        return result;
+    }
+    static toClientBytes(value) {
+        if (value instanceof Uint8Array) {
+            return { type: "bytes", length: value.length };
+        }
+        if (value instanceof ArrayBuffer) {
+            return { type: "bytes", length: value.byteLength };
+        }
+        return null;
+    }
+    /**
+     * Resolve a file path against the configured workspace root.
+     */
+    resolveWorkspacePath(path) {
+        return resolveWorkspacePath(this.workspaceDir, path);
+    }
+    static isAssetLike(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const v = value;
+        return "type" in v && ("uri" in v || "data" in v || "asset_id" in v);
+    }
+    static guessAssetMime(asset) {
+        const explicit = asset.mime_type ?? asset.content_type;
+        if (typeof explicit === "string" && explicit)
+            return explicit;
+        const type = String(asset.type ?? "").toLowerCase();
+        if (type.includes("image"))
+            return "image/png";
+        if (type.includes("audio"))
+            return "audio/wav";
+        if (type.includes("video"))
+            return "video/mp4";
+        if (type.includes("text"))
+            return "text/plain";
+        if (type.includes("model3d"))
+            return "model/gltf-binary";
+        return "application/octet-stream";
+    }
+    static extForMime(mime) {
+        const map = {
+            "image/png": "png",
+            "image/jpeg": "jpg",
+            "image/webp": "webp",
+            "audio/wav": "wav",
+            "audio/mpeg": "mp3",
+            "video/mp4": "mp4",
+            "text/plain": "txt",
+            "application/json": "json",
+            "model/gltf-binary": "glb"
+        };
+        return map[mime] ?? "bin";
+    }
+    static decodeAssetData(data) {
+        if (data === null || data === undefined)
+            return null;
+        if (data instanceof Uint8Array)
+            return data;
+        if (Array.isArray(data) && data.every((v) => Number.isInteger(v))) {
+            return new Uint8Array(data);
+        }
+        if (typeof data === "string") {
+            return Uint8Array.from(Buffer.from(data, "base64"));
+        }
+        return null;
+    }
+    async getAssetBytes(asset) {
+        const decoded = ProcessingContext.decodeAssetData(asset.data);
+        if (decoded)
+            return decoded;
+        const uri = asset.uri;
+        if (typeof uri !== "string" || !this.storage)
+            return null;
+        return this.storage.retrieve(uri);
+    }
+    async materializeAsset(asset, mode) {
+        if (mode === "python" || mode === "raw") {
+            return asset;
+        }
+        const bytes = await this.getAssetBytes(asset);
+        if (!bytes)
+            return asset;
+        const mime = ProcessingContext.guessAssetMime(asset);
+        if (mode === "data_uri") {
+            const encoded = Buffer.from(bytes).toString("base64");
+            return {
+                ...asset,
+                uri: `data:${mime};base64,${encoded}`
+            };
+        }
+        if (mode === "storage_url") {
+            if (!this.storage)
+                return asset;
+            const key = `assets/${randomUUID()}.${ProcessingContext.extForMime(mime)}`;
+            const uri = await this.storage.store(key, bytes, mime);
+            return {
+                ...asset,
+                uri,
+                data: undefined
+            };
+        }
+        if (mode === "temp_url") {
+            if (!this.storage)
+                return asset;
+            const key = `temp/${randomUUID()}.${ProcessingContext.extForMime(mime)}`;
+            const storedUri = await this.storage.store(key, bytes, mime);
+            const resolvedUri = this._tempUrlResolver
+                ? await this._tempUrlResolver(storedUri)
+                : storedUri;
+            return {
+                ...asset,
+                uri: resolvedUri,
+                data: undefined
+            };
+        }
+        if (mode === "workspace") {
+            if (!this.workspaceDir) {
+                throw new Error("workspace_dir is required for workspace asset output");
+            }
+            const workspaceAssets = new FileStorageAdapter(resolveWorkspacePath(this.workspaceDir, "assets"));
+            const key = `${randomUUID()}.${ProcessingContext.extForMime(mime)}`;
+            const uri = await workspaceAssets.store(key, bytes, mime);
+            return {
+                ...asset,
+                uri,
+                data: undefined
+            };
+        }
+        return asset;
+    }
+    /**
+     * Recursively normalize workflow outputs, materializing asset-like values
+     * according to the selected output mode.
+     */
+    async normalizeOutputValue(value, mode = this.assetOutputMode) {
+        if (value === null || value === undefined)
+            return value;
+        const binary = ProcessingContext.toClientBytes(value);
+        if (binary)
+            return binary;
+        if (Array.isArray(value)) {
+            return Promise.all(value.map((item) => this.normalizeOutputValue(item, mode)));
+        }
+        if (ProcessingContext.isAssetLike(value)) {
+            return this.materializeAsset(value, mode);
+        }
+        if (typeof value === "object") {
+            const entries = Object.entries(value);
+            const normalized = await Promise.all(entries.map(async ([k, v]) => [k, await this.normalizeOutputValue(v, mode)]));
+            return Object.fromEntries(normalized);
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=context.js.map