@raindrop-ai/ai-sdk 0.0.19-beta.3 → 0.0.19

package/dist/index-C9H6HnZm.d.mts

@@ -0,0 +1,313 @@
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+declare function getContextManager(): ContextManager;
+declare function currentSpan(): ContextSpan;
+declare function withCurrent<R>(span: ContextSpan, callback: () => R): R;
+
+declare function _resetWarnedMissingUserId(): void;
+
+/**
+ * Options for creating event metadata for call-time context override.
+ */
+type EventMetadataOptions = {
+    /** User identifier (overrides wrap-time userId) */
+    userId?: string;
+    /** Event identifier. If not provided, a unique ID is generated. */
+    eventId?: string;
+    /** Conversation identifier to group related events */
+    convoId?: string;
+    /** Custom event name (overrides wrap-time eventName) */
+    eventName?: string;
+    /** Additional properties to merge with wrap-time properties */
+    properties?: Record<string, unknown>;
+};
+/**
+ * Creates metadata for use with the AI SDK's `experimental_telemetry.metadata` option.
+ * This allows per-call context override when using the wrapped AI SDK.
+ *
+ * Call-time values override wrap-time defaults. Properties are merged (call-time wins on conflicts).
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from "ai";
+ * import { createRaindropAISDK, eventMetadata } from "@raindrop-ai/ai-sdk";
+ *
+ * const raindrop = createRaindropAISDK({ writeKey: "..." });
+ * const { generateText } = raindrop.wrap(ai, {
+ *   context: { userId: "default-user" }  // wrap-time defaults
+ * });
+ *
+ * // Override context per-call
+ * const result = await generateText({
+ *   model: openai("gpt-4"),
+ *   prompt: "Hello!",
+ *   experimental_telemetry: {
+ *     isEnabled: true,
+ *     metadata: eventMetadata({
+ *       convoId: "convo-123",      // add convoId for this call
+ *       eventName: "custom-chat",  // override eventName
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+declare function eventMetadata(options: EventMetadataOptions): Record<string, string>;
+type AISDKChatRequestMessageLike = {
+    id?: string;
+    role?: string;
+    [key: string]: unknown;
+};
+type AISDKChatRequestLike = {
+    id?: string;
+    messageId?: string;
+    trigger?: string;
+    messages?: AISDKChatRequestMessageLike[];
+    [key: string]: unknown;
+};
+/**
+ * Creates stable Raindrop metadata from an AI SDK UI chat request body.
+ *
+ * This is useful for `useChat` applications that require multiple server round-trips
+ * for a single user turn, e.g. when the model triggers client-side tools.
+ *
+ * The helper derives:
+ * - `convoId` from the AI SDK chat request `id`
+ * - `eventId` from the latest user message id in `messages`
+ *
+ * Reusing the same derived `eventId` across tool handoff round-trips allows the
+ * wrapper to patch one logical event instead of creating a new event per POST.
+ */
+declare function eventMetadataFromChatRequest(options: EventMetadataOptions & {
+    request: AISDKChatRequestLike;
+}): Record<string, string>;
+type AgentCallMetadata = ReturnType<typeof eventMetadata>;
+type NormalizeUnknownAgentOptions<T> = T extends {
+    options: infer CallOptions;
+} ? unknown extends CallOptions ? Omit<T, "options"> & {
+    options?: never;
+} : T : T;
+/**
+ * Wraps an agent instance type so `generate()` and `stream()` accept optional
+ * Raindrop call metadata while preserving original return types.
+ */
+type AgentWithMetadata<A> = A extends {
+    generate: (...args: infer GenerateArgs) => infer GenerateReturn;
+    stream: (...args: infer StreamArgs) => infer StreamReturn;
+} ? Omit<A, "generate" | "stream"> & {
+    generate(...args: GenerateArgs extends [infer Options, ...infer Rest] ? [NormalizeUnknownAgentOptions<Options> & {
+        metadata?: AgentCallMetadata;
+    }, ...Rest] : GenerateArgs): GenerateReturn;
+    stream(...args: StreamArgs extends [infer Options, ...infer Rest] ? [NormalizeUnknownAgentOptions<Options> & {
+        metadata?: AgentCallMetadata;
+    }, ...Rest] : StreamArgs): StreamReturn;
+} : A;
+type AgentConstructor = abstract new (...args: any[]) => any;
+type WrapAgentExport<T extends object, K extends PropertyKey> = K extends keyof T ? T[K] extends AgentConstructor ? Omit<T, K> & {
+    [P in K]: new (...args: ConstructorParameters<T[K]>) => AgentWithMetadata<InstanceType<T[K]>>;
+} : T : T;
+/**
+ * Structural wrapper type for AI SDK modules.
+ *
+ * Rewrites AI SDK agent constructor exports so their instance `generate()` and
+ * `stream()` methods accept Raindrop `metadata` while preserving original
+ * return types. Covers the current and deprecated public export names.
+ */
+type WrappedAISDK<T extends object> = WrapAgentExport<WrapAgentExport<WrapAgentExport<T, "ToolLoopAgent">, "Experimental_Agent">, "Agent">;
+/**
+ * Backward-compatible alias for wrapped AI SDK module types.
+ *
+ * This alias intentionally avoids referencing `import("ai")` to satisfy type
+ * resolution without requiring `ai` to be installed.
+ *
+ * Prefer `WrappedAISDK<typeof ai>` in app code when you have an `ai` import.
+ */
+type WrappedAI<T extends object = any> = WrappedAISDK<T>;
+type Attachment = {
+    attachment_id?: string;
+    name?: string;
+    value: string;
+    role: "input" | "output";
+} & ({
+    type: "code";
+    language?: string;
+} | {
+    type: "text" | "image" | "iframe";
+});
+type RaindropAISDKOptions = {
+    /**
+     * API write key. If omitted, telemetry shipping is disabled but `wrap()` is
+     * still available for a consistent integration surface.
+     */
+    writeKey?: string;
+    endpoint?: string;
+    traces?: {
+        enabled?: boolean;
+        flushIntervalMs?: number;
+        maxBatchSize?: number;
+        maxQueueSize?: number;
+        debug?: boolean;
+        debugSpans?: boolean;
+    };
+    events?: {
+        enabled?: boolean;
+        partialFlushMs?: number;
+        debug?: boolean;
+    };
+};
+type RaindropAISDKContext = {
+    userId?: string;
+    eventId?: string;
+    eventName?: string;
+    convoId?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+};
+
+type BuildEventPatch = {
+    eventName?: string;
+    input?: string;
+    output?: string;
+    model?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+};
+/**
+ * Message format passed to `buildEvent`.
+ *
+ * This is intentionally "AI SDK shaped" but loosely typed:
+ * - works across AI SDK versions
+ * - avoids requiring users to import AI SDK types
+ */
+type AISDKMessage = {
+    role: "system" | "user" | "assistant" | "tool" | string;
+    content: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Build or override the Raindrop Event payload from an AI SDK conversation transcript.
+ *
+ * The wrapper calls this twice:
+ * - early with the input messages (system/user)
+ * - at the end with appended response messages (assistant/tool, incl tool-call + tool-result parts)
+ */
+type EventBuilder = (messages: AISDKMessage[]) => void | BuildEventPatch;
+type SelfDiagnosticsSignalDefinition = {
+    /**
+     * Human-readable meaning of this signal.
+     * Used in the injected tool schema and stored in signal properties.
+     */
+    description: string;
+    /**
+     * Optional default sentiment for this signal key.
+     * This can help dashboards classify negative/positive programmatic signals.
+     */
+    sentiment?: "POSITIVE" | "NEGATIVE";
+};
+type SelfDiagnosticsSignalDefinitions = Record<string, SelfDiagnosticsSignalDefinition>;
+type SelfDiagnosticsOptions = {
+    /** Enable automatic injection of the self diagnostics tool. Default: false */
+    enabled?: boolean;
+    /**
+     * Signal keys and descriptions exposed to the model.
+     * Defaults to a built-in set when omitted.
+     */
+    signals?: SelfDiagnosticsSignalDefinitions;
+    /**
+     * Optional extra guidance for when the model should emit self diagnostics.
+     * The SDK still generates a full tool prompt from `signals`.
+     */
+    guidance?: string;
+    /**
+     * Optional tool name override for the injected self diagnostics tool.
+     * Defaults to "__raindrop_report".
+     */
+    toolName?: string;
+};
+type WrapAISDKOptions = {
+    context: RaindropAISDKContext | ((info: {
+        operation: string;
+        args: unknown;
+    }) => RaindropAISDKContext);
+    buildEvent?: EventBuilder;
+    autoAttachment?: boolean;
+    selfDiagnostics?: SelfDiagnosticsOptions;
+    send?: {
+        events?: boolean;
+        traces?: boolean;
+    };
+};
+type EventPatch = {
+    eventName?: string;
+    userId?: string;
+    convoId?: string;
+    input?: string;
+    output?: string;
+    model?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+    isPending?: boolean;
+    timestamp?: string;
+};
+type RaindropAISDKClient = {
+    wrap<T extends object>(aiSDK: T, options?: WrapAISDKOptions): WrappedAISDK<T>;
+    events: {
+        patch(eventId: string, patch: EventPatch): Promise<void>;
+        addAttachments(eventId: string, attachments: Attachment[]): Promise<void>;
+        setProperties(eventId: string, properties: Record<string, unknown>): Promise<void>;
+        finish(eventId: string, patch: {
+            output?: string;
+            model?: string;
+            properties?: Record<string, unknown>;
+        }): Promise<void>;
+    };
+    users: {
+        identify(users: IdentifyInput | IdentifyInput[]): Promise<void>;
+    };
+    signals: {
+        track(signal: {
+            eventId: string;
+            name: "thumbs_up" | "thumbs_down" | string;
+            type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+            sentiment?: "POSITIVE" | "NEGATIVE";
+            timestamp?: string;
+            properties?: Record<string, unknown>;
+            attachmentId?: string;
+            comment?: string;
+            after?: string;
+        }): Promise<void>;
+    };
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+};
+declare function createRaindropAISDK(opts: RaindropAISDKOptions): RaindropAISDKClient;
+
+export { type AISDKChatRequestLike as A, type BuildEventPatch as B, ContextManager as C, type EventBuilder as E, type IdentifyInput as I, type RaindropAISDKClient as R, type SelfDiagnosticsOptions as S, type WrapAISDKOptions as W, _resetWarnedMissingUserId as _, type AISDKChatRequestMessageLike as a, type AISDKMessage as b, type AgentCallMetadata as c, type AgentWithMetadata as d, type Attachment as e, type ContextSpan as f, type EventMetadataOptions as g, type RaindropAISDKContext as h, type RaindropAISDKOptions as i, type SelfDiagnosticsSignalDefinition as j, type SelfDiagnosticsSignalDefinitions as k, type WrappedAI as l, type WrappedAISDK as m, createRaindropAISDK as n, currentSpan as o, eventMetadata as p, eventMetadataFromChatRequest as q, getContextManager as r, withCurrent as w };

package/dist/index-C9H6HnZm.d.ts

@@ -0,0 +1,313 @@
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+declare function getContextManager(): ContextManager;
+declare function currentSpan(): ContextSpan;
+declare function withCurrent<R>(span: ContextSpan, callback: () => R): R;
+
+declare function _resetWarnedMissingUserId(): void;
+
+/**
+ * Options for creating event metadata for call-time context override.
+ */
+type EventMetadataOptions = {
+    /** User identifier (overrides wrap-time userId) */
+    userId?: string;
+    /** Event identifier. If not provided, a unique ID is generated. */
+    eventId?: string;
+    /** Conversation identifier to group related events */
+    convoId?: string;
+    /** Custom event name (overrides wrap-time eventName) */
+    eventName?: string;
+    /** Additional properties to merge with wrap-time properties */
+    properties?: Record<string, unknown>;
+};
+/**
+ * Creates metadata for use with the AI SDK's `experimental_telemetry.metadata` option.
+ * This allows per-call context override when using the wrapped AI SDK.
+ *
+ * Call-time values override wrap-time defaults. Properties are merged (call-time wins on conflicts).
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from "ai";
+ * import { createRaindropAISDK, eventMetadata } from "@raindrop-ai/ai-sdk";
+ *
+ * const raindrop = createRaindropAISDK({ writeKey: "..." });
+ * const { generateText } = raindrop.wrap(ai, {
+ *   context: { userId: "default-user" }  // wrap-time defaults
+ * });
+ *
+ * // Override context per-call
+ * const result = await generateText({
+ *   model: openai("gpt-4"),
+ *   prompt: "Hello!",
+ *   experimental_telemetry: {
+ *     isEnabled: true,
+ *     metadata: eventMetadata({
+ *       convoId: "convo-123",      // add convoId for this call
+ *       eventName: "custom-chat",  // override eventName
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+declare function eventMetadata(options: EventMetadataOptions): Record<string, string>;
+type AISDKChatRequestMessageLike = {
+    id?: string;
+    role?: string;
+    [key: string]: unknown;
+};
+type AISDKChatRequestLike = {
+    id?: string;
+    messageId?: string;
+    trigger?: string;
+    messages?: AISDKChatRequestMessageLike[];
+    [key: string]: unknown;
+};
+/**
+ * Creates stable Raindrop metadata from an AI SDK UI chat request body.
+ *
+ * This is useful for `useChat` applications that require multiple server round-trips
+ * for a single user turn, e.g. when the model triggers client-side tools.
+ *
+ * The helper derives:
+ * - `convoId` from the AI SDK chat request `id`
+ * - `eventId` from the latest user message id in `messages`
+ *
+ * Reusing the same derived `eventId` across tool handoff round-trips allows the
+ * wrapper to patch one logical event instead of creating a new event per POST.
+ */
+declare function eventMetadataFromChatRequest(options: EventMetadataOptions & {
+    request: AISDKChatRequestLike;
+}): Record<string, string>;
+type AgentCallMetadata = ReturnType<typeof eventMetadata>;
+type NormalizeUnknownAgentOptions<T> = T extends {
+    options: infer CallOptions;
+} ? unknown extends CallOptions ? Omit<T, "options"> & {
+    options?: never;
+} : T : T;
+/**
+ * Wraps an agent instance type so `generate()` and `stream()` accept optional
+ * Raindrop call metadata while preserving original return types.
+ */
+type AgentWithMetadata<A> = A extends {
+    generate: (...args: infer GenerateArgs) => infer GenerateReturn;
+    stream: (...args: infer StreamArgs) => infer StreamReturn;
+} ? Omit<A, "generate" | "stream"> & {
+    generate(...args: GenerateArgs extends [infer Options, ...infer Rest] ? [NormalizeUnknownAgentOptions<Options> & {
+        metadata?: AgentCallMetadata;
+    }, ...Rest] : GenerateArgs): GenerateReturn;
+    stream(...args: StreamArgs extends [infer Options, ...infer Rest] ? [NormalizeUnknownAgentOptions<Options> & {
+        metadata?: AgentCallMetadata;
+    }, ...Rest] : StreamArgs): StreamReturn;
+} : A;
+type AgentConstructor = abstract new (...args: any[]) => any;
+type WrapAgentExport<T extends object, K extends PropertyKey> = K extends keyof T ? T[K] extends AgentConstructor ? Omit<T, K> & {
+    [P in K]: new (...args: ConstructorParameters<T[K]>) => AgentWithMetadata<InstanceType<T[K]>>;
+} : T : T;
+/**
+ * Structural wrapper type for AI SDK modules.
+ *
+ * Rewrites AI SDK agent constructor exports so their instance `generate()` and
+ * `stream()` methods accept Raindrop `metadata` while preserving original
+ * return types. Covers the current and deprecated public export names.
+ */
+type WrappedAISDK<T extends object> = WrapAgentExport<WrapAgentExport<WrapAgentExport<T, "ToolLoopAgent">, "Experimental_Agent">, "Agent">;
+/**
+ * Backward-compatible alias for wrapped AI SDK module types.
+ *
+ * This alias intentionally avoids referencing `import("ai")` to satisfy type
+ * resolution without requiring `ai` to be installed.
+ *
+ * Prefer `WrappedAISDK<typeof ai>` in app code when you have an `ai` import.
+ */
+type WrappedAI<T extends object = any> = WrappedAISDK<T>;
+type Attachment = {
+    attachment_id?: string;
+    name?: string;
+    value: string;
+    role: "input" | "output";
+} & ({
+    type: "code";
+    language?: string;
+} | {
+    type: "text" | "image" | "iframe";
+});
+type RaindropAISDKOptions = {
+    /**
+     * API write key. If omitted, telemetry shipping is disabled but `wrap()` is
+     * still available for a consistent integration surface.
+     */
+    writeKey?: string;
+    endpoint?: string;
+    traces?: {
+        enabled?: boolean;
+        flushIntervalMs?: number;
+        maxBatchSize?: number;
+        maxQueueSize?: number;
+        debug?: boolean;
+        debugSpans?: boolean;
+    };
+    events?: {
+        enabled?: boolean;
+        partialFlushMs?: number;
+        debug?: boolean;
+    };
+};
+type RaindropAISDKContext = {
+    userId?: string;
+    eventId?: string;
+    eventName?: string;
+    convoId?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+};
+
+type BuildEventPatch = {
+    eventName?: string;
+    input?: string;
+    output?: string;
+    model?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+};
+/**
+ * Message format passed to `buildEvent`.
+ *
+ * This is intentionally "AI SDK shaped" but loosely typed:
+ * - works across AI SDK versions
+ * - avoids requiring users to import AI SDK types
+ */
+type AISDKMessage = {
+    role: "system" | "user" | "assistant" | "tool" | string;
+    content: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Build or override the Raindrop Event payload from an AI SDK conversation transcript.
+ *
+ * The wrapper calls this twice:
+ * - early with the input messages (system/user)
+ * - at the end with appended response messages (assistant/tool, incl tool-call + tool-result parts)
+ */
+type EventBuilder = (messages: AISDKMessage[]) => void | BuildEventPatch;
+type SelfDiagnosticsSignalDefinition = {
+    /**
+     * Human-readable meaning of this signal.
+     * Used in the injected tool schema and stored in signal properties.
+     */
+    description: string;
+    /**
+     * Optional default sentiment for this signal key.
+     * This can help dashboards classify negative/positive programmatic signals.
+     */
+    sentiment?: "POSITIVE" | "NEGATIVE";
+};
+type SelfDiagnosticsSignalDefinitions = Record<string, SelfDiagnosticsSignalDefinition>;
+type SelfDiagnosticsOptions = {
+    /** Enable automatic injection of the self diagnostics tool. Default: false */
+    enabled?: boolean;
+    /**
+     * Signal keys and descriptions exposed to the model.
+     * Defaults to a built-in set when omitted.
+     */
+    signals?: SelfDiagnosticsSignalDefinitions;
+    /**
+     * Optional extra guidance for when the model should emit self diagnostics.
+     * The SDK still generates a full tool prompt from `signals`.
+     */
+    guidance?: string;
+    /**
+     * Optional tool name override for the injected self diagnostics tool.
+     * Defaults to "__raindrop_report".
+     */
+    toolName?: string;
+};
+type WrapAISDKOptions = {
+    context: RaindropAISDKContext | ((info: {
+        operation: string;
+        args: unknown;
+    }) => RaindropAISDKContext);
+    buildEvent?: EventBuilder;
+    autoAttachment?: boolean;
+    selfDiagnostics?: SelfDiagnosticsOptions;
+    send?: {
+        events?: boolean;
+        traces?: boolean;
+    };
+};
+type EventPatch = {
+    eventName?: string;
+    userId?: string;
+    convoId?: string;
+    input?: string;
+    output?: string;
+    model?: string;
+    properties?: Record<string, unknown>;
+    attachments?: Attachment[];
+    isPending?: boolean;
+    timestamp?: string;
+};
+type RaindropAISDKClient = {
+    wrap<T extends object>(aiSDK: T, options?: WrapAISDKOptions): WrappedAISDK<T>;
+    events: {
+        patch(eventId: string, patch: EventPatch): Promise<void>;
+        addAttachments(eventId: string, attachments: Attachment[]): Promise<void>;
+        setProperties(eventId: string, properties: Record<string, unknown>): Promise<void>;
+        finish(eventId: string, patch: {
+            output?: string;
+            model?: string;
+            properties?: Record<string, unknown>;
+        }): Promise<void>;
+    };
+    users: {
+        identify(users: IdentifyInput | IdentifyInput[]): Promise<void>;
+    };
+    signals: {
+        track(signal: {
+            eventId: string;
+            name: "thumbs_up" | "thumbs_down" | string;
+            type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+            sentiment?: "POSITIVE" | "NEGATIVE";
+            timestamp?: string;
+            properties?: Record<string, unknown>;
+            attachmentId?: string;
+            comment?: string;
+            after?: string;
+        }): Promise<void>;
+    };
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+};
+declare function createRaindropAISDK(opts: RaindropAISDKOptions): RaindropAISDKClient;
+
+export { type AISDKChatRequestLike as A, type BuildEventPatch as B, ContextManager as C, type EventBuilder as E, type IdentifyInput as I, type RaindropAISDKClient as R, type SelfDiagnosticsOptions as S, type WrapAISDKOptions as W, _resetWarnedMissingUserId as _, type AISDKChatRequestMessageLike as a, type AISDKMessage as b, type AgentCallMetadata as c, type AgentWithMetadata as d, type Attachment as e, type ContextSpan as f, type EventMetadataOptions as g, type RaindropAISDKContext as h, type RaindropAISDKOptions as i, type SelfDiagnosticsSignalDefinition as j, type SelfDiagnosticsSignalDefinitions as k, type WrappedAI as l, type WrappedAISDK as m, createRaindropAISDK as n, currentSpan as o, eventMetadata as p, eventMetadataFromChatRequest as q, getContextManager as r, withCurrent as w };