@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/artifacts/store.js

@@ -0,0 +1,403 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { classifyHostTrustTier, extractHostname } from '../tools/fetch/trust-tiers.js';
+import { summarizeError } from '../utils/error-display.js';
+import { guessMimeType, inferArtifactKind, sanitizeArtifactFilename, } from './types.js';
+const DEFAULT_ARTIFACT_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_ARTIFACT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const DEFAULT_MAX_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
+const REMOTE_FETCH_MODES = new Set(['public-only', 'allow-private-hosts']);
+function resolveArtifactRootDir(config) {
+    const controlPlaneDir = typeof config.configManager?.getControlPlaneConfigDir === 'function'
+        ? config.configManager.getControlPlaneConfigDir()
+        : undefined;
+    const rootDir = config.rootDir ?? (controlPlaneDir ? join(controlPlaneDir, 'artifacts') : undefined);
+    if (!rootDir) {
+        throw new Error('ArtifactStore requires an explicit rootDir or configManager.getControlPlaneConfigDir().');
+    }
+    return rootDir;
+}
+function normalizeMimeType(value, fallbackFilename) {
+    const normalized = value?.split(';')[0]?.trim().toLowerCase();
+    if (normalized && /^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(normalized)) {
+        return normalized;
+    }
+    return guessMimeType(fallbackFilename);
+}
+function sanitizeRetentionMs(requested, defaultRetentionMs, maxRetentionMs) {
+    if (requested === 0)
+        return undefined;
+    const candidate = Number.isFinite(requested) ? Number(requested) : defaultRetentionMs;
+    if (candidate <= 0)
+        return undefined;
+    return Math.min(candidate, maxRetentionMs);
+}
+function filenameFromUrl(input) {
+    try {
+        const url = new URL(input);
+        const candidate = basename(url.pathname);
+        return candidate && candidate !== '/' ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeExistingRecord(record) {
+    const sourceUri = typeof record.sourceUri === 'string' ? record.sourceUri : undefined;
+    const legacyFetchMode = typeof record.metadata?.fetchMode === 'string' ? record.metadata.fetchMode : undefined;
+    const acquisitionMode = typeof record.acquisitionMode === 'string'
+        ? record.acquisitionMode
+        : typeof sourceUri === 'string' && /^https?:\/\//i.test(sourceUri)
+            ? 'remote-fetch'
+            : 'unknown';
+    const fetchMode = typeof record.fetchMode === 'string'
+        ? record.fetchMode
+        : legacyFetchMode === 'allow-private-hosts' || legacyFetchMode === 'public-only'
+            ? legacyFetchMode
+            : acquisitionMode === 'remote-fetch'
+                ? 'unknown'
+                : 'not-applicable';
+    return {
+        ...record,
+        acquisitionMode,
+        fetchMode,
+    };
+}
+function resolveArtifactIntent(input) {
+    const hasRemoteUri = typeof input.uri === 'string' && input.uri.trim().length > 0;
+    const hasLocalPath = typeof input.path === 'string' && input.path.trim().length > 0;
+    const derivedAcquisitionMode = hasRemoteUri
+        ? 'remote-fetch'
+        : hasLocalPath
+            ? 'local-path'
+            : 'inline-data';
+    const acquisitionMode = input.acquisitionMode ?? derivedAcquisitionMode;
+    if (acquisitionMode !== 'unknown' && acquisitionMode !== derivedAcquisitionMode) {
+        throw new Error(`Artifact acquisitionMode "${acquisitionMode}" does not match the provided artifact input.`);
+    }
+    const derivedFetchMode = derivedAcquisitionMode === 'remote-fetch'
+        ? input.allowPrivateHosts === true ? 'allow-private-hosts' : 'public-only'
+        : 'not-applicable';
+    const fetchMode = input.fetchMode ?? derivedFetchMode;
+    if (acquisitionMode === 'remote-fetch') {
+        if (!REMOTE_FETCH_MODES.has(fetchMode)) {
+            throw new Error('Remote artifact fetches require fetchMode "public-only" or "allow-private-hosts".');
+        }
+    }
+    else if (fetchMode !== 'not-applicable' && fetchMode !== 'unknown') {
+        throw new Error('Non-remote artifact inputs require fetchMode "not-applicable" or "unknown".');
+    }
+    const allowPrivateHosts = fetchMode === 'allow-private-hosts'
+        || (fetchMode === 'unknown' && input.allowPrivateHosts === true);
+    return {
+        acquisitionMode,
+        fetchMode,
+        allowPrivateHosts,
+    };
+}
+export class ArtifactStore {
+    rootDir;
+    records = new Map();
+    maxBytes;
+    defaultRetentionMs;
+    maxRetentionMs;
+    trustedHosts;
+    blockedHosts;
+    allowPrivateHostFetches;
+    constructor(config) {
+        this.rootDir = resolveArtifactRootDir(config);
+        this.maxBytes = Math.max(1, config.maxBytes ?? DEFAULT_ARTIFACT_MAX_BYTES);
+        this.defaultRetentionMs = Math.max(0, config.defaultRetentionMs ?? DEFAULT_ARTIFACT_RETENTION_MS);
+        this.maxRetentionMs = Math.max(this.defaultRetentionMs, config.maxRetentionMs ?? DEFAULT_MAX_RETENTION_MS);
+        this.trustedHosts = [...(config.trustedHosts ?? [])];
+        this.blockedHosts = [...(config.blockedHosts ?? [])];
+        this.allowPrivateHostFetches = config.allowPrivateHostFetches
+            ?? Boolean(config.configManager?.get?.('network.remoteFetch.allowPrivateHosts'));
+        mkdirSync(this.rootDir, { recursive: true });
+        this.loadExisting();
+    }
+    get storagePath() {
+        return this.rootDir;
+    }
+    list(limit = 100) {
+        this.pruneExpired();
+        return [...this.records.values()]
+            .sort((a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id))
+            .slice(0, Math.max(1, limit))
+            .map((record) => this.toDescriptor(record));
+    }
+    get(id) {
+        this.pruneExpired();
+        const record = this.records.get(id);
+        return record ? this.toDescriptor(record) : null;
+    }
+    getRecord(id) {
+        this.pruneExpired();
+        return this.records.get(id) ?? null;
+    }
+    async readContent(id) {
+        this.pruneExpired();
+        const record = this.records.get(id);
+        if (!record)
+            throw new Error(`Unknown artifact: ${id}`);
+        return {
+            record,
+            buffer: await readFile(record.contentPath),
+        };
+    }
+    async create(input) {
+        const intent = resolveArtifactIntent(input);
+        const resolved = await this.resolveInput(input, intent);
+        if (resolved.buffer.length > this.maxBytes) {
+            throw new Error(`Artifact exceeds the ${this.maxBytes}-byte limit.`);
+        }
+        const id = `artifact-${randomUUID().slice(0, 8)}`;
+        const filename = sanitizeArtifactFilename(resolved.filename, 'artifact');
+        const contentPath = join(this.rootDir, `${id}.data`);
+        const metadataPath = join(this.rootDir, `${id}.json`);
+        const retentionMs = sanitizeRetentionMs(input.retentionMs, this.defaultRetentionMs, this.maxRetentionMs);
+        await mkdir(this.rootDir, { recursive: true });
+        if (resolved.path) {
+            await copyFile(resolved.path, contentPath);
+        }
+        else {
+            await writeFile(contentPath, resolved.buffer);
+        }
+        const record = {
+            id,
+            kind: input.kind ?? inferArtifactKind(resolved.mimeType, filename),
+            mimeType: resolved.mimeType,
+            filename,
+            sizeBytes: resolved.buffer.length,
+            sha256: createHash('sha256').update(resolved.buffer).digest('hex'),
+            createdAt: Date.now(),
+            ...(retentionMs ? { expiresAt: Date.now() + retentionMs } : {}),
+            ...(resolved.sourceUri ? { sourceUri: resolved.sourceUri } : {}),
+            acquisitionMode: intent.acquisitionMode,
+            fetchMode: intent.fetchMode,
+            metadata: input.metadata ?? {},
+            contentPath,
+            metadataPath,
+        };
+        await writeFile(metadataPath, `${JSON.stringify(record, null, 2)}\n`, 'utf-8');
+        this.records.set(id, record);
+        return this.toDescriptor(record);
+    }
+    async toAttachment(reference, options = {}) {
+        const record = this.records.get(reference.artifactId);
+        if (!record)
+            throw new Error(`Unknown artifact: ${reference.artifactId}`);
+        const relativeContentPath = `/api/artifacts/${encodeURIComponent(record.id)}/content`;
+        const attachment = {
+            artifactId: record.id,
+            label: reference.label,
+            metadata: {
+                ...record.metadata,
+                ...(reference.metadata ?? {}),
+            },
+            id: record.id,
+            kind: record.kind,
+            mimeType: record.mimeType,
+            filename: record.filename,
+            sizeBytes: record.sizeBytes,
+            sha256: record.sha256,
+            createdAt: record.createdAt,
+            acquisitionMode: record.acquisitionMode,
+            fetchMode: record.fetchMode,
+            contentPath: relativeContentPath,
+            ...(options.contentUrl ? { contentUrl: options.contentUrl } : {}),
+        };
+        if (typeof options.includeBase64IfSmallerThan === 'number'
+            && record.sizeBytes <= Math.max(0, options.includeBase64IfSmallerThan)) {
+            const { buffer } = await this.readContent(record.id);
+            return {
+                ...attachment,
+                dataBase64: buffer.toString('base64'),
+            };
+        }
+        return attachment;
+    }
+    toDescriptor(record) {
+        return {
+            id: record.id,
+            kind: record.kind,
+            mimeType: record.mimeType,
+            filename: record.filename,
+            sizeBytes: record.sizeBytes,
+            sha256: record.sha256,
+            createdAt: record.createdAt,
+            ...(typeof record.expiresAt === 'number' ? { expiresAt: record.expiresAt } : {}),
+            ...(typeof record.sourceUri === 'string' ? { sourceUri: record.sourceUri } : {}),
+            acquisitionMode: record.acquisitionMode,
+            fetchMode: record.fetchMode,
+            metadata: record.metadata,
+        };
+    }
+    loadExisting() {
+        if (!existsSync(this.rootDir))
+            return;
+        for (const entry of readdirSync(this.rootDir)) {
+            if (!entry.endsWith('.json'))
+                continue;
+            const metadataPath = join(this.rootDir, entry);
+            try {
+                const parsed = normalizeExistingRecord(JSON.parse(readFileSync(metadataPath, 'utf-8')));
+                if (!parsed?.id || typeof parsed.contentPath !== 'string' || !existsSync(parsed.contentPath))
+                    continue;
+                if (typeof parsed.expiresAt === 'number' && parsed.expiresAt <= Date.now()) {
+                    this.removeRecordFiles(parsed);
+                    continue;
+                }
+                this.records.set(parsed.id, parsed);
+            }
+            catch (error) {
+                logger.debug('[artifacts] skipping unreadable artifact metadata', {
+                    path: metadataPath,
+                    error: summarizeError(error),
+                });
+            }
+        }
+    }
+    pruneExpired(now = Date.now()) {
+        for (const record of this.records.values()) {
+            if (typeof record.expiresAt === 'number' && record.expiresAt <= now) {
+                this.removeRecordFiles(record);
+            }
+        }
+    }
+    removeRecordFiles(record) {
+        this.records.delete(record.id);
+        try {
+            if (existsSync(record.contentPath))
+                rmSync(record.contentPath, { force: true });
+            if (existsSync(record.metadataPath))
+                rmSync(record.metadataPath, { force: true });
+        }
+        catch (error) {
+            logger.debug('[artifacts] failed to prune expired artifact files', {
+                artifactId: record.id,
+                error: summarizeError(error),
+            });
+        }
+    }
+    async resolveInput(input, intent) {
+        if (typeof input.dataBase64 === 'string') {
+            const filename = sanitizeArtifactFilename(input.filename, 'artifact');
+            return {
+                buffer: Buffer.from(input.dataBase64, 'base64'),
+                mimeType: normalizeMimeType(input.mimeType, filename),
+                filename,
+                ...(typeof input.sourceUri === 'string' && input.sourceUri.trim().length > 0 ? { sourceUri: input.sourceUri.trim() } : {}),
+            };
+        }
+        if (typeof input.text === 'string') {
+            const filename = sanitizeArtifactFilename(input.filename, 'artifact.txt');
+            return {
+                buffer: Buffer.from(input.text, 'utf-8'),
+                mimeType: normalizeMimeType(input.mimeType ?? guessMimeType(filename) ?? 'text/plain', filename),
+                filename,
+                ...(typeof input.sourceUri === 'string' && input.sourceUri.trim().length > 0 ? { sourceUri: input.sourceUri.trim() } : {}),
+            };
+        }
+        if (typeof input.path === 'string' && input.path.trim().length > 0) {
+            const normalizedPath = input.path.trim();
+            const buffer = await readFile(normalizedPath);
+            const filename = sanitizeArtifactFilename(input.filename ?? basename(normalizedPath), 'artifact');
+            let mimeType = input.mimeType;
+            if (!mimeType) {
+                const bunType = Bun.file(normalizedPath).type;
+                mimeType = bunType && bunType.trim().length > 0 ? bunType : guessMimeType(filename);
+            }
+            if (buffer.length > this.maxBytes) {
+                throw new Error(`Artifact exceeds the ${this.maxBytes}-byte limit.`);
+            }
+            return {
+                buffer,
+                mimeType: normalizeMimeType(mimeType ?? 'application/octet-stream', filename),
+                filename,
+                path: normalizedPath,
+                ...(typeof input.sourceUri === 'string' && input.sourceUri.trim().length > 0 ? { sourceUri: input.sourceUri.trim() } : {}),
+            };
+        }
+        if (typeof input.uri === 'string' && input.uri.trim().length > 0) {
+            return this.resolveRemoteInput(input.uri.trim(), input.mimeType, input.filename, intent.fetchMode, intent.allowPrivateHosts);
+        }
+        throw new Error('Artifact input requires dataBase64, text, path, or uri');
+    }
+    async resolveRemoteInput(uri, mimeTypeOverride, filenameOverride, fetchMode = 'public-only', allowPrivateHosts = false) {
+        const parsed = new URL(uri);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw new Error(`Unsupported artifact URI scheme: ${parsed.protocol}`);
+        }
+        let current = parsed.toString();
+        for (let redirectCount = 0; redirectCount < 5; redirectCount += 1) {
+            if (allowPrivateHosts && !this.allowPrivateHostFetches) {
+                throw new Error('Private-host remote artifact fetches are disabled by config.');
+            }
+            this.assertRemoteHostAllowed(current, fetchMode);
+            const response = await fetch(current, {
+                method: 'GET',
+                redirect: 'manual',
+            });
+            if ([301, 302, 303, 307, 308].includes(response.status)) {
+                const location = response.headers.get('location');
+                if (!location)
+                    throw new Error(`Artifact URI redirect missing location header: ${current}`);
+                current = new URL(location, current).toString();
+                continue;
+            }
+            if (!response.ok) {
+                throw new Error(`Artifact URI fetch failed (${response.status}) for ${current}`);
+            }
+            const contentLength = Number(response.headers.get('content-length') ?? NaN);
+            if (Number.isFinite(contentLength) && contentLength > this.maxBytes) {
+                throw new Error(`Remote artifact exceeds the ${this.maxBytes}-byte limit.`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            if (buffer.length > this.maxBytes) {
+                throw new Error(`Remote artifact exceeds the ${this.maxBytes}-byte limit.`);
+            }
+            const filename = sanitizeArtifactFilename(filenameOverride
+                ?? this.filenameFromContentDisposition(response.headers.get('content-disposition'))
+                ?? filenameFromUrl(current), 'artifact');
+            return {
+                buffer,
+                mimeType: normalizeMimeType(mimeTypeOverride ?? response.headers.get('content-type') ?? undefined, filename),
+                filename,
+                sourceUri: current,
+            };
+        }
+        throw new Error(`Artifact URI exceeded redirect limit: ${uri}`);
+    }
+    filenameFromContentDisposition(header) {
+        if (!header)
+            return undefined;
+        const match = header.match(/filename\*?=(?:UTF-8''|")?([^";]+)/i);
+        if (!match?.[1])
+            return undefined;
+        try {
+            return decodeURIComponent(match[1].replace(/^"|"$/g, ''));
+        }
+        catch {
+            return match[1].replace(/^"|"$/g, '');
+        }
+    }
+    assertRemoteHostAllowed(uri, fetchMode) {
+        const hostname = extractHostname(uri);
+        if (!hostname) {
+            throw new Error(`Could not resolve artifact URI host: ${uri}`);
+        }
+        const result = classifyHostTrustTier(hostname, {
+            trustedHosts: [...this.trustedHosts],
+            blockedHosts: [...this.blockedHosts],
+        });
+        const allowPrivateHosts = fetchMode === 'allow-private-hosts';
+        if (result.tier === 'blocked' && (!allowPrivateHosts || !result.isSsrf)) {
+            throw new Error(`Artifact URI blocked by SSRF policy: ${result.reason}`);
+        }
+    }
+}

package/dist/_internal/platform/artifacts/types.d.ts

@@ -0,0 +1,56 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export type ArtifactKind = 'file' | 'image' | 'audio' | 'video' | 'document' | 'archive' | 'data';
+export declare const ARTIFACT_ACQUISITION_MODES: readonly ["inline-data", "local-path", "remote-fetch", "unknown"];
+export declare const ARTIFACT_FETCH_MODES: readonly ["not-applicable", "public-only", "allow-private-hosts", "unknown"];
+export type ArtifactAcquisitionMode = typeof ARTIFACT_ACQUISITION_MODES[number];
+export type ArtifactFetchMode = typeof ARTIFACT_FETCH_MODES[number];
+export interface ArtifactDescriptor {
+    readonly id: string;
+    readonly kind: ArtifactKind;
+    readonly mimeType: string;
+    readonly filename?: string;
+    readonly sizeBytes: number;
+    readonly sha256: string;
+    readonly createdAt: number;
+    readonly expiresAt?: number;
+    readonly sourceUri?: string;
+    readonly acquisitionMode: ArtifactAcquisitionMode;
+    readonly fetchMode: ArtifactFetchMode;
+    readonly metadata: Record<string, unknown>;
+}
+export interface ArtifactRecord extends ArtifactDescriptor {
+    readonly contentPath: string;
+    readonly metadataPath: string;
+}
+export interface ArtifactReference {
+    readonly artifactId: string;
+    readonly label?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface ArtifactAttachment extends ArtifactDescriptor {
+    readonly artifactId: string;
+    readonly label?: string;
+    readonly contentPath: string;
+    readonly contentUrl?: string;
+    readonly dataBase64?: string;
+}
+export interface ArtifactCreateInput {
+    readonly kind?: ArtifactKind;
+    readonly mimeType?: string;
+    readonly filename?: string;
+    readonly dataBase64?: string;
+    readonly text?: string;
+    readonly path?: string;
+    readonly uri?: string;
+    readonly sourceUri?: string;
+    readonly retentionMs?: number;
+    readonly acquisitionMode?: ArtifactAcquisitionMode;
+    readonly fetchMode?: ArtifactFetchMode;
+    readonly allowPrivateHosts?: boolean;
+    readonly metadata?: Record<string, unknown>;
+}
+export declare const EXTENSION_MIME_TYPES: Record<string, string>;
+export declare function guessMimeType(filename?: string): string;
+export declare function inferArtifactKind(mimeType: string, filename?: string): ArtifactKind;
+export declare function sanitizeArtifactFilename(filename: string | undefined, fallback?: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/artifacts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/artifacts/types.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/artifacts/types.js

@@ -0,0 +1,92 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export const ARTIFACT_ACQUISITION_MODES = ['inline-data', 'local-path', 'remote-fetch', 'unknown'];
+export const ARTIFACT_FETCH_MODES = ['not-applicable', 'public-only', 'allow-private-hosts', 'unknown'];
+export const EXTENSION_MIME_TYPES = {
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.markdown': 'text/markdown',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.tsv': 'text/tab-separated-values',
+    '.yaml': 'application/yaml',
+    '.yml': 'application/yaml',
+    '.xml': 'application/xml',
+    '.html': 'text/html',
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.zip': 'application/zip',
+    '.gz': 'application/gzip',
+    '.tar': 'application/x-tar',
+    '.tgz': 'application/gzip',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.bmp': 'image/bmp',
+    '.ico': 'image/x-icon',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff',
+    '.avif': 'image/avif',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.flac': 'audio/flac',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+};
+export function guessMimeType(filename) {
+    if (!filename)
+        return 'application/octet-stream';
+    const ext = filename.toLowerCase().match(/\.[^.]+$/)?.[0] ?? '';
+    return EXTENSION_MIME_TYPES[ext] ?? 'application/octet-stream';
+}
+export function inferArtifactKind(mimeType, filename) {
+    const lower = mimeType.toLowerCase();
+    if (lower.startsWith('image/'))
+        return 'image';
+    if (lower.startsWith('audio/'))
+        return 'audio';
+    if (lower.startsWith('video/'))
+        return 'video';
+    if (lower === 'application/json'
+        || lower === 'text/csv'
+        || lower === 'text/tab-separated-values'
+        || lower === 'application/xml'
+        || lower === 'application/yaml'
+        || lower.includes('spreadsheetml')
+        || lower === 'application/vnd.ms-excel') {
+        return 'data';
+    }
+    if (lower === 'application/pdf'
+        || lower.startsWith('text/')
+        || lower.includes('wordprocessingml')
+        || lower === 'application/msword'
+        || lower.includes('presentationml')
+        || lower === 'application/vnd.ms-powerpoint') {
+        return 'document';
+    }
+    if (lower === 'application/zip'
+        || lower === 'application/gzip'
+        || lower === 'application/x-tar') {
+        return 'archive';
+    }
+    const fromFilename = guessMimeType(filename);
+    if (fromFilename !== 'application/octet-stream' && fromFilename !== lower) {
+        return inferArtifactKind(fromFilename, undefined);
+    }
+    return 'file';
+}
+export function sanitizeArtifactFilename(filename, fallback = 'artifact') {
+    const trimmed = (filename ?? fallback).trim().replace(/[\\/:*?"<>|]+/g, '-');
+    return trimmed.length > 0 ? trimmed : fallback;
+}

package/dist/_internal/platform/automation/delivery.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Delivery policy and delivery-attempt types.
+ */
+import type { AutomationSurfaceKind } from './types.js';
+export type AutomationDeliveryMode = 'none' | 'webhook' | 'surface' | 'integration' | 'link';
+export interface AutomationDeliveryTarget {
+    readonly kind: AutomationDeliveryMode;
+    readonly surfaceKind?: AutomationSurfaceKind;
+    readonly address?: string;
+    readonly routeId?: string;
+    readonly label?: string;
+}
+export interface AutomationDeliveryPolicy {
+    readonly mode: AutomationDeliveryMode;
+    readonly targets: readonly AutomationDeliveryTarget[];
+    readonly fallbackTargets: readonly AutomationDeliveryTarget[];
+    readonly includeSummary: boolean;
+    readonly includeTranscript: boolean;
+    readonly includeLinks: boolean;
+    readonly replyToRouteId?: string;
+}
+export interface AutomationDeliveryAttempt {
+    readonly id: string;
+    readonly runId: string;
+    readonly jobId: string;
+    readonly target: AutomationDeliveryTarget;
+    readonly status: 'pending' | 'sending' | 'sent' | 'failed' | 'dead_lettered';
+    readonly startedAt?: number;
+    readonly endedAt?: number;
+    readonly error?: string;
+    readonly responseId?: string;
+}
+//# sourceMappingURL=delivery.d.ts.map

package/dist/_internal/platform/automation/delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/delivery.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,MAAM,CAAC;AAE7F,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACtD,QAAQ,CAAC,eAAe,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC9D,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,eAAe,CAAC;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/_internal/platform/automation/delivery.js

@@ -0,0 +1,4 @@
+/**
+ * Delivery policy and delivery-attempt types.
+ */
+export {};

package/dist/_internal/platform/automation/failures.d.ts

@@ -0,0 +1,35 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Failure policy and failure record types.
+ */
+export type AutomationFailureAction = 'retry' | 'cooldown' | 'disable' | 'dead_letter';
+export type AutomationRetryStrategy = 'fixed' | 'linear' | 'exponential';
+export interface AutomationRetryPolicy {
+    readonly maxAttempts: number;
+    readonly delayMs: number;
+    readonly strategy: AutomationRetryStrategy;
+    readonly maxDelayMs?: number;
+    readonly jitterMs?: number;
+}
+export interface AutomationFailurePolicy {
+    readonly action: AutomationFailureAction;
+    readonly maxConsecutiveFailures: number;
+    readonly cooldownMs: number;
+    readonly retryPolicy: AutomationRetryPolicy;
+    readonly deadLetterRouteId?: string;
+    readonly disableAfterFailures?: boolean;
+    readonly notifyRouteId?: string;
+}
+export interface AutomationFailureRecord {
+    readonly id: string;
+    readonly jobId: string;
+    readonly runId?: string;
+    readonly occurredAt: number;
+    readonly reason: string;
+    readonly action: AutomationFailureAction;
+    readonly consecutiveFailures: number;
+    readonly autoDisabled: boolean;
+    readonly deadLetterRouteId?: string;
+    readonly metadata: Record<string, unknown>;
+}
+//# sourceMappingURL=failures.d.ts.map

package/dist/_internal/platform/automation/failures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failures.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/failures.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;GAEG;AAEH,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,CAAC;AACvF,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,CAAC;AAEzE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C"}

package/dist/_internal/platform/automation/failures.js

@@ -0,0 +1,2 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export {};