@codybrom/denim 1.3.6 → 2.0.1

package/package.json

@@ -1,23 +1,23 @@
 {
-  "name": "@codybrom/denim",
-  "version": "1.3.6",
-  "description": "Typescript/Deno module to simplify posting to Threads",
-  "main": "mod.ts",
-  "directories": {
-    "example": "examples"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codybrom/denim.git"
-  },
-  "keywords": [
-    "threads",
-    "threads-api"
-  ],
-  "author": "Cody Bromley",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/codybrom/denim/issues"
-  },
-  "homepage": "https://github.com/codybrom/denim#readme"
-}
+	"name": "@codybrom/denim",
+	"version": "2.0.1",
+	"description": "A Deno/TypeScript library for the Threads API",
+	"main": "mod.ts",
+	"directories": {
+		"example": "examples"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/codybrom/denim.git"
+	},
+	"keywords": [
+		"threads",
+		"threads-api"
+	],
+	"author": "Cody Bromley",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/codybrom/denim/issues"
+	},
+	"homepage": "https://github.com/codybrom/denim#readme"
+}

package/readme.md

@@ -1,251 +1,215 @@
 # Denim
 
-[![JSR](https://jsr.io/badges/@codybrom/denim)](https://jsr.io/@codybrom/denim) [![JSR Score](https://jsr.io/badges/@codybrom/denim/score)](https://jsr.io/@codybrom/denim)
+[![JSR](https://jsr.io/badges/@codybrom/denim)](https://jsr.io/@codybrom/denim)
+[![JSR Score](https://jsr.io/badges/@codybrom/denim/score)](https://jsr.io/@codybrom/denim)
 
-**Denim** is a Deno module that provides a simple interface for posting single Threads posts using text, images, or videos.
+A Deno/TypeScript wrapper for the
+[Threads API](https://developers.facebook.com/docs/threads). Covers posting,
+retrieval, replies, profiles, insights, search, locations, tokens, and oEmbed.
 
-## Features
+You'll need a Threads app with an access token from
+[Meta's developer portal](https://developers.facebook.com/apps/). See the
+[Threads API docs](https://developers.facebook.com/docs/threads/get-started) for
+setup.
 
-- Create and publish posts on Threads with an easy-use-API
-- Supports text-only, image, video, and carousel posts
-- Add alt text to image and video posts
-- Attach links to text posts
-- Geo-gate content to specific countries
-- Control who can reply to posts
-- Retrieve publishing rate limit information
-- Ready to deploy as an edge function
+```bash
+deno add @codybrom/denim
+```
 
-## Installation
+## Publishing
 
-### Using with Deno
+Threads publishing is two steps: create a container, then publish it.
 
-To add Denim to your Deno project, you can use the following command:
+```typescript
+import {
+	createThreadsContainer,
+	publishThreadsContainer,
+} from "@codybrom/denim";
+
+const containerId = await createThreadsContainer({
+	userId: "YOUR_USER_ID",
+	accessToken: "YOUR_ACCESS_TOKEN",
+	mediaType: "TEXT",
+	text: "Hello from Denim!",
+});
 
-```bash
-deno add @codybrom/denim
+await publishThreadsContainer("YOUR_USER_ID", "YOUR_ACCESS_TOKEN", containerId);
 ```
 
-This will add the latest version of Denim to your project's dependencies.
+`createThreadsContainer(request)` takes a `ThreadsPostRequest` and returns the
+container ID string. The request requires `userId`, `accessToken`, `mediaType`,
+and usually `text`. Optional fields control the post type:
 
-## Usage
+| Field                     | Type       | Purpose                                                                                                       |
+| ------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------- |
+| `imageUrl`                | `string`   | Image URL (for `IMAGE` or `CAROUSEL` items)                                                                   |
+| `videoUrl`                | `string`   | Video URL (for `VIDEO` or `CAROUSEL` items)                                                                   |
+| `altText`                 | `string`   | Alt text for images and videos                                                                                |
+| `linkAttachment`          | `string`   | URL to attach to a `TEXT` post                                                                                |
+| `replyControl`            | `string`   | `"everyone"`, `"accounts_you_follow"`, `"mentioned_only"`, `"parent_post_author_only"`, or `"followers_only"` |
+| `allowlistedCountryCodes` | `string[]` | ISO country codes to restrict post visibility                                                                 |
+| `replyToId`               | `string`   | Post ID to reply to                                                                                           |
+| `quotePostId`             | `string`   | Post ID to quote                                                                                              |
+| `pollAttachment`          | `object`   | `{ option_a, option_b, option_c?, option_d? }`                                                                |
+| `topicTag`                | `string`   | Topic tag for the post                                                                                        |
+| `isGhostPost`             | `boolean`  | Make a ghost post (text only, expires in 24h)                                                                 |
+| `isSpoilerMedia`          | `boolean`  | Hide media behind a spoiler overlay                                                                           |
+| `textEntities`            | `array`    | Text spoiler ranges: `[{ entity_type, offset, length }]`                                                      |
+| `textAttachment`          | `object`   | Long-form text: `{ plaintext, link_attachment_url? }`                                                         |
+| `gifAttachment`           | `object`   | GIF: `{ gif_id, provider }`                                                                                   |
+| `locationId`              | `string`   | Location ID from `searchLocations`                                                                            |
+| `children`                | `string[]` | Carousel item IDs from `createCarouselItem`                                                                   |
+| `autoPublishText`         | `boolean`  | Skip the publish step for text posts                                                                          |
 
-To import straight from JSR:
+`publishThreadsContainer(userId, accessToken, containerId, getPermalink?)`
+publishes a container. Pass `true` for `getPermalink` to get `{ id, permalink }`
+instead of just the ID string.
 
-```typescript
-import { ThreadsPostRequest, createThreadsContainer, publishThreadsContainer } from 'jsr:@codybrom/denim';
-```
+`createCarouselItem(request)` creates individual items for a carousel post.
+Takes the same request shape but `mediaType` must be `"IMAGE"` or `"VIDEO"`.
 
-### Basic Usage
+`repost(mediaId, accessToken)` reposts an existing thread. Returns `{ id }`.
 
-```typescript
-import { createThreadsContainer, publishThreadsContainer, ThreadsPostRequest } from "jsr:@codybrom/denim";
+`deleteThread(mediaId, accessToken)` deletes a thread. Returns
+`{ success: boolean, deleted_id?: string }`.
 
-const request: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "TEXT",
-  text: "Check out Denim on GitHub!",
-  linkAttachment: "https://github.com/codybrom/denim",
-  replyControl: "everyone",
-};
+## Retrieval
 
-// Create a container
-const containerId = await createThreadsContainer(request);
+All retrieval functions accept an optional `fields` string array to request
+specific fields, and an optional `PaginationOptions` object
+(`{ since?, until?, limit?, before?, after? }`).
 
-// Publish the container
-const publishedId = await publishThreadsContainer(request.userId, request.accessToken, containerId);
+`getThreadsList(userId, accessToken, options?, fields?)` returns a user's
+threads as `{ data: ThreadsPost[], paging }`.
 
-console.log(`Post published with ID: ${publishedId}`);
-```
+`getSingleThread(mediaId, accessToken, fields?)` returns a single `ThreadsPost`.
 
-#### Retrieving Publishing Rate Limit
+`getGhostPosts(userId, accessToken, options?, fields?)` returns a user's ghost
+posts.
 
-```typescript
-import { getPublishingLimit } from "jsr:@codybrom/denim";
-
-const userId = "YOUR_USER_ID";
-const accessToken = "YOUR_ACCESS_TOKEN";
-
-try {
-  const rateLimit = await getPublishingLimit(userId, accessToken);
-  console.log("Current usage:", rateLimit.quota_usage);
-  console.log("Total quota:", rateLimit.config.quota_total);
-  console.log("Quota duration (seconds):", rateLimit.config.quota_duration);
-} catch (error) {
-  console.error("Failed to retrieve rate limit information:", error);
-}
-```
+## Profiles
 
-### Posting Different Media Types
+`getProfile(userId, accessToken, fields?)` returns the authenticated user's
+`ThreadsProfile` (username, name, bio, profile picture, verification status).
 
-#### Text-only Post
+`lookupProfile(accessToken, username, fields?)` looks up any public profile by
+username. Returns a `PublicProfile` with follower counts and engagement stats.
+Requires `threads_profile_discovery` permission.
 
-```typescript
-const textRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "TEXT",
-  text: "This is a text-only post on Threads!",
-};
-```
+`getProfilePosts(accessToken, username, options?, fields?)` returns a public
+profile's posts.
 
-#### Text Post with Link Attachment
+## Replies
 
-```typescript
-const textRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "TEXT",
-  text: "This is a post with an attached link on Threads!",
-  linkAttachment: "https://example.com",
-};
-```
+`getReplies(mediaId, accessToken, options?, fields?, reverse?)` returns direct
+replies to a post. Pass `reverse: false` for chronological order (default is
+reverse chronological).
 
-#### Image Post with Alt Text
+`getConversation(mediaId, accessToken, options?, fields?, reverse?)` returns the
+full conversation thread (replies and nested replies). Pass `reverse: false` for
+chronological order.
 
-```typescript
-const imageRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "IMAGE",
-  text: "Check out this image!",
-  imageUrl: "https://example.com/image.jpg",
-  altText: "A beautiful sunset over the ocean",
-};
-```
+`getUserReplies(userId, accessToken, options?, fields?)` returns all replies
+made by a user.
 
-#### Video Post
+`manageReply(replyId, accessToken, hide)` hides or unhides a reply. Pass `true`
+to hide, `false` to unhide.
 
-```typescript
-const videoRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "VIDEO",
-  text: "Watch this video!",
-  videoUrl: "https://example.com/video.mp4",
-};
-```
+## Insights
 
-#### Video Post with Alt Text, Reply Control and Geo-gating* (requires special account permission)
+`getMediaInsights(mediaId, accessToken, metrics)` returns metrics for a post.
+Pass metric names as a string array: `"views"`, `"likes"`, `"replies"`,
+`"reposts"`, `"quotes"`, `"shares"`.
 
 ```typescript
-const videoRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "VIDEO",
-  text: "Watch this video!",
-  videoUrl: "https://example.com/video.mp4",
-  altText: "A tutorial on how to make a chocolate cake",
-  allowlistedCountryCodes: ["US", "GB"],
-  replyControl: "mentioned_only",
-};
+const insights = await getMediaInsights(postId, token, ["views", "likes"]);
+// insights.data[0].values[0].value => 42
 ```
 
-#### Carousel Post
+`getUserInsights(userId, accessToken, metrics, options?)` returns user-level
+metrics. Accepts an options object with `since`/`until` timestamps and
+`breakdown` for demographics.
 
-```typescript
-import { createCarouselItem, createThreadsContainer, publishThreadsContainer, ThreadsPostRequest } from "jsr:@codybrom/denim";
-
-// First, create carousel items
-const item1Id = await createCarouselItem({
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "IMAGE",
-  imageUrl: "https://example.com/image1.jpg",
-  altText: "First image in the carousel",
-});
+## Search & Locations
 
-const item2Id = await createCarouselItem({
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "VIDEO",
-  videoUrl: "https://example.com/video.mp4",
-  altText: "Video in the carousel",
-});
+`searchKeyword(accessToken, options, fields?)` searches posts by keyword or
+topic tag. Options:
+`{ q, search_type?, search_mode?, media_type?, author_username?,
+...pagination }`.
+Requires `threads_keyword_search` permission for searching beyond your own
+posts.
 
-// Then, create the carousel post
-const carouselRequest: ThreadsPostRequest = {
-  userId: "YOUR_USER_ID",
-  accessToken: "YOUR_ACCESS_TOKEN",
-  mediaType: "CAROUSEL",
-  text: "Check out this carousel post!",
-  children: [item1Id, item2Id],
-  replyControl: "everyone",
-};
+`searchLocations(accessToken, options, fields?)` searches for locations by name
+or coordinates. Options: `{ query?, latitude?, longitude? }`. Returns location
+objects with IDs you can pass to `createThreadsContainer` as `locationId`.
 
-const containerId = await createThreadsContainer(carouselRequest);
-const publishedId = await publishThreadsContainer(carouselRequest.userId, carouselRequest.accessToken, containerId);
+`getLocation(locationId, accessToken, fields?)` returns details for a location
+(name, address, city, country, coordinates).
 
-console.log(`Carousel post published with ID: ${publishedId}`);
-```
+## Tokens
 
-## Deploying as an Edge Function
+`exchangeCodeForToken(clientId, clientSecret, code, redirectUri)` exchanges an
+OAuth authorization code for a short-lived access token. Returns
+`{ access_token, user_id }`.
 
-Denim can be easily deployed as an edge function. An example implementation is provided in `examples/edge-function.ts`.
+`getAppAccessToken(clientId, clientSecret)` gets an app-level access token via
+client credentials. Returns `{ access_token, token_type }`.
 
-To deploy:
+`exchangeToken(clientSecret, accessToken)` exchanges a short-lived token for a
+long-lived one (60 days). Returns `{ access_token, token_type, expires_in }`.
 
-1. Copy the `examples/edge-function.ts` file to your project.
-2. Deploy this file to your serverless platform that supports Deno.
-3. Send POST requests to your function's URI with the appropriate JSON body.
+`refreshToken(accessToken)` refreshes a long-lived token before it expires. Same
+return shape.
 
-### Example cURL Commands
+`debugToken(accessToken, inputToken)` returns metadata about a token: app ID,
+scopes, expiry, validity.
 
-```bash
-# Post a text-only Thread
-curl -X POST <YOUR_FUNCTION_URI> \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_AUTH_KEY" \
-  -d '{
-    "userId": "YOUR_USER_ID",
-    "accessToken": "YOUR_ACCESS_TOKEN",
-    "mediaType": "TEXT",
-    "text": "Hello from Denim!"
-  }'
-
-# Post an image Thread
-curl -X POST <YOUR_FUNCTION_URI> \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_AUTH_KEY" \
-  -d '{
-    "userId": "YOUR_USER_ID",
-    "accessToken": "YOUR_ACCESS_TOKEN",
-    "mediaType": "IMAGE",
-    "text": "Check out this image I posted with Denim!",
-    "imageUrl": "https://example.com/image.jpg"
-  }'
-
-# Post a video Thread
-curl -X POST <YOUR_FUNCTION_URI> \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_AUTH_KEY" \
-  -d '{
-    "userId": "YOUR_USER_ID",
-    "accessToken": "YOUR_ACCESS_TOKEN",
-    "mediaType": "VIDEO",
-    "text": "Watch this video I posted with Denim!",
-    "videoUrl": "https://example.com/video.mp4"
-  }'
-```
+## Other
+
+`getPublishingLimit(userId, accessToken, fields?)` returns rate limit info: post
+quota, reply quota, and remaining usage.
 
-Note: Replace with your actual authorization headers if your edge function requires them (or remove them).
+`getMentions(userId, accessToken, options?, fields?)` returns posts that mention
+the authenticated user.
 
-## Security Note
+`getOEmbed(accessToken, url, maxWidth?)` returns embeddable HTML for a Threads
+post URL. Returns `{ html, provider_name, type, version, width }`.
 
-Ensure that your function is deployed with appropriate access controls and authentication mechanisms to protect sensitive data like access tokens.
+## Utilities
+
+`validateRequest(request)` checks a `ThreadsPostRequest` for invalid
+combinations (wrong media type for polls, too many text entities, etc.) and
+throws descriptive errors. Called automatically by `createThreadsContainer`.
+
+`checkContainerStatus(containerId, accessToken)` polls a container's publishing
+status. Returns `{ status, error_message? }` where `status` is `"FINISHED"`,
+`"IN_PROGRESS"`, `"EXPIRED"`, `"ERROR"`, or `"PUBLISHED"`.
 
 ## Testing
 
-To run the tests:
+Denim ships a `MockThreadsAPI` interface for testing without network requests.
+Set an implementation on `globalThis.threadsAPI` and all functions route through
+it instead of calling the Threads API:
 
-```bash
-deno test mod_test.ts
+```typescript
+import { MockThreadsAPIImpl } from "@codybrom/denim";
+
+const mock = new MockThreadsAPIImpl();
+(globalThis as any).threadsAPI = mock;
+
+// Now all denim functions use the mock
+const container = await createThreadsContainer({ ... });
+
+// Enable error mode to test failure paths
+mock.setErrorMode(true);
 ```
 
-## Contributing
+See `mod_test.ts` for more examples.
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+```bash
+deno task test
+```
 
 ## License
 
-[MIT License](LICENSE)
+[MIT](LICENSE)

package/src/api/createCarouselItem.ts

@@ -0,0 +1,86 @@
+import { THREADS_API_BASE_URL } from "../constants.ts";
+import type { ThreadsPostRequest } from "../types.ts";
+import { getAPI } from "../utils/getAPI.ts";
+/**
+ * Creates a carousel item for a Threads carousel post.
+ *
+ * This function sends a request to the Threads API to create a single item
+ * that will be part of a carousel post. It can be used for both image and
+ * video items.
+ *
+ * @param request - The request object containing carousel item details
+ * @param request.userId - The user ID of the Threads account
+ * @param request.accessToken - The access token for authentication
+ * @param request.mediaType - The type of media for this carousel item ('IMAGE' or 'VIDEO')
+ * @param request.imageUrl - The URL of the image (required if mediaType is 'IMAGE')
+ * @param request.videoUrl - The URL of the video (required if mediaType is 'VIDEO')
+ * @param request.altText - Optional accessibility text for the image or video
+ * @returns A Promise that resolves to the carousel item ID
+ * @throws Will throw an error if the API request fails or returns an invalid response
+ *
+ * @example
+ * ```typescript
+ * const itemRequest = {
+ *   userId: "123456",
+ *   accessToken: "your_access_token",
+ *   mediaType: "IMAGE" as const,
+ *   imageUrl: "https://example.com/image.jpg",
+ *   altText: "A beautiful landscape"
+ * };
+ * const itemId = await createCarouselItem(itemRequest);
+ * ```
+ */
+export async function createCarouselItem(
+	request: Omit<ThreadsPostRequest, "mediaType"> & {
+		mediaType: "IMAGE" | "VIDEO";
+	},
+): Promise<string> {
+	const api = getAPI();
+	if (api) {
+		return api.createCarouselItem(request);
+	}
+	if (request.mediaType !== "IMAGE" && request.mediaType !== "VIDEO") {
+		throw new Error("Carousel items must be either IMAGE or VIDEO type");
+	}
+
+	if (request.mediaType === "IMAGE" && !request.imageUrl) {
+		throw new Error("imageUrl is required for IMAGE type carousel items");
+	}
+
+	if (request.mediaType === "VIDEO" && !request.videoUrl) {
+		throw new Error("videoUrl is required for VIDEO type carousel items");
+	}
+
+	const url = `${THREADS_API_BASE_URL}/${request.userId}/threads`;
+	const body = new URLSearchParams({
+		access_token: request.accessToken,
+		media_type: request.mediaType,
+		is_carousel_item: "true",
+	});
+	if (request.imageUrl) body.append("image_url", request.imageUrl);
+	if (request.videoUrl) body.append("video_url", request.videoUrl);
+	if (request.altText) body.append("alt_text", request.altText);
+
+	const response = await fetch(url, {
+		method: "POST",
+		body: body,
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+		},
+	});
+
+	const responseText = await response.text();
+
+	if (!response.ok) {
+		throw new Error(
+			`Failed to create carousel item (${response.status}): ${responseText}`,
+		);
+	}
+
+	try {
+		const data = JSON.parse(responseText);
+		return data.id;
+	} catch (_error) {
+		throw new Error(`Invalid response from Threads API: ${responseText}`);
+	}
+}

package/src/api/createThreadsContainer.ts

@@ -0,0 +1,122 @@
+import { THREADS_API_BASE_URL } from "../constants.ts";
+import type { ThreadsPostRequest } from "../types.ts";
+import { getAPI } from "../utils/getAPI.ts";
+import { validateRequest } from "../utils/validateRequest.ts";
+/**
+ * Creates a Threads media container.
+ *
+ * @param request - The ThreadsPostRequest object containing post details
+ * @returns A Promise that resolves to the container ID
+ * @throws Will throw an error if the API request fails
+ *
+ * @example
+ * ```typescript
+ * const request: ThreadsPostRequest = {
+ *   userId: "123456",
+ *   accessToken: "your_access_token",
+ *   mediaType: "VIDEO",
+ *   text: "Check out this video!",
+ *   videoUrl: "https://example.com/video.mp4",
+ *   altText: "A cool video"
+ * };
+ * const containerId = await createThreadsContainer(request);
+ * ```
+ */
+export async function createThreadsContainer(
+	request: ThreadsPostRequest,
+): Promise<string> {
+	const api = getAPI();
+	if (api) {
+		return api.createThreadsContainer(request);
+	}
+	try {
+		// Input validation
+		await validateRequest(request);
+
+		const url = `${THREADS_API_BASE_URL}/${request.userId}/threads`;
+		const body = new URLSearchParams({
+			access_token: request.accessToken,
+			media_type: request.mediaType,
+		});
+
+		// Add common optional parameters
+		if (request.text) body.append("text", request.text);
+		if (request.altText) body.append("alt_text", request.altText);
+		if (request.replyControl) {
+			body.append("reply_control", request.replyControl);
+		}
+		if (request.allowlistedCountryCodes) {
+			body.append(
+				"allowlisted_country_codes",
+				JSON.stringify(request.allowlistedCountryCodes),
+			);
+		}
+
+		// New optional parameters
+		if (request.replyToId) body.append("reply_to_id", request.replyToId);
+		if (request.quotePostId) {
+			body.append("quote_post_id", request.quotePostId);
+		}
+		if (request.topicTag) body.append("topic_tag", request.topicTag);
+		if (request.isGhostPost !== undefined) {
+			body.append("is_ghost_post", String(request.isGhostPost));
+		}
+		if (request.locationId) body.append("location_id", request.locationId);
+		if (request.autoPublishText !== undefined) {
+			body.append("auto_publish_text", String(request.autoPublishText));
+		}
+		if (request.isSpoilerMedia !== undefined) {
+			body.append("is_spoiler_media", String(request.isSpoilerMedia));
+		}
+
+		// JSON-serialized parameters
+		if (request.pollAttachment) {
+			body.append("poll_attachment", JSON.stringify(request.pollAttachment));
+		}
+		if (request.textEntities) {
+			body.append("text_entities", JSON.stringify(request.textEntities));
+		}
+		if (request.textAttachment) {
+			body.append("text_attachment", JSON.stringify(request.textAttachment));
+		}
+		if (request.gifAttachment) {
+			body.append("gif_attachment", JSON.stringify(request.gifAttachment));
+		}
+
+		// Handle media type specific parameters
+		if (request.mediaType === "VIDEO" && request.videoUrl) {
+			body.append("video_url", request.videoUrl);
+		} else if (request.mediaType === "IMAGE" && request.imageUrl) {
+			body.append("image_url", request.imageUrl);
+		} else if (request.mediaType === "TEXT" && request.linkAttachment) {
+			body.append("link_attachment", request.linkAttachment);
+		} else if (request.mediaType === "CAROUSEL" && request.children) {
+			body.append("children", request.children.join(","));
+		}
+
+		const response = await fetch(url, {
+			method: "POST",
+			body: body,
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		});
+
+		const responseText = await response.text();
+
+		if (!response.ok) {
+			throw new Error(
+				`Failed to create container (${response.status} ${response.statusText}): ${responseText}`,
+			);
+		}
+
+		const data = JSON.parse(responseText);
+
+		return data.id;
+	} catch (error) {
+		// Rethrow the error if it's already an Error instance
+		if (error instanceof Error) {
+			throw error;
+		}
+		// Otherwise, wrap it in a new Error
+		throw new Error(`Failed to create Threads container: ${String(error)}`);
+	}
+}