@opencoredev/social-sdk 0.1.0

package/dist/platforms/x-engagement.js

@@ -0,0 +1,47 @@
+import { SocialError } from "../core/errors.js";
+import { managedHttp } from "../cloud/common.js";
+async function mutate(action, tweetId, account, options, context) {
+    if (account.kind !== "connected-account" ||
+        account.version !== 1 ||
+        account.backend !== context.backendInstance ||
+        account.platform !== "x" ||
+        account.accountId !== options.userId)
+        throw new SocialError({
+            code: "unauthorized",
+            operation: `x.${action}`,
+            message: "Account reference does not belong to this X authorization and backend.",
+        });
+    if (!/^\d+$/.test(tweetId))
+        throw new SocialError({
+            code: "invalid_input",
+            operation: `x.${action}`,
+            message: "Provide a native numeric X post ID.",
+        });
+    const request = managedHttp("https://api.x.com", {
+        apiKey: options.accessToken,
+        ...(options.fetch ? { fetch: options.fetch } : {}),
+    });
+    const result = await request(`/2/users/${encodeURIComponent(options.userId)}/likes${action === "unlike" ? `/${tweetId}` : ""}`, context, action === "like" ? { tweet_id: tweetId } : undefined, {}, action === "like" ? "POST" : "DELETE");
+    const data = result && typeof result === "object" && "data" in result ? result.data : undefined;
+    if (!data ||
+        typeof data !== "object" ||
+        !("liked" in data) ||
+        typeof data.liked !== "boolean" ||
+        data.liked !== (action === "like"))
+        throw new SocialError({
+            code: "ambiguous_outcome",
+            operation: `x.${action}`,
+            message: "X did not confirm the requested reaction state. Reconcile before retrying.",
+            retryDisposition: { kind: "reconcile-first" },
+        });
+    return { liked: data.liked, tweetId, userId: options.userId };
+}
+/** Requires like.write, tweet.read, users.read and the app's current API access. Never retries writes. */
+export function xLike(tweetId, account, options, context) {
+    return mutate("like", tweetId, account, options, context);
+}
+/** Deletes only the authenticated user's like; it does not delete the target post. */
+export function xUnlike(tweetId, account, options, context) {
+    return mutate("unlike", tweetId, account, options, context);
+}
+//# sourceMappingURL=x-engagement.js.map

package/dist/platforms/x-engagement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-engagement.js","sourceRoot":"","sources":["../../src/platforms/x-engagement.ts"],"names":[],"mappings":"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"}

package/dist/platforms/x.d.ts

@@ -0,0 +1,82 @@
+import type { AdapterOperationContext, ConnectedAccountRef, JsonObject, PlatformPostRef } from "../core/types.js";
+export interface XAuthorization {
+    readonly userId: string;
+    readonly accessToken: string;
+    readonly handle?: string;
+}
+export { xLike, xUnlike, type XEngagementOptions, type XEngagementResult } from "./x-engagement.js";
+export interface XOptions {
+    readonly auth: XAuthorization;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly clock?: () => Date;
+}
+export interface XNative {
+    readonly readPost: (ref: PlatformPostRef, context: AdapterOperationContext) => Promise<JsonObject>;
+    readonly repost: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly postId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly quote: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly text: string;
+        readonly quotedPostId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly deletePost: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly postId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<void>;
+    readonly createPoll: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly text: string;
+        readonly options: readonly string[];
+        readonly durationMinutes: number;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly bookmarks: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly bookmark: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly postId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<void>;
+    readonly removeBookmark: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly postId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<void>;
+    readonly follow: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly userId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly unfollow: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly userId: string;
+        readonly context: AdapterOperationContext;
+    }) => Promise<void>;
+    readonly uploadVideo: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly media: Blob;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly uploadGif: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly media: Blob;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly listDirectMessages: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly context: AdapterOperationContext;
+    }) => Promise<JsonObject>;
+    readonly stream: (input: {
+        readonly account: ConnectedAccountRef;
+        readonly context: AdapterOperationContext;
+    }) => Promise<Response>;
+}
+export declare function x(options: XOptions): import("../core/adapter.js").SocialAdapter<XNative>;
+//# sourceMappingURL=x.d.ts.map

package/dist/platforms/x.d.ts.map

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

package/dist/platforms/x.js

@@ -0,0 +1,511 @@
+import { remainingBudget } from "../transport/budget.js";
+import twitterText from "twitter-text";
+import { defineAdapter } from "../core/adapter.js";
+import { SocialError } from "../core/errors.js";
+import { managedHttp, publicFields } from "../cloud/common.js";
+import { createHttp, HttpError } from "../transport/http.js";
+import { array, object, optionalNumber, optionalString, string } from "../transport/validation.js";
+export { xLike, xUnlike } from "./x-engagement.js";
+export function x(options) {
+    const request = managedHttp("https://api.x.com", {
+        apiKey: options.auth.accessToken,
+        ...(options.fetch ? { fetch: options.fetch } : {}),
+    });
+    const http = createHttp(options.fetch ? { fetch: options.fetch } : {});
+    const now = () => (options.clock?.() ?? new Date()).toISOString();
+    const authorize = (ref, context) => {
+        if (ref.backend !== context.backendInstance ||
+            ref.platform !== "x" ||
+            ref.accountId !== options.auth.userId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "x",
+                message: "Reference does not match this X user authorization.",
+            });
+    };
+    async function readAccount(context) {
+        const user = object(object(await request("/2/users/me", context))["data"]);
+        if (user["id"] !== options.auth.userId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "accounts.read",
+                message: "The authenticated X user differs from the configured account.",
+            });
+        return {
+            ref: {
+                kind: "connected-account",
+                version: 1,
+                backend: context.backendInstance,
+                platform: "x",
+                accountId: options.auth.userId,
+            },
+            displayName: string(user["name"]),
+            ...(typeof user["username"] === "string" ? { handle: user["username"] } : {}),
+            status: "connected",
+        };
+    }
+    async function readPost(ref, context) {
+        authorize(ref, context);
+        const result = object(object(await request(`/2/tweets/${encodeURIComponent(ref.postId)}`, context, undefined, {
+            "tweet.fields": "author_id,public_metrics,created_at,conversation_id,referenced_tweets",
+        }))["data"]);
+        if (result["id"] !== ref.postId || result["author_id"] !== ref.accountId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "posts.read",
+                message: "X post identity or author does not match the declared reference.",
+            });
+        return result;
+    }
+    async function listPosts(account, input, context) {
+        authorize(account, context);
+        if (input.limit !== undefined &&
+            (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "posts.list",
+                message: "X feed limit must be an integer from 1 through 100.",
+            });
+        const result = object(await request(`/2/users/${encodeURIComponent(account.accountId)}/tweets`, context, undefined, {
+            "tweet.fields": "id,text,author_id,created_at,conversation_id",
+            ...(input.cursor === undefined ? {} : { pagination_token: input.cursor }),
+            ...(input.limit === undefined ? {} : { max_results: String(input.limit) }),
+        }));
+        const items = array(result["data"]).map((entry) => {
+            const row = object(entry);
+            const authorId = optionalString(row["author_id"]);
+            if (authorId !== account.accountId)
+                throw new SocialError({
+                    code: "unauthorized",
+                    operation: "posts.list",
+                    message: "X returned a post owned by a different account.",
+                });
+            return publicFields(row, ["id", "text", "author_id", "created_at", "conversation_id"]);
+        });
+        const meta = result["meta"] === undefined ? {} : object(result["meta"]);
+        const nextCursor = optionalString(meta["next_token"]);
+        return {
+            items,
+            ...(nextCursor === undefined ? {} : { nextCursor }),
+        };
+    }
+    async function getAccountMetrics(account, context) {
+        authorize(account, context);
+        const result = object(await request(`/2/users/${encodeURIComponent(account.accountId)}`, context, undefined, {
+            "user.fields": "id,public_metrics",
+        }));
+        const data = object(result["data"]);
+        const id = optionalString(data["id"]);
+        if (id !== account.accountId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "analytics.read",
+                message: "X returned metrics for a different account.",
+            });
+        const counts = data["public_metrics"] === undefined ? {} : object(data["public_metrics"]);
+        const fields = ["followers_count", "following_count", "tweet_count", "listed_count"];
+        return fields.flatMap((name) => {
+            const value = optionalNumber(counts[name]);
+            return value === undefined
+                ? []
+                : [
+                    {
+                        name,
+                        value,
+                        unit: "count",
+                        period: "lifetime",
+                        fetchedAt: now(),
+                        freshness: "unknown",
+                        source: "X API v2",
+                    },
+                ];
+        });
+    }
+    async function validateReplyParent(ref, context) {
+        authorize(ref, context);
+        const parent = object(object(await request(`/2/tweets/${encodeURIComponent(ref.commentId)}`, context, undefined, {
+            "tweet.fields": "conversation_id",
+        }))["data"]);
+        if (parent["id"] !== ref.commentId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "comments.write",
+                message: "X did not return the declared reply parent.",
+            });
+        if (ref.postId !== ref.commentId) {
+            const root = object(object(await request(`/2/tweets/${encodeURIComponent(ref.postId)}`, context, undefined, {
+                "tweet.fields": "conversation_id",
+            }))["data"]);
+            if (root["id"] !== ref.postId ||
+                (typeof parent["conversation_id"] === "string" &&
+                    parent["conversation_id"] !== root["conversation_id"]))
+                throw new SocialError({
+                    code: "unauthorized",
+                    operation: "comments.write",
+                    message: "Reply parent does not belong to the declared X conversation.",
+                });
+        }
+    }
+    async function uploadImage(media, context) {
+        if (media.source.kind !== "blob" ||
+            media.kind !== "image" ||
+            media.source.blob.size > 5 * 1024 * 1024)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "This X slice uploads image Blobs up to 5 MiB.",
+            });
+        const body = new FormData();
+        body.set("media", media.source.blob, media.filename ?? "image");
+        body.set("media_category", "tweet_image");
+        let result;
+        try {
+            result = await http({
+                url: new URL("https://api.x.com/2/media/upload"),
+                method: "POST",
+                headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                body,
+                timeoutMs: remainingBudget(context),
+                ...(context.signal ? { signal: context.signal } : {}),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            throw new SocialError({
+                code: "media_error",
+                operation: "media.upload",
+                message: error.message,
+                upstreamStatus: error.status,
+                retryDisposition: { kind: "never" },
+            });
+        }
+        const data = object(object(result)["data"]);
+        if (data["processing_info"] && object(data["processing_info"])["state"] !== "succeeded")
+            throw new SocialError({
+                code: "media_error",
+                operation: "media.upload",
+                message: "X media processing is not complete. No post was created.",
+            });
+        return string(data["id"]);
+    }
+    async function createPost(account, text, context, extra = {}, targetIndex = 0) {
+        authorize(account, context);
+        const result = object(await request("/2/tweets", context, { text, ...extra }));
+        const data = result["data"] ? object(result["data"]) : {};
+        const id = optionalString(data["id"]);
+        const base = { account, targetIndex, observedAt: now() };
+        if (!id)
+            return {
+                ...base,
+                state: "unknown",
+                reason: "unmapped-state",
+                diagnostic: "X create response lacks a native ID. Reconcile before retrying.",
+            };
+        return {
+            ...base,
+            state: "published",
+            post: {
+                kind: "platform-post",
+                version: 1,
+                backend: account.backend,
+                platform: "x",
+                accountId: account.accountId,
+                postId: id,
+            },
+        };
+    }
+    return defineAdapter({
+        id: "x",
+        capabilities: {
+            schemaVersion: 1,
+            backend: "x",
+            apiRevision: "X API v2 / OpenAPI 2.168",
+            runtime: ["node22", "node24", "bun"],
+            capabilities: [
+                {
+                    platform: "x",
+                    operation: "posts.publish",
+                    availability: "available",
+                    formats: ["text", "image", "video"],
+                    requiredScopes: ["tweet.read", "tweet.write", "users.read", "media.write"],
+                    notes: "User-context OAuth2 token; current X API access/billing required. Up to four static JPEG/PNG image Blobs, each at most 5 MiB. Video/GIF processing is outside this slice.",
+                },
+                ...[
+                    "accounts.read",
+                    "posts.list",
+                    "posts.read",
+                    "analytics.read",
+                    "comments.write",
+                    "posts.repost",
+                    "posts.quote",
+                    "posts.delete",
+                    "polls.create",
+                    "bookmarks.read",
+                    "bookmarks.write",
+                    "follows.write",
+                ].map((operation) => ({
+                    platform: "x",
+                    operation,
+                    availability: "available",
+                })),
+                {
+                    platform: "x",
+                    operation: "media.video",
+                    availability: "available",
+                    formats: ["video"],
+                },
+                { platform: "x", operation: "media.gif", availability: "available" },
+                {
+                    platform: "x",
+                    operation: "messages.read",
+                    availability: "permission-required",
+                    requiredScopes: ["dm.read"],
+                },
+                {
+                    platform: "x",
+                    operation: "streams.read",
+                    availability: "approval-dependent",
+                    notes: "Filtered stream access depends on the X API tier.",
+                },
+            ],
+        },
+        accounts: {
+            async list(_input, context) {
+                return { items: [await readAccount(context)] };
+            },
+            async get(ref, context) {
+                authorize(ref, context);
+                return readAccount(context);
+            },
+        },
+        posts: {
+            list: listPosts,
+            prepareTarget(target) {
+                const issues = [];
+                const fail = (code, message) => issues.push({ code, message, severity: "error", targetIndex: target.targetIndex });
+                if (target.account.platform !== "x" || target.account.accountId !== options.auth.userId)
+                    fail("x.account", "Select the configured X user.");
+                const text = target.content.text ?? "";
+                if (text && !twitterText.parseTweet(text).valid)
+                    fail("x.text", "Text exceeds X's weighted 280-character limit or contains invalid characters.");
+                if (target.schedule || target.content.link)
+                    fail("x.operation", "Scheduling needs an application runner; place URLs explicitly in text.");
+                if (target.replyTo &&
+                    (target.replyTo.platform !== "x" ||
+                        target.replyTo.backend !== target.account.backend ||
+                        target.replyTo.accountId !== target.account.accountId ||
+                        target.replyTo.kind !== "platform-post"))
+                    fail("x.reply", "Use a platform-post reply reference authorized for this account and backend.");
+                const settings = target.options === undefined ? {} : object(target.options);
+                if (Object.keys(settings).some((key) => key !== "replySettings") ||
+                    (settings["replySettings"] !== undefined &&
+                        !["everyone", "following", "mentionedUsers"].includes(String(settings["replySettings"]))))
+                    fail("x.options", "Provide only a supported replySettings value.");
+                const media = target.content.media ?? [];
+                if (media.length > 4)
+                    fail("x.media_count", "Attach up to four images.");
+                for (const item of media) {
+                    if (item.kind !== "image" ||
+                        item.source.kind !== "blob" ||
+                        !["image/jpeg", "image/png"].includes(item.mimeType ?? ""))
+                        fail("x.image", "This slice requires a JPEG or PNG image Blob.");
+                    else if (item.source.blob.size > 5 * 1024 * 1024)
+                        fail("x.image_size", "Image exceeds the 5 MiB limit.");
+                    if (item.altText !== undefined)
+                        fail("x.alt_text", "This slice has no verified media metadata mapping. Use a backend that supports alt text.");
+                }
+                return issues;
+            },
+            async publishTarget(target, context) {
+                authorize(target.account, context);
+                const ids = [];
+                for (const media of target.content.media ?? [])
+                    ids.push(await uploadImage(media, context));
+                const settings = target.options === undefined ? {} : object(target.options);
+                return createPost(target.account, target.content.text ?? "", context, {
+                    ...(ids.length ? { media: { media_ids: ids } } : {}),
+                    ...(target.replyTo ? { reply: { in_reply_to_tweet_id: target.replyTo.postId } } : {}),
+                    ...(settings["replySettings"] && settings["replySettings"] !== "everyone"
+                        ? { reply_settings: string(settings["replySettings"]) }
+                        : {}),
+                }, target.targetIndex);
+            },
+            async get(ref, context) {
+                return publicFields(await readPost(ref, context), [
+                    "id",
+                    "text",
+                    "author_id",
+                    "created_at",
+                    "conversation_id",
+                ]);
+            },
+        },
+        comments: {
+            async list() {
+                throw new SocialError({
+                    code: "unsupported_capability",
+                    operation: "comments.read",
+                    message: "X reply search is not implemented in this slice.",
+                });
+            },
+            async reply(ref, content, context) {
+                await validateReplyParent(ref, context);
+                if (!twitterText.parseTweet(content.text).valid)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "comments.write",
+                        message: "Reply exceeds X's weighted text limits.",
+                    });
+                const result = await createPost({ ...ref, kind: "connected-account" }, content.text, context, { reply: { in_reply_to_tweet_id: ref.commentId } });
+                if (result.state !== "published")
+                    throw new SocialError({
+                        code: "ambiguous_outcome",
+                        operation: "comments.write",
+                        message: "X reply lacks a confirmed native ID. Reconcile before retrying.",
+                        retryDisposition: { kind: "reconcile-first" },
+                    });
+                return { ...ref, commentId: result.post.postId };
+            },
+        },
+        analytics: {
+            getAccountMetrics,
+            async getPostMetrics(ref, context) {
+                const row = await readPost(ref, context);
+                const counts = row["public_metrics"] ? object(row["public_metrics"]) : {};
+                return [
+                    ["likes", "like_count"],
+                    ["reposts", "retweet_count"],
+                    ["replies", "reply_count"],
+                    ["quotes", "quote_count"],
+                ].flatMap(([name, key]) => {
+                    const value = key ? optionalNumber(counts[key]) : undefined;
+                    return value === undefined || !name
+                        ? []
+                        : [
+                            {
+                                name,
+                                value,
+                                unit: "count",
+                                period: "lifetime",
+                                fetchedAt: now(),
+                                freshness: "unknown",
+                                source: "X API v2",
+                            },
+                        ];
+                });
+            },
+        },
+        native: {
+            readPost,
+            async repost({ account, postId, context }) {
+                authorize(account, context);
+                return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/retweets`, context, {
+                    tweet_id: postId,
+                }));
+            },
+            async quote({ account, text, quotedPostId, context }) {
+                authorize(account, context);
+                return object(await request("/2/tweets", context, { text, quote_tweet_id: quotedPostId }));
+            },
+            async deletePost({ account, postId, context }) {
+                authorize(account, context);
+                await request(`/2/tweets/${encodeURIComponent(postId)}`, context, undefined, {}, "DELETE");
+            },
+            async createPoll({ account, text, options: pollOptions, durationMinutes, context }) {
+                authorize(account, context);
+                if (pollOptions.length < 2 ||
+                    pollOptions.length > 4 ||
+                    durationMinutes < 5 ||
+                    durationMinutes > 10080)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "x.polls.create",
+                        message: "X polls require 2-4 options and a duration from 5 minutes to 7 days.",
+                    });
+                return object(await request("/2/tweets", context, {
+                    text,
+                    poll: { options: [...pollOptions], duration_minutes: durationMinutes },
+                }));
+            },
+            async bookmarks({ account, context }) {
+                authorize(account, context);
+                return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/bookmarks`, context));
+            },
+            async bookmark({ account, postId, context }) {
+                authorize(account, context);
+                await request(`/2/users/${encodeURIComponent(account.accountId)}/bookmarks`, context, {
+                    tweet_id: postId,
+                });
+            },
+            async removeBookmark({ account, postId, context }) {
+                authorize(account, context);
+                await request(`/2/users/${encodeURIComponent(account.accountId)}/bookmarks/${encodeURIComponent(postId)}`, context, undefined, {}, "DELETE");
+            },
+            async follow({ account, userId, context }) {
+                authorize(account, context);
+                return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/following`, context, {
+                    target_user_id: userId,
+                }));
+            },
+            async unfollow({ account, userId, context }) {
+                authorize(account, context);
+                await request(`/2/users/${encodeURIComponent(account.accountId)}/following/${encodeURIComponent(userId)}`, context, undefined, {}, "DELETE");
+            },
+            async uploadVideo({ account, media, context }) {
+                authorize(account, context);
+                if (!media.type.startsWith("video/") || media.size > 512 * 1024 * 1024)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "x.media.video",
+                        message: "Provide a video Blob no larger than 512 MiB.",
+                    });
+                const body = new FormData();
+                body.set("media", media, "video");
+                body.set("media_category", "tweet_video");
+                return object(await http({
+                    url: new URL("https://api.x.com/2/media/upload"),
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                    body,
+                    timeoutMs: remainingBudget(context),
+                    ...(context.signal ? { signal: context.signal } : {}),
+                }));
+            },
+            async uploadGif({ account, media, context }) {
+                authorize(account, context);
+                if (media.type !== "image/gif")
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "x.media.gif",
+                        message: "GIF uploads require image/gif media.",
+                    });
+                const body = new FormData();
+                body.set("media", media, "image.gif");
+                body.set("media_category", "tweet_gif");
+                return object(await http({
+                    url: new URL("https://api.x.com/2/media/upload"),
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                    body,
+                    timeoutMs: remainingBudget(context),
+                    ...(context.signal ? { signal: context.signal } : {}),
+                }));
+            },
+            async listDirectMessages({ account, context }) {
+                authorize(account, context);
+                return object(await request("/2/dm_conversations", context));
+            },
+            async stream({ account, context }) {
+                authorize(account, context);
+                return (await http({
+                    url: new URL("https://api.x.com/2/tweets/search/stream"),
+                    headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                    timeoutMs: remainingBudget(context),
+                    ...(context.signal ? { signal: context.signal } : {}),
+                }));
+            },
+        },
+    });
+}
+//# sourceMappingURL=x.js.map