@pellux/goodvibes-sdk 0.28.22 → 0.30.1

package/dist/platform/utils/clipboard.js

@@ -1 +1,130 @@
-export * from '../../_internal/platform/utils/clipboard.js';
+import { logger } from './logger.js';
+import { summarizeError } from './error-display.js';
+export const MIN_IMAGE_BYTES = 100;
+const IMAGE_MIME_TYPES = [
+    { mime: 'image/png', mediaType: 'image/png' },
+    { mime: 'image/jpeg', mediaType: 'image/jpeg' },
+    { mime: 'image/webp', mediaType: 'image/webp' },
+    { mime: 'image/gif', mediaType: 'image/gif' },
+];
+/**
+ * pasteFromClipboard - Attempts to read from system clipboard using platform tools.
+ */
+export function pasteFromClipboard() {
+    try {
+        if (process.platform === 'linux') {
+            // Try wl-paste (Wayland) then xclip (X11)
+            const wl = Bun.spawnSync(['wl-paste', '--no-newline'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'ignore',
+                timeout: 3000,
+            });
+            if (wl.exitCode === 0 && wl.stdout) {
+                return Buffer.from(wl.stdout).toString();
+            }
+            const xclip = Bun.spawnSync(['xclip', '-selection', 'clipboard', '-o'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'ignore',
+                timeout: 3000,
+            });
+            if (xclip.exitCode === 0 && xclip.stdout) {
+                return Buffer.from(xclip.stdout).toString();
+            }
+        }
+        else if (process.platform === 'darwin') {
+            const pb = Bun.spawnSync(['pbpaste'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'ignore',
+                timeout: 3000,
+            });
+            if (pb.exitCode === 0 && pb.stdout) {
+                return Buffer.from(pb.stdout).toString();
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Clipboard: Paste failed', { error: summarizeError(err) });
+    }
+    return '';
+}
+/**
+ * pasteImageFromClipboard - Attempts to read image data from system clipboard.
+ * Returns base64-encoded image data and mediaType, or null if no image is available.
+ */
+export function pasteImageFromClipboard() {
+    try {
+        if (process.platform === 'linux') {
+            // Try wl-paste (Wayland) for each supported MIME type
+            for (const { mime, mediaType } of IMAGE_MIME_TYPES) {
+                const wl = Bun.spawnSync(['wl-paste', '--type', mime, '--no-newline'], {
+                    stdin: 'ignore',
+                    stdout: 'pipe',
+                    stderr: 'ignore',
+                    timeout: 3000,
+                });
+                if (wl.exitCode === 0 && wl.stdout) {
+                    const buf = Buffer.from(wl.stdout);
+                    if (buf.length > MIN_IMAGE_BYTES) {
+                        return { data: buf.toString('base64'), mediaType };
+                    }
+                }
+            }
+            // Try xclip (X11) for each supported MIME type
+            for (const { mime, mediaType } of IMAGE_MIME_TYPES) {
+                const xclip = Bun.spawnSync(['xclip', '-selection', 'clipboard', '-t', mime, '-o'], {
+                    stdin: 'ignore',
+                    stdout: 'pipe',
+                    stderr: 'ignore',
+                    timeout: 3000,
+                });
+                if (xclip.exitCode === 0 && xclip.stdout) {
+                    const buf = Buffer.from(xclip.stdout);
+                    if (buf.length > MIN_IMAGE_BYTES) {
+                        return { data: buf.toString('base64'), mediaType };
+                    }
+                }
+            }
+        }
+        else if (process.platform === 'darwin') {
+            // macOS: try pngpaste first (brew install pngpaste), then fall back to osascript
+            const pp = Bun.spawnSync(['pngpaste', '-'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'ignore',
+                timeout: 3000,
+            });
+            if (pp.exitCode === 0 && pp.stdout) {
+                const ppBuf = Buffer.from(pp.stdout);
+                if (ppBuf.length > MIN_IMAGE_BYTES) {
+                    return { data: ppBuf.toString('base64'), mediaType: 'image/png' };
+                }
+            }
+            // Fallback: osascript — reads clipboard as PNG hex data
+            // Output format: «data PNGf<hex>» — extract hex after 'PNGf'
+            const osa = Bun.spawnSync(['osascript', '-e', 'the clipboard as «class PNGf»'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'ignore',
+                timeout: 5000,
+            });
+            if (osa.exitCode === 0 && osa.stdout) {
+                const raw = Buffer.from(osa.stdout).toString('utf8').trim();
+                // raw is like: «data PNGf89504e47...»
+                const match = raw.match(/«data PNGf([0-9a-fA-F]+)»/);
+                if (match) {
+                    const osaBuf = Buffer.from(match[1], 'hex');
+                    if (osaBuf.length > MIN_IMAGE_BYTES) {
+                        return { data: osaBuf.toString('base64'), mediaType: 'image/png' };
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.debug('Clipboard image access failed', { error: summarizeError(err) });
+    }
+    return null;
+}

package/dist/platform/utils/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/concurrency.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAC3C,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7C,OAAO,CAAC,CAAC,EAAE,CAAC,CAmBd"}

package/dist/platform/utils/error-display.d.ts

@@ -1,2 +1,35 @@
-export * from '../../_internal/platform/utils/error-display.js';
+import { ProviderError, type ErrorCategory, type ErrorSource, type ProviderErrorOptions } from '../types/errors.js';
+import type { StructuredDaemonErrorBody } from '../types/daemon-error-contract.js';
+export interface NormalizedError {
+    readonly name: string;
+    readonly message: string;
+    readonly summary: string;
+    readonly hint?: string;
+    readonly code?: string;
+    readonly category: ErrorCategory;
+    readonly source: ErrorSource;
+    readonly recoverable: boolean;
+    readonly statusCode?: number;
+    readonly provider?: string;
+    readonly operation?: string;
+    readonly phase?: string;
+    readonly requestId?: string;
+    readonly providerCode?: string;
+    readonly providerType?: string;
+    readonly retryAfterMs?: number;
+}
+export interface ErrorNormalizationOptions {
+    readonly provider?: string;
+    readonly fallbackMessage?: string;
+    readonly source?: ErrorSource;
+}
+export interface ProviderErrorNormalizationOptions extends ProviderErrorOptions {
+    readonly fallbackMessage?: string;
+}
+export declare function normalizeError(error: unknown, options?: ErrorNormalizationOptions): NormalizedError;
+export declare function summarizeError(error: unknown, options?: ErrorNormalizationOptions): string;
+export declare function formatError(error: unknown, options?: ErrorNormalizationOptions): string;
+export declare function buildErrorResponseBody(error: unknown, options?: ErrorNormalizationOptions): StructuredDaemonErrorBody;
+export declare function toProviderError(error: unknown, options?: ProviderErrorNormalizationOptions): ProviderError;
+export declare function formatProviderError(error: ProviderError, provider?: string): string;
 //# sourceMappingURL=error-display.d.ts.map

package/dist/platform/utils/error-display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-display.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/error-display.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"error-display.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/error-display.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC9H,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAuBnF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,MAAM,WAAW,iCAAkC,SAAQ,oBAAoB;IAC7E,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAmJD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,eAAe,CA6CvG;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,MAAM,CAE9F;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,MAAM,CAU3F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,yBAAyB,CAkBzH;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,iCAAsC,GAAG,aAAa,CA0D9G;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnF"}

package/dist/platform/utils/error-display.js

@@ -1 +1,316 @@
-export * from '../../_internal/platform/utils/error-display.js';
+import { AppError, ProviderError } from '../types/errors.js';
+import { redactSensitiveData } from './redaction.js';
+const MAX_ERROR_LENGTH = 240;
+const NETWORK_ERROR_PATTERNS = [
+    {
+        pattern: /ECONNREFUSED/i,
+        category: 'network',
+        message: (provider) => `Cannot connect to ${provider ?? 'the provider'}. Check whether the service is reachable.`,
+    },
+    {
+        pattern: /ETIMEDOUT|ECONNABORTED|timed?[\s_-]?out/i,
+        category: 'timeout',
+        message: () => 'Connection timed out before the request completed.',
+    },
+    {
+        pattern: /ENOTFOUND|EAI_AGAIN/i,
+        category: 'network',
+        message: (provider) => `DNS lookup failed for ${provider ?? 'the provider'}. Check the base URL and network.`,
+    },
+];
+function truncateMessage(msg) {
+    if (msg.length <= MAX_ERROR_LENGTH)
+        return msg;
+    return msg.slice(0, MAX_ERROR_LENGTH) + '\u2026';
+}
+function extractStringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function extractStructuredMessage(msg) {
+    const trimmed = msg.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!parsed || typeof parsed !== 'object')
+            return undefined;
+        const record = parsed;
+        const nestedError = record.error && typeof record.error === 'object' ? record.error : undefined;
+        const parts = [
+            extractStringField(record, 'message'),
+            nestedError ? extractStringField(nestedError, 'message') : undefined,
+            nestedError ? extractStringField(nestedError, 'code') : undefined,
+            nestedError ? extractStringField(nestedError, 'type') : undefined,
+            extractStringField(record, 'code'),
+            extractStringField(record, 'type'),
+        ].filter((value) => Boolean(value));
+        return parts.length > 0 ? parts.join(', ') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripJson(msg) {
+    return msg
+        .replace(/\{[^{}]{0,500}\}/g, ' ')
+        .replace(/\[[^\[\]]{0,500}\]/g, ' ')
+        .replace(/\s{2,}/g, ' ')
+        .trim();
+}
+function cleanMessage(msg, fallbackMessage) {
+    const structured = extractStructuredMessage(msg);
+    if (structured)
+        return truncateMessage(structured);
+    const stripped = stripJson(msg);
+    if (stripped.length > 0)
+        return truncateMessage(stripped);
+    if (msg.trim().length > 0)
+        return truncateMessage(msg.trim());
+    return fallbackMessage ?? 'Unexpected error';
+}
+function inferCategory(message, statusCode) {
+    const msg = message.toLowerCase();
+    if (statusCode === 401)
+        return 'authentication';
+    if (statusCode === 402)
+        return 'billing';
+    if (statusCode === 403)
+        return 'authorization';
+    if (statusCode === 404)
+        return 'not_found';
+    if (statusCode === 408)
+        return 'timeout';
+    if (statusCode === 429)
+        return 'rate_limit';
+    if (statusCode === 400)
+        return 'bad_request';
+    if (statusCode !== undefined && statusCode >= 500)
+        return 'service';
+    if (/api[_\s-]?key|auth|token|credential|jwt|unauthoriz/.test(msg))
+        return 'authentication';
+    if (/forbidden|access denied|permission denied|not allowed/.test(msg))
+        return 'authorization';
+    if (/billing|payment required|credits?|quota|depleted|insufficient balance/.test(msg))
+        return 'billing';
+    if (/rate.limit|too many requests|throttl/.test(msg))
+        return 'rate_limit';
+    if (/timed?[\s_-]?out|etimedout|deadline exceeded/.test(msg))
+        return 'timeout';
+    if (/econnrefused|enotfound|ehostunreach|econnreset|socket hang up|fetch failed|dns|tls|ssl|certificate/.test(msg))
+        return 'network';
+    if (/not found|unknown model|no such model|unsupported model|unknown endpoint/.test(msg))
+        return 'not_found';
+    if (/invalid request|bad request|invalid argument|schema|malformed|unsupported parameter/.test(msg))
+        return 'bad_request';
+    if (/invalid json|parse|no response body|unexpected eof|stream ended|malformed response/.test(msg))
+        return 'protocol';
+    return 'unknown';
+}
+function inferHint(category, statusCode) {
+    switch (category) {
+        case 'rate_limit':
+            return 'The caller may retry automatically. If this persists, wait, lower request volume, or switch models/providers.';
+        case 'authentication':
+            return 'Possible causes: invalid or expired credentials, missing subscription/session state, account restrictions, or the wrong provider/endpoint receiving the request.';
+        case 'authorization':
+            return 'Possible causes: missing model access, account permissions, safety/policy restrictions, or provider routing to a service that does not expose this model.';
+        case 'billing':
+            return 'Check credits, subscription status, usage limits, or account entitlements.';
+        case 'timeout':
+            return 'Check network stability, provider latency, and request size.';
+        case 'network':
+            return 'Check connectivity, DNS, TLS certificates, base URL, or any local proxy/tunnel.';
+        case 'bad_request':
+            return 'Check model id, parameters, message format, and tool schema.';
+        case 'not_found':
+            return 'Check model id, provider selection, and API path.';
+        case 'protocol':
+            return 'Check upstream protocol support, streaming mode, and transport stability.';
+        case 'service':
+            return statusCode === 503
+                ? 'The provider is temporarily unavailable. Retry shortly or switch providers if the issue persists.'
+                : 'The provider returned a server-side failure. Retry shortly or switch providers if the issue persists.';
+        default:
+            return undefined;
+    }
+}
+function inferSource(error, override) {
+    if (override)
+        return override;
+    if (error instanceof AppError && error.source)
+        return error.source;
+    if (error instanceof Error && error.name === 'TypeError' && /fetch/i.test(error.message))
+        return 'transport';
+    return 'unknown';
+}
+function buildSummary(message, metadata) {
+    const tags = [];
+    if (metadata.phase && !message.toLowerCase().includes(metadata.phase.toLowerCase()))
+        tags.push(`phase=${metadata.phase}`);
+    if (metadata.providerCode && !message.includes(metadata.providerCode))
+        tags.push(`code=${metadata.providerCode}`);
+    if (metadata.requestId && !message.includes(metadata.requestId))
+        tags.push(`request_id=${metadata.requestId}`);
+    return tags.length > 0 ? `${message} (${tags.join(', ')})` : message;
+}
+function getNetworkErrorMessage(message, provider) {
+    for (const entry of NETWORK_ERROR_PATTERNS) {
+        if (entry.pattern.test(message)) {
+            return {
+                category: entry.category,
+                summary: entry.message(provider),
+            };
+        }
+    }
+    return undefined;
+}
+function extractErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const message = extractStringField(error, 'message');
+        if (message)
+            return message;
+    }
+    return String(error);
+}
+export function normalizeError(error, options = {}) {
+    // OBS-24: Redact Bearer tokens and API keys before any further processing.
+    const rawMessage = redactSensitiveData(extractErrorMessage(error));
+    const statusCode = error instanceof AppError
+        ? error.statusCode
+        : error && typeof error === 'object' && 'statusCode' in error && typeof error.statusCode === 'number'
+            ? error.statusCode
+            : error && typeof error === 'object' && 'status' in error && typeof error.status === 'number'
+                ? error.status
+                : undefined;
+    const provider = options.provider ?? (error instanceof AppError ? error.provider : undefined);
+    const cleanedMessage = cleanMessage(rawMessage, options.fallbackMessage);
+    const network = getNetworkErrorMessage(rawMessage, provider);
+    const category = (error instanceof AppError && error.category
+        ? error.category
+        : network?.category ?? inferCategory(cleanedMessage, statusCode));
+    const source = inferSource(error, options.source);
+    const summary = buildSummary(network?.summary ?? cleanedMessage, {
+        requestId: error instanceof AppError ? error.requestId : undefined,
+        providerCode: error instanceof AppError ? error.providerCode : undefined,
+        phase: error instanceof AppError ? error.phase : undefined,
+    });
+    const hint = error instanceof AppError && error.guidance
+        ? error.guidance
+        : inferHint(category, statusCode);
+    return {
+        name: error instanceof Error ? error.name : 'Error',
+        message: cleanedMessage,
+        summary,
+        ...(hint ? { hint } : {}),
+        ...(error instanceof AppError ? { code: error.code } : {}),
+        category,
+        source,
+        recoverable: error instanceof AppError ? error.recoverable : false,
+        ...(statusCode !== undefined ? { statusCode } : {}),
+        ...(provider ? { provider } : {}),
+        ...(error instanceof AppError && error.operation ? { operation: error.operation } : {}),
+        ...(error instanceof AppError && error.phase ? { phase: error.phase } : {}),
+        ...(error instanceof AppError && error.requestId ? { requestId: error.requestId } : {}),
+        ...(error instanceof AppError && error.providerCode ? { providerCode: error.providerCode } : {}),
+        ...(error instanceof AppError && error.providerType ? { providerType: error.providerType } : {}),
+        ...(error instanceof AppError && error.retryAfterMs !== undefined ? { retryAfterMs: error.retryAfterMs } : {}),
+    };
+}
+export function summarizeError(error, options = {}) {
+    return normalizeError(error, options).summary;
+}
+export function formatError(error, options = {}) {
+    const normalized = normalizeError(error, options);
+    const lines = [normalized.summary];
+    if (normalized.hint) {
+        lines.push(`  Hint: ${normalized.hint}`);
+    }
+    if (normalized.retryAfterMs !== undefined) {
+        lines.push(`  Retry in ${Math.ceil(normalized.retryAfterMs / 1000)}s`);
+    }
+    return lines.join('\n');
+}
+export function buildErrorResponseBody(error, options = {}) {
+    const normalized = normalizeError(error, options);
+    return {
+        error: normalized.summary,
+        ...(normalized.hint ? { hint: normalized.hint } : {}),
+        ...(normalized.code ? { code: normalized.code } : {}),
+        category: normalized.category,
+        source: normalized.source,
+        recoverable: normalized.recoverable,
+        ...(normalized.statusCode !== undefined ? { status: normalized.statusCode } : {}),
+        ...(normalized.provider ? { provider: normalized.provider } : {}),
+        ...(normalized.operation ? { operation: normalized.operation } : {}),
+        ...(normalized.phase ? { phase: normalized.phase } : {}),
+        ...(normalized.requestId ? { requestId: normalized.requestId } : {}),
+        ...(normalized.providerCode ? { providerCode: normalized.providerCode } : {}),
+        ...(normalized.providerType ? { providerType: normalized.providerType } : {}),
+        ...(normalized.retryAfterMs !== undefined ? { retryAfterMs: normalized.retryAfterMs } : {}),
+    };
+}
+export function toProviderError(error, options = {}) {
+    if (error instanceof ProviderError) {
+        return new ProviderError(error.message, {
+            statusCode: error.statusCode ?? options.statusCode,
+            category: (error.category ?? options.category),
+            guidance: error.guidance ?? options.guidance,
+            detail: error.detail ?? options.detail,
+            source: 'provider',
+            provider: error.provider ?? options.provider,
+            operation: error.operation ?? options.operation,
+            phase: error.phase ?? options.phase,
+            requestId: error.requestId ?? options.requestId,
+            providerCode: error.providerCode ?? options.providerCode,
+            providerType: error.providerType ?? options.providerType,
+            retryAfterMs: error.retryAfterMs ?? options.retryAfterMs,
+            rawMessage: error.rawMessage ?? options.rawMessage ?? error.message,
+        });
+    }
+    const normalized = normalizeError(error, {
+        provider: options.provider,
+        fallbackMessage: options.fallbackMessage,
+        source: 'provider',
+    });
+    return new ProviderError(normalized.message, {
+        ...(options.statusCode !== undefined || normalized.statusCode !== undefined
+            ? { statusCode: options.statusCode ?? normalized.statusCode }
+            : {}),
+        ...(options.category
+            ? { category: options.category }
+            : normalized.category !== 'unknown'
+                ? { category: normalized.category }
+                : {}),
+        ...(options.guidance
+            ? { guidance: options.guidance }
+            : normalized.hint
+                ? { guidance: normalized.hint }
+                : {}),
+        ...(options.detail ? { detail: options.detail } : {}),
+        source: 'provider',
+        ...(options.provider ?? normalized.provider ? { provider: options.provider ?? normalized.provider } : {}),
+        ...(options.operation ? { operation: options.operation } : {}),
+        ...(options.phase ? { phase: options.phase } : {}),
+        ...(options.requestId ?? normalized.requestId ? { requestId: options.requestId ?? normalized.requestId } : {}),
+        ...(options.providerCode ?? normalized.providerCode ? { providerCode: options.providerCode ?? normalized.providerCode } : {}),
+        ...(options.providerType ?? normalized.providerType ? { providerType: options.providerType ?? normalized.providerType } : {}),
+        ...(options.retryAfterMs ?? normalized.retryAfterMs !== undefined
+            ? { retryAfterMs: options.retryAfterMs ?? normalized.retryAfterMs }
+            : {}),
+        ...(options.rawMessage
+            ? { rawMessage: options.rawMessage }
+            : typeof error === 'string'
+                ? { rawMessage: error }
+                : error instanceof Error
+                    ? { rawMessage: error.message }
+                    : {}),
+    });
+}
+export function formatProviderError(error, provider) {
+    return formatError(error, { provider, source: 'provider' });
+}

package/dist/platform/utils/fetch-with-timeout.d.ts

@@ -1,2 +1,35 @@
-export * from '../../_internal/platform/utils/fetch-with-timeout.js';
+/**
+ * Sanitize a URL for logging: strip query params that might contain secrets.
+ * @internal Exported for testing only.
+ */
+export declare function sanitizeUrlForLog(url: string | URL | Request): string;
+/**
+ * instrumentedFetch — wraps the global fetch with structured OUTBOUND_HTTP logging.
+ *
+ * Use this in place of bare `fetch()` for non-streaming outbound HTTP calls where
+ * observability is required. For streaming calls (SSE/chat completions) where the
+ * caller already manages an AbortController, use fetch() directly — those streams
+ * manage their own lifecycle and do not benefit from this wrapper.
+ *
+ * @param url    - The URL or Request to fetch.
+ * @param init   - Standard RequestInit (optional).
+ */
+export declare function instrumentedFetch(url: string | URL | Request, init?: RequestInit): Promise<Response>;
+/**
+ * fetchWithTimeout — wraps the global fetch with an AbortController timeout.
+ *
+ * If the caller passes a signal that is already aborted, the request is
+ * rejected immediately. When both a caller signal and the internal timeout
+ * controller are present, they are merged via AbortSignal.any so that
+ * whichever fires first wins.
+ *
+ * Streaming fetches (SSE, chat completions) where the caller already manages
+ * an AbortController via ChatRequest.signal should NOT use this helper —
+ * pass the signal directly to fetch() as they already do.
+ *
+ * @param url       - The URL or Request to fetch.
+ * @param init      - Standard RequestInit (optional).
+ * @param timeoutMs - Milliseconds before aborting. Default: 30 000.
+ */
+export declare function fetchWithTimeout(url: string | URL | Request, init?: RequestInit, timeoutMs?: number): Promise<Response>;
 //# sourceMappingURL=fetch-with-timeout.d.ts.map

package/dist/platform/utils/fetch-with-timeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-with-timeout.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/fetch-with-timeout.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC"}
+{"version":3,"file":"fetch-with-timeout.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/fetch-with-timeout.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,GAAG,MAAM,CAarE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC3B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CAkBnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,SAAS,SAAS,GACjB,OAAO,CAAC,QAAQ,CAAC,CAmBnB"}

package/dist/platform/utils/fetch-with-timeout.js

@@ -1 +1,95 @@
-export * from '../../_internal/platform/utils/fetch-with-timeout.js';
+import { logger } from './logger.js';
+/**
+ * Sensitive query-parameter keys to strip from logged URLs.
+ * Values are replaced with "[redacted]" in OUTBOUND_HTTP log entries.
+ */
+const SENSITIVE_PARAMS = new Set([
+    'key', 'api_key', 'apikey', 'token', 'secret',
+    'access_token', 'apiToken', 'api-key',
+]);
+/**
+ * Sanitize a URL for logging: strip query params that might contain secrets.
+ * @internal Exported for testing only.
+ */
+export function sanitizeUrlForLog(url) {
+    try {
+        const raw = url instanceof Request ? url.url : String(url);
+        const parsed = new URL(raw);
+        for (const key of parsed.searchParams.keys()) {
+            if (SENSITIVE_PARAMS.has(key.toLowerCase())) {
+                parsed.searchParams.set(key, '[redacted]');
+            }
+        }
+        return `${parsed.origin}${parsed.pathname}${parsed.search ? parsed.search : ''}`;
+    }
+    catch {
+        return '[unparseable-url]';
+    }
+}
+/**
+ * instrumentedFetch — wraps the global fetch with structured OUTBOUND_HTTP logging.
+ *
+ * Use this in place of bare `fetch()` for non-streaming outbound HTTP calls where
+ * observability is required. For streaming calls (SSE/chat completions) where the
+ * caller already manages an AbortController, use fetch() directly — those streams
+ * manage their own lifecycle and do not benefit from this wrapper.
+ *
+ * @param url    - The URL or Request to fetch.
+ * @param init   - Standard RequestInit (optional).
+ */
+export async function instrumentedFetch(url, init) {
+    const startMs = Date.now();
+    const method = init?.method ?? 'GET';
+    const safeUrl = sanitizeUrlForLog(url);
+    let status = -1;
+    try {
+        const res = await fetch(url, init);
+        status = res.status;
+        return res;
+    }
+    finally {
+        logger.info('OUTBOUND_HTTP', {
+            type: 'OUTBOUND_HTTP',
+            method,
+            url: safeUrl,
+            status,
+            latencyMs: Date.now() - startMs,
+        });
+    }
+}
+/**
+ * fetchWithTimeout — wraps the global fetch with an AbortController timeout.
+ *
+ * If the caller passes a signal that is already aborted, the request is
+ * rejected immediately. When both a caller signal and the internal timeout
+ * controller are present, they are merged via AbortSignal.any so that
+ * whichever fires first wins.
+ *
+ * Streaming fetches (SSE, chat completions) where the caller already manages
+ * an AbortController via ChatRequest.signal should NOT use this helper —
+ * pass the signal directly to fetch() as they already do.
+ *
+ * @param url       - The URL or Request to fetch.
+ * @param init      - Standard RequestInit (optional).
+ * @param timeoutMs - Milliseconds before aborting. Default: 30 000.
+ */
+export async function fetchWithTimeout(url, init, timeoutMs = 30_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new DOMException('Request timed out', 'TimeoutError')), timeoutMs);
+    timer.unref?.();
+    let signal;
+    const callerSignal = init?.signal;
+    if (callerSignal) {
+        // Merge caller signal + our timeout: first one to fire wins
+        signal = AbortSignal.any([callerSignal, controller.signal]);
+    }
+    else {
+        signal = controller.signal;
+    }
+    try {
+        return await fetch(url, { ...init, signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/platform/utils/glob-to-regex.d.ts

@@ -1,2 +1,8 @@
-export * from '../../_internal/platform/utils/glob-to-regex.js';
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Shared glob-to-regex conversion utility.
+ * Handles **, *, and ? wildcards correctly for file path matching.
+ */
+export declare function buildGlobMatcher(glob: string): (path: string) => boolean;
+export declare function globToRegex(glob: string): RegExp;
 //# sourceMappingURL=glob-to-regex.d.ts.map

package/dist/platform/utils/glob-to-regex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glob-to-regex.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/glob-to-regex.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"glob-to-regex.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/glob-to-regex.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAGxE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBhD"}