@symbolica/agentica 0.2.11-rc

package/dist-transformer/errors/generation.d.ts

@@ -0,0 +1,75 @@
+import { AgenticaError } from './base.js';
+/** Base class for exceptions during remote operations. */
+export declare class ServerError extends AgenticaError {
+    constructor(message: string);
+}
+/** Base class for exceptions during agent generation. */
+export declare class GenerationError extends ServerError {
+    constructor(message: string);
+}
+/** Usage error. */
+export declare class UsageError extends GenerationError {
+    constructor(message: string);
+}
+/** Max tokens error. */
+export declare class MaxTokensError extends UsageError {
+    constructor(maxTokens: number | string);
+}
+/** Max rounds error. */
+export declare class MaxRoundsError extends UsageError {
+    constructor(maxRounds: number | string);
+}
+/** Content filtering error. */
+export declare class ContentFilteringError extends GenerationError {
+    constructor();
+}
+/** Base class for exceptions during inference, mainly HTTP errors. */
+export declare class InferenceError extends GenerationError {
+    constructor(message: string);
+}
+/** API connection error. */
+export declare class APIConnectionError extends InferenceError {
+}
+/** API timeout error. */
+export declare class APITimeoutError extends InferenceError {
+}
+/** Rate limit error. */
+export declare class RateLimitError extends InferenceError {
+}
+/** Bad request error. */
+export declare class BadRequestError extends InferenceError {
+}
+/** Unauthorized error. */
+export declare class UnauthorizedError extends InferenceError {
+}
+/** Permission denied error. */
+export declare class PermissionDeniedError extends InferenceError {
+}
+/** Insufficient credits error. */
+export declare class InsufficientCreditsError extends InferenceError {
+}
+/** Not found error. */
+export declare class NotFoundError extends InferenceError {
+}
+/** Conflict error. */
+export declare class ConflictError extends InferenceError {
+}
+/** Unprocessable entity error. */
+export declare class UnprocessableEntityError extends InferenceError {
+}
+/** Request too large error. */
+export declare class RequestTooLargeError extends InferenceError {
+}
+/** Service unavailable error. */
+export declare class ServiceUnavailableError extends InferenceError {
+}
+/** Overloaded error. */
+export declare class OverloadedError extends InferenceError {
+}
+/** Deadline exceeded error. */
+export declare class DeadlineExceededError extends InferenceError {
+}
+/** Internal server error. */
+export declare class InternalServerError extends InferenceError {
+}
+//# sourceMappingURL=generation.d.ts.map

package/dist-transformer/errors/generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation.d.ts","sourceRoot":"","sources":["../../src/errors/generation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,0DAA0D;AAC1D,qBAAa,WAAY,SAAQ,aAAa;gBAC9B,OAAO,EAAE,MAAM;CAG9B;AAID,yDAAyD;AACzD,qBAAa,eAAgB,SAAQ,WAAW;gBAChC,OAAO,EAAE,MAAM;CAG9B;AAID,mBAAmB;AACnB,qBAAa,UAAW,SAAQ,eAAe;gBAC/B,OAAO,EAAE,MAAM;CAG9B;AAED,wBAAwB;AACxB,qBAAa,cAAe,SAAQ,UAAU;gBAC9B,SAAS,EAAE,MAAM,GAAG,MAAM;CAOzC;AAED,wBAAwB;AACxB,qBAAa,cAAe,SAAQ,UAAU;gBAC9B,SAAS,EAAE,MAAM,GAAG,MAAM;CAOzC;AAED,+BAA+B;AAC/B,qBAAa,qBAAsB,SAAQ,eAAe;;CAIzD;AAED,sEAAsE;AACtE,qBAAa,cAAe,SAAQ,eAAe;gBACnC,OAAO,EAAE,MAAM;CAG9B;AAID,4BAA4B;AAC5B,qBAAa,kBAAmB,SAAQ,cAAc;CAAG;AAEzD,yBAAyB;AACzB,qBAAa,eAAgB,SAAQ,cAAc;CAAG;AAItD,wBAAwB;AACxB,qBAAa,cAAe,SAAQ,cAAc;CAAG;AAErD,yBAAyB;AACzB,qBAAa,eAAgB,SAAQ,cAAc;CAAG;AAEtD,0BAA0B;AAC1B,qBAAa,iBAAkB,SAAQ,cAAc;CAAG;AAExD,+BAA+B;AAC/B,qBAAa,qBAAsB,SAAQ,cAAc;CAAG;AAE5D,kCAAkC;AAClC,qBAAa,wBAAyB,SAAQ,cAAc;CAAG;AAE/D,uBAAuB;AACvB,qBAAa,aAAc,SAAQ,cAAc;CAAG;AAEpD,sBAAsB;AACtB,qBAAa,aAAc,SAAQ,cAAc;CAAG;AAEpD,kCAAkC;AAClC,qBAAa,wBAAyB,SAAQ,cAAc;CAAG;AAE/D,+BAA+B;AAC/B,qBAAa,oBAAqB,SAAQ,cAAc;CAAG;AAE3D,iCAAiC;AACjC,qBAAa,uBAAwB,SAAQ,cAAc;CAAG;AAE9D,wBAAwB;AACxB,qBAAa,eAAgB,SAAQ,cAAc;CAAG;AAEtD,+BAA+B;AAC/B,qBAAa,qBAAsB,SAAQ,cAAc;CAAG;AAE5D,6BAA6B;AAC7B,qBAAa,mBAAoB,SAAQ,cAAc;CAAG"}

package/dist-transformer/errors/generation.js

@@ -0,0 +1,98 @@
+import { AgenticaError } from './base.js';
+/** Base class for exceptions during remote operations. */
+export class ServerError extends AgenticaError {
+    constructor(message) {
+        super(message);
+    }
+}
+// === Base Exceptions ===
+/** Base class for exceptions during agent generation. */
+export class GenerationError extends ServerError {
+    constructor(message) {
+        super(message);
+    }
+}
+// === Generation Exceptions ===
+/** Usage error. */
+export class UsageError extends GenerationError {
+    constructor(message) {
+        super(message);
+    }
+}
+/** Max tokens error. */
+export class MaxTokensError extends UsageError {
+    constructor(maxTokens) {
+        const message = typeof maxTokens === 'number'
+            ? `The maximum number of tokens (${maxTokens}) has been reached.`
+            : String(maxTokens);
+        super(message);
+    }
+}
+/** Max rounds error. */
+export class MaxRoundsError extends UsageError {
+    constructor(maxRounds) {
+        const message = typeof maxRounds === 'number'
+            ? `The maximum number of rounds of inference (${maxRounds}) has been reached.`
+            : String(maxRounds);
+        super(message);
+    }
+}
+/** Content filtering error. */
+export class ContentFilteringError extends GenerationError {
+    constructor() {
+        super('The previously generated content has been filtered.');
+    }
+}
+/** Base class for exceptions during inference, mainly HTTP errors. */
+export class InferenceError extends GenerationError {
+    constructor(message) {
+        super(message);
+    }
+}
+// === Inference errors ===
+/** API connection error. */
+export class APIConnectionError extends InferenceError {
+}
+/** API timeout error. */
+export class APITimeoutError extends InferenceError {
+}
+// HTTP status errors
+/** Rate limit error. */
+export class RateLimitError extends InferenceError {
+}
+/** Bad request error. */
+export class BadRequestError extends InferenceError {
+}
+/** Unauthorized error. */
+export class UnauthorizedError extends InferenceError {
+}
+/** Permission denied error. */
+export class PermissionDeniedError extends InferenceError {
+}
+/** Insufficient credits error. */
+export class InsufficientCreditsError extends InferenceError {
+}
+/** Not found error. */
+export class NotFoundError extends InferenceError {
+}
+/** Conflict error. */
+export class ConflictError extends InferenceError {
+}
+/** Unprocessable entity error. */
+export class UnprocessableEntityError extends InferenceError {
+}
+/** Request too large error. */
+export class RequestTooLargeError extends InferenceError {
+}
+/** Service unavailable error. */
+export class ServiceUnavailableError extends InferenceError {
+}
+/** Overloaded error. */
+export class OverloadedError extends InferenceError {
+}
+/** Deadline exceeded error. */
+export class DeadlineExceededError extends InferenceError {
+}
+/** Internal server error. */
+export class InternalServerError extends InferenceError {
+}

package/dist-transformer/errors/index.d.ts

@@ -0,0 +1,9 @@
+import { MultiplexErrorMessage } from '../client-session-manager/types.js';
+export { AgenticaError, enrichError } from './base.js';
+export { APIConnectionError, APITimeoutError, BadRequestError, ConflictError, ContentFilteringError, DeadlineExceededError, GenerationError, InferenceError, InsufficientCreditsError, InternalServerError, MaxRoundsError, MaxTokensError, NotFoundError, OverloadedError, PermissionDeniedError, RateLimitError, RequestTooLargeError, ServerError, ServiceUnavailableError, UnauthorizedError, UnprocessableEntityError, UsageError, } from './generation.js';
+export { ThisIsABug } from './bugs.js';
+export { ClientServerOutOfSyncError, ConnectionError, SDKUnsupportedError, WebSocketConnectionError, WebSocketTimeoutError, } from './connection.js';
+export { InvocationError, NotRunningError, TooManyInvocationsError } from './invocation.js';
+export declare const attemptToParseMultiplexError: (errorMsg: MultiplexErrorMessage) => Error;
+export declare const attemptToParseError: (name: string, message: string) => Error;
+//# sourceMappingURL=index.d.ts.map

package/dist-transformer/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAEpD,OAAO,EACH,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,aAAa,EACb,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,WAAW,EACX,uBAAuB,EACvB,iBAAiB,EACjB,wBAAwB,EACxB,UAAU,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC,OAAO,EACH,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,GACxB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAsCzF,eAAO,MAAM,4BAA4B,GAAI,UAAU,qBAAqB,KAAG,KAY9E,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,KAInE,CAAC"}

package/dist-transformer/errors/index.js

@@ -0,0 +1,64 @@
+import { AgenticaError } from './base.js';
+import { ThisIsABug } from './bugs.js';
+import { ClientServerOutOfSyncError, ConnectionError, SDKUnsupportedError, WebSocketConnectionError, WebSocketTimeoutError, } from './connection.js';
+import { ServerError } from './generation.js';
+import { APIConnectionError, APITimeoutError, BadRequestError, ConflictError, ContentFilteringError, DeadlineExceededError, GenerationError, InferenceError, InsufficientCreditsError, InternalServerError, MaxRoundsError, MaxTokensError, NotFoundError, OverloadedError, PermissionDeniedError, RateLimitError, RequestTooLargeError, ServiceUnavailableError, UnauthorizedError, UnprocessableEntityError, UsageError, } from './generation.js';
+import { InvocationError, NotRunningError, TooManyInvocationsError } from './invocation.js';
+export { AgenticaError, enrichError } from './base.js';
+export { APIConnectionError, APITimeoutError, BadRequestError, ConflictError, ContentFilteringError, DeadlineExceededError, GenerationError, InferenceError, InsufficientCreditsError, InternalServerError, MaxRoundsError, MaxTokensError, NotFoundError, OverloadedError, PermissionDeniedError, RateLimitError, RequestTooLargeError, ServerError, ServiceUnavailableError, UnauthorizedError, UnprocessableEntityError, UsageError, } from './generation.js';
+export { ThisIsABug } from './bugs.js';
+export { ClientServerOutOfSyncError, ConnectionError, SDKUnsupportedError, WebSocketConnectionError, WebSocketTimeoutError, } from './connection.js';
+export { InvocationError, NotRunningError, TooManyInvocationsError } from './invocation.js';
+const ERROR_MAP = {
+    // Generation errors
+    APIConnectionError,
+    APITimeoutError,
+    BadRequestError,
+    ConflictError,
+    ContentFilteringError,
+    DeadlineExceededError,
+    GenerationError,
+    InferenceError,
+    InternalServerError,
+    UsageError,
+    MaxTokensError,
+    MaxRoundsError,
+    NotFoundError,
+    OverloadedError,
+    PermissionDeniedError,
+    InsufficientCreditsError,
+    RateLimitError,
+    RequestTooLargeError,
+    ServerError,
+    ServiceUnavailableError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+    // Connection errors
+    ConnectionError,
+    WebSocketConnectionError,
+    WebSocketTimeoutError,
+    SDKUnsupportedError,
+    ClientServerOutOfSyncError,
+    // Invocation errors
+    InvocationError,
+    NotRunningError,
+    TooManyInvocationsError,
+    ThisIsABug,
+};
+export const attemptToParseMultiplexError = (errorMsg) => {
+    const error = attemptToParseError(errorMsg.error_name, errorMsg.error_message ?? 'Unknown error');
+    if (error instanceof AgenticaError) {
+        error.uid = errorMsg.uid ?? undefined;
+        error.iid = errorMsg.iid;
+        error.sessionId = errorMsg.session_id ?? undefined;
+        error.sessionManagerId = errorMsg.session_manager_id ?? undefined;
+        error.errorTimestamp = errorMsg.timestamp;
+    }
+    return error;
+};
+export const attemptToParseError = (name, message) => {
+    const ErrorConstructor = ERROR_MAP[name];
+    if (ErrorConstructor)
+        return new ErrorConstructor(message);
+    return new ServerError(message);
+};

package/dist-transformer/errors/invocation.d.ts

@@ -0,0 +1,8 @@
+import { AgenticaError } from './base.js';
+export declare class InvocationError extends AgenticaError {
+}
+export declare class TooManyInvocationsError extends InvocationError {
+}
+export declare class NotRunningError extends InvocationError {
+}
+//# sourceMappingURL=invocation.d.ts.map

package/dist-transformer/errors/invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.d.ts","sourceRoot":"","sources":["../../src/errors/invocation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,qBAAa,eAAgB,SAAQ,aAAa;CAAG;AAErD,qBAAa,uBAAwB,SAAQ,eAAe;CAAG;AAE/D,qBAAa,eAAgB,SAAQ,eAAe;CAAG"}

package/dist-transformer/errors/invocation.js

@@ -0,0 +1,7 @@
+import { AgenticaError } from './base.js';
+export class InvocationError extends AgenticaError {
+}
+export class TooManyInvocationsError extends InvocationError {
+}
+export class NotRunningError extends InvocationError {
+}

package/dist-transformer/index.d.ts

@@ -0,0 +1,8 @@
+export declare const waitForTracing: Promise<unknown>;
+export { type AgenticConfig, agentic, agenticPro, agenticTransformation } from './agentica/agentic.js';
+export { Agent, spawn, spawnTransformation } from './agentica/agent.js';
+export { Agentica, getGlobalCsm, getUidForIid } from './agentica-client/index.js';
+export { setDefaultLogLevel, setLogLevel } from './logging/index.js';
+export { getTracer, initializeTracing, shutdownTracing } from './otel-config.js';
+export { CustomLogFW, getLoggerProvider, setupOtelLogging } from './otel-logging.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-transformer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,kBAEzB,CAAC;AA0BH,OAAO,EAAE,KAAK,aAAa,EAAE,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACpG,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGzE,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist-transformer/index.js

@@ -0,0 +1,40 @@
+// Initialize OpenTelemetry tracing at import time (like Python does in __init__.py)
+// This ensures TracerProvider is registered before any tracers are created
+let _resolveInitTracing = () => { };
+export const waitForTracing = new Promise((resolve, _) => {
+    _resolveInitTracing = resolve;
+});
+if (typeof process !== 'undefined' && process.versions?.node) {
+    (async () => {
+        const { initializeTracing } = await import('./otel-config.js');
+        const { loggingConfig } = await import('./logging/index.js');
+        try {
+            await initializeTracing('agentica-sdk-typescript');
+            // Enable OTel logging if explicitly requested
+            const otelEnabled = process.env?.OTEL_ENABLED?.toLowerCase() === 'true';
+            if (otelEnabled) {
+                loggingConfig.setOtelLoggingEnabled(true);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to initialize OpenTelemetry:', error);
+        }
+        finally {
+            _resolveInitTracing();
+        }
+    })();
+}
+else {
+    // resolve immediately in when not init-ing.
+    _resolveInitTracing();
+}
+// Agentica function exports
+export { agentic, agenticPro, agenticTransformation } from './agentica/agentic.js';
+export { Agent, spawn, spawnTransformation } from './agentica/agent.js';
+// Agentica client exports
+export { Agentica, getGlobalCsm, getUidForIid } from './agentica-client/index.js';
+// Logging exports
+export { setDefaultLogLevel, setLogLevel } from './logging/index.js';
+// OpenTelemetry exports
+export { getTracer, initializeTracing, shutdownTracing } from './otel-config.js';
+export { CustomLogFW, getLoggerProvider, setupOtelLogging } from './otel-logging.js';

package/dist-transformer/logging/composite-logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * CompositeLogger combines multiple logger implementations.
+ * Similar to Python's HybridNotifier pattern.
+ */
+import type { ScopedLogger, SpanContext } from './types.js';
+/**
+ * CompositeLogger delegates to multiple logger implementations.
+ * This allows combining console logging with OpenTelemetry logging.
+ */
+export declare class CompositeLogger implements ScopedLogger {
+    private loggers;
+    readonly scope: string;
+    constructor(loggers: ScopedLogger[], scope: string);
+    setScope(_scope: string): void;
+    debug(message: string, ...args: any[]): void;
+    debugObject(message: string, obj: any): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: Error, ...args: any[]): void;
+    withScope(childScope: string): ScopedLogger;
+    withDepth(delta: number): ScopedLogger;
+    incDepth(): void;
+    decDepth(): void;
+    setAttribute(key: string, value: string | number | boolean): void;
+    getAttribute(key: string): string | number | boolean | undefined;
+    startSpan(name: string): SpanContext;
+}
+//# sourceMappingURL=composite-logger.d.ts.map

package/dist-transformer/logging/composite-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-logger.d.ts","sourceRoot":"","sources":["../../src/logging/composite-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA6CzD;;;GAGG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAE5C,OAAO,CAAC,OAAO;aACC,KAAK,EAAE,MAAM;gBADrB,OAAO,EAAE,YAAY,EAAE,EACf,KAAK,EAAE,MAAM;IAGjC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI9B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM5C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI;IAM5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3D,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY;IAM3C,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAKtC,QAAQ,IAAI,IAAI;IAMhB,QAAQ,IAAI,IAAI;IAMhB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI;IAMjE,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS;IAWhE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;CAIvC"}

package/dist-transformer/logging/composite-logger.js

@@ -0,0 +1,118 @@
+/**
+ * CompositeLogger combines multiple logger implementations.
+ * Similar to Python's HybridNotifier pattern.
+ */
+/**
+ * Composite span context that delegates to multiple underlying span contexts.
+ */
+class CompositeSpanContext {
+    constructor(spans) {
+        this.spans = spans;
+    }
+    get spanId() {
+        // Return the first valid span ID
+        return this.spans[0]?.spanId || '00000000000000000000000000000000';
+    }
+    get traceId() {
+        // Return the first valid trace ID
+        return this.spans[0]?.traceId || '00000000000000000000000000000000';
+    }
+    setAttribute(key, value) {
+        for (const span of this.spans) {
+            span.setAttribute(key, value);
+        }
+    }
+    recordException(error) {
+        for (const span of this.spans) {
+            span.recordException(error);
+        }
+    }
+    end() {
+        for (const span of this.spans) {
+            span.end();
+        }
+    }
+    executeInContext(fn) {
+        // Use the first span's context (they should all be part of the same trace)
+        if (this.spans[0] && 'executeInContext' in this.spans[0]) {
+            return this.spans[0].executeInContext(fn);
+        }
+        return fn();
+    }
+}
+/**
+ * CompositeLogger delegates to multiple logger implementations.
+ * This allows combining console logging with OpenTelemetry logging.
+ */
+export class CompositeLogger {
+    constructor(loggers, scope) {
+        this.loggers = loggers;
+        this.scope = scope;
+    }
+    setScope(_scope) {
+        throw new Error('Method not implemented.');
+    }
+    debug(message, ...args) {
+        for (const logger of this.loggers) {
+            logger.debug(message, ...args);
+        }
+    }
+    debugObject(message, obj) {
+        for (const logger of this.loggers) {
+            logger.debugObject(message, obj);
+        }
+    }
+    info(message, ...args) {
+        for (const logger of this.loggers) {
+            logger.info(message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        for (const logger of this.loggers) {
+            logger.warn(message, ...args);
+        }
+    }
+    error(message, error, ...args) {
+        for (const logger of this.loggers) {
+            logger.error(message, error, ...args);
+        }
+    }
+    withScope(childScope) {
+        const childLoggers = this.loggers.map((logger) => logger.withScope(childScope));
+        const fullScope = `${this.scope}:${childScope}`;
+        return new CompositeLogger(childLoggers, fullScope);
+    }
+    withDepth(delta) {
+        const newLoggers = this.loggers.map((logger) => logger.withDepth(delta));
+        return new CompositeLogger(newLoggers, this.scope);
+    }
+    incDepth() {
+        for (const logger of this.loggers) {
+            logger.incDepth();
+        }
+    }
+    decDepth() {
+        for (const logger of this.loggers) {
+            logger.decDepth();
+        }
+    }
+    setAttribute(key, value) {
+        for (const logger of this.loggers) {
+            logger.setAttribute(key, value);
+        }
+    }
+    getAttribute(key) {
+        // Return the first non-undefined attribute value
+        for (const logger of this.loggers) {
+            const value = logger.getAttribute(key);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    startSpan(name) {
+        const spans = this.loggers.map((logger) => logger.startSpan(name));
+        return new CompositeSpanContext(spans);
+    }
+}

package/dist-transformer/logging/config.d.ts

@@ -0,0 +1,17 @@
+import type { LogLevel, LoggerConfig } from './types.js';
+export declare class LoggingConfig {
+    private defaultLevel;
+    private scopeLevels;
+    private tracingEnabled;
+    private otelLoggingEnabled;
+    constructor(config?: LoggerConfig);
+    setDefaultLevel(level: LogLevel): void;
+    setScopeLevel(scope: string, level: LogLevel): void;
+    getEffectiveLevel(scope: string): LogLevel;
+    isTracingEnabled(): boolean;
+    isOtelLoggingEnabled(): boolean;
+    setOtelLoggingEnabled(enabled: boolean): void;
+    shouldLog(scope: string, level: LogLevel): boolean;
+}
+export declare const globalConfig: LoggingConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist-transformer/logging/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/logging/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAmCtD,qBAAa,aAAa;IACtB,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,kBAAkB,CAAkB;gBAEhC,MAAM,CAAC,EAAE,YAAY;IAuBjC,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAItC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAInD,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IAY1C,gBAAgB,IAAI,OAAO;IAI3B,oBAAoB,IAAI,OAAO;IAI/B,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI7C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO;CAIrD;AAED,eAAO,MAAM,YAAY,eAAsB,CAAC"}

package/dist-transformer/logging/config.js

@@ -0,0 +1,86 @@
+import { getLogLevel } from '../bundlers/utils.js';
+const DEFAULT_PRIORITY = 'warn';
+const levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+function parseEnvLogLevel() {
+    const envValue = getLogLevel();
+    if (!envValue)
+        return {};
+    const parts = envValue.split(',').map((p) => p.trim());
+    const result = {};
+    for (const part of parts) {
+        if (part.includes(':')) {
+            const lastColonIndex = part.lastIndexOf(':');
+            const scope = part.substring(0, lastColonIndex);
+            const level = part.substring(lastColonIndex + 1);
+            if (!result.scopes)
+                result.scopes = {};
+            result.scopes[scope] = level;
+        }
+        else {
+            result.default = part;
+        }
+    }
+    return result;
+}
+export class LoggingConfig {
+    constructor(config) {
+        this.scopeLevels = new Map();
+        this.tracingEnabled = true;
+        this.otelLoggingEnabled = false;
+        const envConfig = parseEnvLogLevel();
+        this.defaultLevel = config?.defaultLevel ?? envConfig.default ?? DEFAULT_PRIORITY;
+        if (envConfig.scopes) {
+            for (const [scope, level] of Object.entries(envConfig.scopes)) {
+                this.scopeLevels.set(scope, level);
+            }
+        }
+        if (config?.scopeLevels) {
+            for (const [scope, level] of Object.entries(config.scopeLevels)) {
+                this.scopeLevels.set(scope, level);
+            }
+        }
+        if (config?.enableTracing !== undefined) {
+            this.tracingEnabled = config.enableTracing;
+        }
+        if (config?.enableOtelLogging !== undefined) {
+            this.otelLoggingEnabled = config.enableOtelLogging;
+        }
+    }
+    setDefaultLevel(level) {
+        this.defaultLevel = level;
+    }
+    setScopeLevel(scope, level) {
+        this.scopeLevels.set(scope, level);
+    }
+    getEffectiveLevel(scope) {
+        const parts = scope.split(':');
+        for (let i = parts.length; i > 0; i--) {
+            const prefix = parts.slice(0, i).join(':');
+            const level = this.scopeLevels.get(prefix);
+            if (level !== undefined) {
+                return level;
+            }
+        }
+        return this.defaultLevel;
+    }
+    isTracingEnabled() {
+        return this.tracingEnabled;
+    }
+    isOtelLoggingEnabled() {
+        return this.otelLoggingEnabled;
+    }
+    setOtelLoggingEnabled(enabled) {
+        this.otelLoggingEnabled = enabled;
+    }
+    shouldLog(scope, level) {
+        const effectiveLevel = this.getEffectiveLevel(scope);
+        return levelPriority[level] >= levelPriority[effectiveLevel];
+    }
+}
+export const globalConfig = new LoggingConfig();

package/dist-transformer/logging/index.d.ts

@@ -0,0 +1,19 @@
+import type { LogLevel, ScopedLogger } from './types.js';
+export { ConsolaLogger, shortenPath } from './logger.js';
+export { OtelLogger } from './otel-logger.js';
+export { CompositeLogger } from './composite-logger.js';
+export { globalConfig as loggingConfig } from './config.js';
+export type { LogLevel, LoggerConfig, ScopedLogger, SpanContext } from './types.js';
+/**
+ * Create a logger for runtime SDK usage.
+ * Returns CompositeLogger (console + OTel) when OTel is enabled, otherwise ConsolaLogger.
+ */
+export declare function createLogger(scope: string): ScopedLogger;
+/**
+ * Create a console-only logger for build-time usage (e.g., transformer).
+ * NEVER uses OTel, even if enabled. Use this for compile-time tools.
+ */
+export declare function createConsolaLogger(scope: string): ScopedLogger;
+export declare function setLogLevel(scope: string, level: LogLevel): void;
+export declare function setDefaultLogLevel(level: LogLevel): void;
+//# sourceMappingURL=index.d.ts.map

package/dist-transformer/logging/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logging/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAOtD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,YAAY,IAAI,aAAa,EAAE,MAAM,UAAU,CAAC;AACzD,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEjF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAMxD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAE/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAEhE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAExD"}

package/dist-transformer/logging/index.js

@@ -0,0 +1,32 @@
+import { CompositeLogger } from './composite-logger.js';
+import { globalConfig } from './config.js';
+import { ConsolaLogger } from './logger.js';
+import { OtelLogger } from './otel-logger.js';
+export { ConsolaLogger, shortenPath } from './logger.js';
+export { OtelLogger } from './otel-logger.js';
+export { CompositeLogger } from './composite-logger.js';
+export { globalConfig as loggingConfig } from './config.js';
+/**
+ * Create a logger for runtime SDK usage.
+ * Returns CompositeLogger (console + OTel) when OTel is enabled, otherwise ConsolaLogger.
+ */
+export function createLogger(scope) {
+    // If OTel logging is enabled, create a composite logger that emits both console and OTel
+    if (globalConfig.isOtelLoggingEnabled()) {
+        return new CompositeLogger([new ConsolaLogger(scope), new OtelLogger(scope)], scope);
+    }
+    return new ConsolaLogger(scope);
+}
+/**
+ * Create a console-only logger for build-time usage (e.g., transformer).
+ * NEVER uses OTel, even if enabled. Use this for compile-time tools.
+ */
+export function createConsolaLogger(scope) {
+    return new ConsolaLogger(scope);
+}
+export function setLogLevel(scope, level) {
+    globalConfig.setScopeLevel(scope, level);
+}
+export function setDefaultLogLevel(level) {
+    globalConfig.setDefaultLevel(level);
+}