@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/slack/actions.js

@@ -50,6 +50,16 @@ const messageContentProperties = {
     unfurlMedia: s.boolean({ description: "Whether Slack should unfurl media in the message." }),
     metadata: s.unknownObject("Slack message metadata to attach to the message."),
 };
+// Shared by `conversations.history` and `conversations.replies`: opt in to
+// the untouched vendor record. Off by default so the row read in bulk stays
+// lean. Opting in also asks Slack for message metadata, which it leaves out
+// unless the request sets `include_all_metadata`.
+const includeRawProperties = {
+    includeRaw: s.boolean({
+        description: "When true, each returned message also carries the untouched Slack record under raw, including its blocks, attachments, files and message metadata. Defaults to false.",
+    }),
+};
+const rawMessageSchema = s.unknownObject("The untouched Slack record, exactly as the Slack API returned it. Present only when includeRaw is true.");
 const slackReactionSchema = s.looseObject({
     name: s.string({ description: "The emoji name of the reaction." }),
     count: s.integer({ description: "How many users added this reaction." }),
@@ -60,9 +70,10 @@ const slackReactionSchema = s.looseObject({
 // Only fields the executor actually normalizes are declared. The object is
 // loose, but that permits extras it does NOT make them appear: the executor
 // builds each row explicitly, so an undeclared Slack field is simply not
-// emitted. Deliberately absent: `blocks`, `attachments` and `files`. Those
-// are unbounded nested payloads on a row shape that ETL reads in bulk, and
-// each wants its own normalized contract rather than a raw passthrough.
+// emitted. Deliberately absent: `blocks`, `attachments`, `files` and
+// `metadata`. Those are unbounded nested payloads on a row shape that ETL
+// reads in bulk, so they stay out of the default row; a caller that needs
+// them passes includeRaw and reads them from `raw`, the untouched record.
 const slackMessageSchema = s.looseObject({
     ts: s.string({ description: "The message timestamp identifier." }),
     type: s.string({ description: "The Slack message type, normally 'message'." }),
@@ -77,15 +88,20 @@ const slackMessageSchema = s.looseObject({
     clientMsgId: s.string({ description: "The client-generated message identifier when Slack returns one." }),
     text: s.string({ description: "The text content of the message." }),
     editedTs: s.string({ description: "The timestamp of the most recent edit, when the message was edited." }),
+    editedUserId: s.string({ description: "The user ID of the most recent editor, when the message was edited." }),
     threadTs: s.string({
         description: "The timestamp of the thread parent. Equal to ts on a thread parent, and absent on a message that is not in a thread.",
     }),
     parentUserId: s.string({ description: "The author of the thread parent, on a threaded reply." }),
     replyCount: s.integer({ description: "The number of replies to this thread parent." }),
     replyUsersCount: s.integer({ description: "The number of distinct users who replied to this thread parent." }),
+    replyUserIds: s.array(s.string({ description: "A Slack user ID." }), {
+        description: "Up to five user IDs of people who replied to this thread parent. Slack caps this list; use replyUsersCount for the total.",
+    }),
     latestReply: s.string({ description: "The timestamp of the most recent reply to this thread parent." }),
     isLocked: s.boolean({ description: "Whether the thread is locked." }),
     reactions: s.array(slackReactionSchema, { description: "Reaction summaries attached to the message." }),
+    raw: rawMessageSchema,
 }, { description: "A Slack message record." });
 const searchMessageMatchSchema = s.looseObject({
     matchId: s.string({ description: "Slack's search result item identifier." }),
@@ -98,6 +114,7 @@ const searchMessageMatchSchema = s.looseObject({
     permalink: s.string({ description: "A Slack permalink for the matching message." }),
     teamId: s.string({ description: "The Slack team ID returned for the match." }),
     type: s.string({ description: "The Slack result type." }),
+    raw: rawMessageSchema,
 }, { description: "A normalized Slack message search match." });
 const conversationSchema = s.object({
     channelId: s.string({ description: "The unique identifier of the conversation." }),
@@ -113,6 +130,21 @@ const conversationSchema = s.object({
     purpose: s.nullable(s.string({ description: "The conversation purpose." })),
     userId: s.string({ description: "The linked user identifier for IM conversations." }),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    created: s.integer({ description: "Creation time as a Unix timestamp in seconds when Slack provides it." }),
+    updated: s.integer({
+        description: "Last settings update time, passed through as Slack returns it. Slack documents epoch milliseconds for channels (unlike created) and a Unix timestamp for legacy IM and MPIM objects.",
+    }),
+    creatorId: s.string({ description: "The user who created the conversation when Slack provides it." }),
+    isShared: s.boolean({ description: "Whether the conversation is shared with another workspace." }),
+    isExtShared: s.boolean({ description: "Whether the conversation is shared with an external organization." }),
+    isOrgShared: s.boolean({
+        description: "Whether the conversation is shared between workspaces of the same Enterprise organization.",
+    }),
+    contextTeamId: s.string({
+        description: "The ID of the workspace the conversation is within when Slack provides it.",
+    }),
+    lastRead: s.string({ description: "The last-read message timestamp when Slack provides it." }),
+    unreadCount: s.integer({ description: "The unread message count when Slack provides it." }),
 }, {
     required: ["channelId", "name", "type", "isArchived", "isPrivate", "isMember", "topic", "purpose"],
     description: "A normalized Slack conversation record.",
@@ -127,6 +159,18 @@ const userSchema = s.object({
     isAdmin: s.nullable(s.boolean({ description: "Whether the user is an admin." })),
     isOwner: s.nullable(s.boolean({ description: "Whether the user is an owner." })),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    email: s.string({
+        description: "The profile email. Slack returns it only when the token holds the users:read.email scope.",
+    }),
+    tz: s.string({ description: "The user's time zone identifier when Slack provides it." }),
+    tzOffset: s.integer({ description: "The user's UTC offset in seconds when Slack provides it." }),
+    updated: s.integer({ description: "When the user object was last updated, as a Unix timestamp in seconds." }),
+    teamId: s.string({ description: "The user's team ID when Slack provides it." }),
+    isRestricted: s.boolean({
+        description: "Whether the user is a guest. Single-channel guests also set isUltraRestricted.",
+    }),
+    isUltraRestricted: s.boolean({ description: "Whether the user is a single-channel guest." }),
+    isAppUser: s.boolean({ description: "Whether the user is an authorized user of the calling app." }),
 }, {
     required: ["userId", "username", "realName", "displayName", "isBot", "isDeleted", "isAdmin", "isOwner"],
     description: "A normalized Slack user record.",
@@ -188,6 +232,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId"], description: "Input parameters for reading Slack conversation history." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the conversation." }),
@@ -242,6 +287,9 @@ export const slackActions = [
             sort: searchSortSchema,
             sortDir: sortDirectionSchema,
             teamId: s.string({ description: "The encoded team ID to search when using an org-level token." }),
+            includeRaw: s.boolean({
+                description: "When true, each returned match also carries the untouched Slack search match under raw, including any blocks, attachments and files. Defaults to false.",
+            }),
         }, { required: ["query"], description: "Input parameters for searching Slack messages." }),
         outputSchema: s.object({
             query: s.string({ description: "The search query Slack executed." }),
@@ -323,6 +371,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId", "threadTs"], description: "Input parameters for reading a Slack thread." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the thread." }),
@@ -537,6 +586,23 @@ export const slackActions = [
         inputSchema: s.object({ fileId: fileIdSchema }, { required: ["fileId"], description: "Input parameters for fetching a Slack file." }),
         outputSchema: s.object({ file: fileSchema }, { required: ["file"], description: "The output payload for this action." }),
     }),
+    action({
+        name: "download_file",
+        operationType: "read",
+        description: "Download a Slack-hosted file into transit storage using the connected identity's access.",
+        requiredScopes: ["files:read"],
+        inputSchema: s.requiredObject("The Slack file to download.", { fileId: fileIdSchema }),
+        outputSchema: s.requiredObject("A Slack file downloaded into transit storage.", {
+            fileId: fileIdSchema,
+            file: s.requiredObject("The downloaded file in transit storage.", {
+                fileId: s.nonEmptyString("The transit file identifier."),
+                downloadUrl: s.url("The transit URL for downloading the stored file."),
+                sizeBytes: s.nonNegativeInteger("The stored file size in bytes."),
+                name: s.nonEmptyString("The stored file name."),
+                mimeType: s.nonEmptyString("The stored file MIME type."),
+            }),
+        }),
+    }),
     action({
         name: "delete_file",
         operationType: "destructive",

package/src/providers/slack/runtime.js

@@ -1,6 +1,6 @@
-import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
+import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, optionalStringArray, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { slackConversationTypes } from "./constants.js";
 export const slackApiBaseUrl = "https://slack.com/api";
 const slackFileUrlMaxBytes = 100 * 1024 * 1024;
@@ -116,6 +116,9 @@ export const slackActionHandlers = {
     get_file(input, context) {
         return slackGetFile(input, context);
     },
+    download_file(input, context) {
+        return slackDownloadFile(input, context);
+    },
     delete_file(input, context) {
         return slackDeleteFile(input, context);
     },
@@ -193,7 +196,8 @@ async function slackGetChannelMessages(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history", includeRaw);
 }
 async function slackConversationsMembers(input, context) {
     const url = slackApiUrl("conversations.members");
@@ -211,6 +215,7 @@ async function slackConversationsMembers(input, context) {
     };
 }
 async function slackSearchMessages(input, context) {
+    const includeRaw = input.includeRaw === true;
     const query = requiredString(input.query, "query", (message) => new ProviderRequestError(400, message));
     if (input.page != null && input.cursor != null) {
         throw new ProviderRequestError(400, "page and cursor cannot be used together");
@@ -241,7 +246,7 @@ async function slackSearchMessages(input, context) {
     const payload = await slackGetJson(url, context);
     return {
         query: optionalString(payload.query) ?? query,
-        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match)),
+        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match, includeRaw)),
         total: typeof payload.messages?.total === "number" ? payload.messages.total : 0,
         pagination: payload.messages?.pagination ?? {},
         paging: payload.messages?.paging ?? {},
@@ -315,7 +320,8 @@ async function slackGetThread(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies", includeRaw);
 }
 async function slackListConversations(input, context) {
     const url = slackApiUrl("conversations.list");
@@ -545,6 +551,61 @@ async function slackGetFile(input, context) {
         file: normalizeFile(payload.file ?? {}),
     };
 }
+async function slackDownloadFile(input, context) {
+    const { transitFiles } = context;
+    if (!transitFiles) {
+        throw providerInputError("Slack download_file requires transit file storage");
+    }
+    const fileId = requiredInputString(input.fileId, "fileId");
+    return runProviderRequest({ signal: context.signal, label: "Slack file download" }, async (signal) => {
+        signal.throwIfAborted();
+        const infoUrl = slackApiUrl("files.info");
+        infoUrl.searchParams.set("file", fileId);
+        const payload = await slackGetJson(infoUrl, { ...context, signal });
+        const metadata = requiredResponseRecord(payload.file, "Slack file metadata");
+        const privateUrl = optionalString(metadata.url_private_download) ?? optionalString(metadata.url_private);
+        if (metadata.is_external === true || !privateUrl) {
+            throw providerInputError("This Slack file has no downloadable Slack-hosted content");
+        }
+        const url = assertPublicHttpUrl(privateUrl, { fieldName: "Slack file URL", createError: providerResponseError });
+        // Only Slack's file origin may receive the connection's bearer token.
+        // The shared fetch guard drops it if a redirect crosses origins.
+        if (url.origin !== "https://files.slack.com") {
+            throw providerResponseError("Slack file URL must use https://files.slack.com");
+        }
+        if ((optionalNumber(metadata.size) ?? 0) > transitFiles.maxBytes) {
+            throw new ProviderRequestError(413, `Slack file download exceeds ${transitFiles.maxBytes} bytes`);
+        }
+        const response = await context.fetcher(url, {
+            headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
+            signal,
+        });
+        try {
+            if (!response.ok) {
+                throw new ProviderRequestError(response.status, `Slack file download failed with HTTP ${response.status}`);
+            }
+            const mimeType = optionalString(response.headers.get("content-type")) ??
+                optionalString(metadata.mimetype) ??
+                "application/octet-stream";
+            // Slack can return a sign-in page instead of the requested bytes.
+            if (mimeType.split(";")[0]?.trim().toLowerCase() === "text/html" && metadata.mimetype !== "text/html") {
+                throw providerResponseError("Slack returned an HTML page instead of the requested file");
+            }
+            const bytes = await readBoundedResponseBytes(response, {
+                maxBytes: transitFiles.maxBytes,
+                fieldName: "Slack file download",
+                createError: (message) => new ProviderRequestError(413, message),
+            });
+            signal.throwIfAborted();
+            const name = optionalString(metadata.name) ?? fileId;
+            const file = await transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
+            return { fileId, file };
+        }
+        finally {
+            await response.body?.cancel().catch(() => undefined);
+        }
+    });
+}
 async function slackDeleteFile(input, context) {
     await slackRequestJson({
         ...context,
@@ -593,7 +654,7 @@ async function slackFormRequestJson(context, method, body) {
 async function readSlackResponseJson(response) {
     const payload = (optionalRecord(await response.json().catch(() => undefined)) ?? {});
     if (!response.ok) {
-        throw slackHttpError(response.status, payload, response.headers.get("retry-after"));
+        throw slackHttpError(response, payload);
     }
     assertSlackPayload(payload);
     // Preserve HTTP/Slack failures (including Retry-After) above, but require
@@ -786,6 +847,15 @@ function normalizeConversation(conversation) {
         purpose: typeof purpose?.value === "string" ? purpose.value : null,
         userId: optionalString(conversation.user),
         locale: optionalString(conversation.locale),
+        created: optionalInteger(conversation.created),
+        updated: optionalInteger(conversation.updated),
+        creatorId: optionalString(conversation.creator),
+        isShared: optionalBoolean(conversation.is_shared),
+        isExtShared: optionalBoolean(conversation.is_ext_shared),
+        isOrgShared: optionalBoolean(conversation.is_org_shared),
+        contextTeamId: optionalString(conversation.context_team_id),
+        lastRead: optionalString(conversation.last_read),
+        unreadCount: optionalInteger(conversation.unread_count),
     });
 }
 /**
@@ -805,13 +875,27 @@ function applySlackHistoryWindow(url, input) {
         url.searchParams.set("inclusive", String(input.inclusive));
     }
 }
+/**
+ * Apply the shared `includeRaw` opt-in of `conversations.history` /
+ * `conversations.replies` and report whether it is on. Only a literal `true`
+ * opts in. Slack leaves message metadata out of both methods unless the
+ * request sets `include_all_metadata`, and `raw` promises the whole record, so
+ * opting in asks for it too.
+ */
+function applySlackIncludeRaw(url, input) {
+    const includeRaw = input.includeRaw === true;
+    if (includeRaw) {
+        url.searchParams.set("include_all_metadata", "true");
+    }
+    return includeRaw;
+}
 /**
  * Read one `conversations.history` / `conversations.replies` page. A page whose
  * list is missing or whose rows are not objects is rejected rather than
  * flattened into an empty result, so a broken upstream response cannot pass
  * for the documented end of a walk.
  */
-function readSlackMessagePage(payload, method) {
+function readSlackMessagePage(payload, method, includeRaw = false) {
     if (payload.has_more !== undefined && typeof payload.has_more !== "boolean") {
         throw slackResponseError(`${method} has_more`);
     }
@@ -821,7 +905,7 @@ function readSlackMessagePage(payload, method) {
             if (!record) {
                 throw slackResponseError(`${method} message`);
             }
-            return normalizeSlackMessage(record);
+            return normalizeSlackMessage(record, includeRaw);
         }),
         hasMore: payload.has_more ?? false,
         nextCursor: readSlackNextCursor(payload, method),
@@ -869,8 +953,13 @@ function requireSlackId(value, label) {
  * missing value stays distinguishable from an empty one. `userId` is the one
  * exception kept for compatibility: it stays `""` on a message with no
  * author, where `botId` / `username` carry the identity instead.
+ *
+ * `files`, `attachments`, `blocks` and `metadata` stay out of the row: they
+ * are unbounded nested payloads on a row read in bulk. With `includeRaw` the
+ * whole untouched record rides along under `raw` for a consumer that needs
+ * them, or any other field this normalizer does not model.
  */
-function normalizeSlackMessage(message) {
+function normalizeSlackMessage(message, includeRaw = false) {
     const edited = optionalRecord(message.edited) ?? {};
     const reactions = Array.isArray(message.reactions) ? message.reactions : undefined;
     return compactObject({
@@ -885,13 +974,16 @@ function normalizeSlackMessage(message) {
         clientMsgId: optionalString(message.client_msg_id),
         text: typeof message.text === "string" ? message.text : "",
         editedTs: optionalString(edited.ts),
+        editedUserId: optionalString(edited.user),
         threadTs: optionalString(message.thread_ts),
         parentUserId: optionalString(message.parent_user_id),
         replyCount: optionalInteger(message.reply_count),
         replyUsersCount: optionalInteger(message.reply_users_count),
+        replyUserIds: optionalStringArray(message.reply_users),
         latestReply: optionalString(message.latest_reply),
         isLocked: optionalBoolean(message.is_locked),
         reactions: reactions?.map((reaction) => normalizeSlackReaction(optionalRecord(reaction) ?? {})),
+        raw: includeRaw ? message : undefined,
     });
 }
 function normalizeSlackReaction(reaction) {
@@ -901,7 +993,7 @@ function normalizeSlackReaction(reaction) {
         userIds: Array.isArray(reaction.users) ? reaction.users.map((user) => String(user)) : undefined,
     });
 }
-function normalizeSearchMessageMatch(match) {
+function normalizeSearchMessageMatch(match, includeRaw = false) {
     const channel = optionalRecord(match.channel) ?? {};
     return compactObject({
         matchId: optionalString(match.iid),
@@ -914,6 +1006,7 @@ function normalizeSearchMessageMatch(match) {
         permalink: optionalString(match.permalink),
         teamId: optionalString(match.team),
         type: optionalString(match.type),
+        raw: includeRaw ? match : undefined,
     });
 }
 function normalizeUser(user) {
@@ -928,6 +1021,14 @@ function normalizeUser(user) {
         isAdmin: typeof user.is_admin === "boolean" ? user.is_admin : null,
         isOwner: typeof user.is_owner === "boolean" ? user.is_owner : null,
         locale: optionalString(user.locale),
+        email: optionalString(profile.email),
+        tz: optionalString(user.tz),
+        tzOffset: optionalInteger(user.tz_offset),
+        updated: optionalInteger(user.updated),
+        teamId: optionalString(user.team_id),
+        isRestricted: optionalBoolean(user.is_restricted),
+        isUltraRestricted: optionalBoolean(user.is_ultra_restricted),
+        isAppUser: optionalBoolean(user.is_app_user),
     });
 }
 function normalizeFile(file) {
@@ -979,17 +1080,11 @@ function formatSlackPayloadError(payload) {
     }
     return `${error}: ${details.join("; ")}`;
 }
-function slackHttpError(status, payload, retryAfter) {
-    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${status}`;
-    if (status === 429 && retryAfter !== null && /^\d+$/.test(retryAfter)) {
-        const retryAfterSeconds = Number(retryAfter);
-        if (Number.isSafeInteger(retryAfterSeconds)) {
-            // The action envelope carries provider details; retain pacing so callers
-            // can resume the same page without guessing when this workspace may retry.
-            return new ProviderRequestError(status, message, { ...payload, retryAfterSeconds });
-        }
-    }
-    return new ProviderRequestError(status, message, payload);
+function slackHttpError(response, payload) {
+    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${response.status}`;
+    // The action envelope carries provider details; retain pacing so callers
+    // can resume the same page without guessing when this workspace may retry.
+    return new ProviderRequestError(response.status, message, withRetryAfterSeconds(response, payload));
 }
 function slackResponseError(message) {
     return new ProviderRequestError(502, `slack response is invalid: ${message}`);

package/src/providers/slickdeals/runtime.js

@@ -155,7 +155,7 @@ async function requestSlickdealsJson(input) {
                 authorization: `Bearer ${input.token}`,
                 "user-agent": providerUserAgent,
             },
-            redirect: "error",
+            redirect: "manual",
             signal,
         });
         const payload = await readPayload(response);

package/src/providers/sorftime_mcp/executors.js

@@ -45,7 +45,7 @@ export const proxy = defineProviderProxy({
     baseUrl: sorftimeMcpEndpoint,
     auth: { type: "api_key_authorization", prefix: "Bearer " },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     timeoutMs: requestTimeoutMs,
     allowedEndpoint(endpoint) {
         const url = new URL(endpoint, sorftimeMcpEndpoint);
@@ -79,7 +79,7 @@ function withSorftimeClient(context, run) {
             authorization: `Bearer ${context.apiKey}`,
             "user-agent": providerUserAgent,
         },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapSorftimeError,
     }, run);

package/src/providers/speak_ai/executors.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/speak_ai/executors.js

@@ -0,0 +1,187 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { compactObject, looseArray, optionalInteger, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "speak_ai";
+const apiBaseUrl = "https://api.speakai.co/v1";
+const tokenCache = new Map();
+const handlers = {
+    async upload_media(input, context) {
+        const data = await request("/media/upload", {
+            method: "POST",
+            body: compactObject({
+                name: requiredInputString(input.name, "name"),
+                url: requiredInputString(input.mediaUrl, "mediaUrl"),
+                mediaType: optionalString(input.mediaType),
+                description: optionalString(input.description),
+                sourceLanguage: optionalString(input.sourceLanguage),
+                tags: optionalString(input.tags),
+                folderId: optionalString(input.folderId),
+            }),
+        }, context, "execute");
+        return { mediaId: requiredResponseString(data.mediaId, "Speak AI upload mediaId") };
+    },
+    async list_media(input, context) {
+        const data = await request(buildUrl("/media", input, {
+            mediaType: "mediaType",
+            page: "page",
+            pageSize: "pageSize",
+            sortBy: "sortBy",
+            filterMedia: "filterMedia",
+            filterName: "filterName",
+            folderId: "folderId",
+        }), { method: "GET" }, context, "execute");
+        return {
+            totalCount: requireInteger(data.totalCount, "totalCount"),
+            pages: requireInteger(data.pages, "pages"),
+            media: looseArray(data.mediaList),
+        };
+    },
+    async get_media_status(input, context) {
+        const data = await media(input, context, "status");
+        return {
+            mediaId: requiredResponseString(data.mediaId, "mediaId"),
+            state: requiredResponseString(data.state, "state"),
+            media: data,
+        };
+    },
+    async get_transcript(input, context) {
+        const data = await media(input, context, "transcript");
+        return { mediaId: requiredResponseString(data.mediaId, "mediaId"), transcript: data };
+    },
+    async get_media_insights(input, context) {
+        const data = await media(input, context, "insight");
+        return { mediaId: requiredResponseString(data.mediaId, "mediaId"), insights: data };
+    },
+    async list_folders(input, context) {
+        const data = await request(buildUrl("/folder", input, { page: "page", pageSize: "pageSize", sortBy: "sortBy" }), { method: "GET" }, context, "execute");
+        return {
+            totalCount: requireInteger(data.totalCount, "totalCount"),
+            pages: data.pages == null ? null : requireInteger(data.pages, "pages"),
+            folders: looseArray(data.folders),
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const token = await authenticate(input.apiKey, fetcher, "validate");
+        return {
+            profile: { accountId: token.email ?? "speak-ai-api-key", displayName: token.email ?? "Speak AI API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl, validationEndpoint: "/auth/accessToken" },
+        };
+    },
+};
+async function media(input, context, family) {
+    const mediaId = requiredInputString(input.mediaId, "mediaId");
+    const data = await request(`/media/${family}/${encodeURIComponent(mediaId)}`, { method: "GET" }, context, "execute");
+    return data.state === "notUploaded" && data.mediaId === undefined ? { ...data, mediaId } : data;
+}
+async function request(path, init, context, phase) {
+    let token = await authenticate(context.apiKey, context.fetcher, phase);
+    let response = await fetchToken(path, init, context, token.accessToken);
+    let payload = await readProviderJsonBody(response, {
+        emptyBody: {},
+        invalidJsonMessage: "Speak AI returned invalid JSON",
+    });
+    if (phase === "execute" && response.status === 401) {
+        tokenCache.delete(sha256Hex(context.apiKey));
+        token = await authenticate(context.apiKey, context.fetcher, phase);
+        response = await fetchToken(path, init, context, token.accessToken);
+        payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Speak AI returned invalid JSON",
+        });
+    }
+    if (!response.ok)
+        throw error(response.status, payload, phase);
+    const envelope = requiredResponseRecord(payload, "Speak AI response");
+    if (envelope.state === "notUploaded" && envelope.data === undefined)
+        return envelope;
+    return requiredResponseRecord(envelope.data, "Speak AI response data");
+}
+function requiredResponseString(value, label) {
+    const result = optionalString(value);
+    if (!result)
+        throw providerResponseError(`${label} must be a non-empty string`);
+    return result;
+}
+function fetchToken(path, init, context, accessToken) {
+    return runProviderRequest({ signal: context.signal, label: "Speak AI" }, (signal) => context.fetcher(path instanceof URL ? path : `${apiBaseUrl}${path}`, {
+        method: init.method,
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+            "x-speakai-key": context.apiKey,
+            "x-access-token": accessToken,
+        },
+        body: init.body ? JSON.stringify(init.body) : undefined,
+        signal,
+    }));
+}
+async function authenticate(apiKey, fetcher, phase) {
+    const key = sha256Hex(apiKey);
+    if (phase === "validate")
+        tokenCache.delete(key);
+    const cached = tokenCache.get(key);
+    if (cached) {
+        const value = await cached;
+        if (Date.now() < value.expiresAt)
+            return value;
+        tokenCache.delete(key);
+    }
+    const pending = runProviderRequest({ label: "Speak AI authentication" }, async (signal) => {
+        const response = await fetcher(`${apiBaseUrl}/auth/accessToken`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "user-agent": providerUserAgent, "x-speakai-key": apiKey },
+            body: "{}",
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Speak AI returned invalid JSON",
+        });
+        if (!response.ok)
+            throw error(response.status, payload, phase);
+        const data = requiredResponseRecord(requiredResponseRecord(payload, "Speak AI authentication response").data, "Speak AI authentication data");
+        return {
+            accessToken: requiredInputString(data.accessToken, "accessToken"),
+            email: optionalString(data.email),
+            expiresAt: Date.now() + 3_000_000,
+        };
+    });
+    tokenCache.set(key, pending);
+    try {
+        return await pending;
+    }
+    catch (cause) {
+        tokenCache.delete(key);
+        throw cause;
+    }
+}
+function error(status, payload, phase) {
+    const body = requiredResponseRecord(payload, "Speak AI error response");
+    const message = optionalString(body.message) ?? "Speak AI request failed";
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (phase === "validate" && optionalInteger(body.code) === 401)
+        return providerInputError(message);
+    if (status === 400 || status === 422)
+        return providerInputError(message);
+    return new ProviderRequestError(status || 502, message, payload);
+}
+function requireInteger(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        throw new ProviderRequestError(502, `Speak AI ${label} must be an integer`);
+    return value;
+}
+function buildUrl(path, input, mapping) {
+    const url = new URL(`${apiBaseUrl}${path}`);
+    for (const [key, query] of Object.entries(mapping))
+        if (input[key] != null)
+            url.searchParams.set(query, String(input[key]));
+    return url;
+}

package/src/providers/tikhub/bounded-response.d.ts

@@ -5,4 +5,4 @@ export declare function readBoundedResponseText(response: Response, input: {
     maxBytes: number;
     label: string;
 }): Promise<string>;
-export declare function cancelResponseBody(response: Response): Promise<void>;
+export declare function cancelResponseBody(response: Response): void;