@oomol-lab/open-connector 1.7.0 → 1.9.0

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 type OneDriveRuntimeDeps = OAuthProviderContext;
@@ -23,4 +25,5 @@ export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
 export declare function oneDriveJsonRequest<T>(pathOrUrl: string, input: OneDriveRequestInput): Promise<T>;
 export declare function assertOneDriveResponse(response: Response): Promise<void>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/one_drive/executors.js

@@ -1,7 +1,8 @@
 import { Buffer } from "node:buffer";
 import { compactObject, requiredRecord } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, ProviderRequestError, readTransitFileInput, } from "../provider-runtime.js";
+import { oneDriveItemChanged } from "./trigger-on-item-changed.js";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0";
 const graphOrigin = new URL(graphBaseUrl).origin;
 const oneDriveUploadChunkSizeBytes = 10 * 1024 * 1024;
@@ -553,12 +554,13 @@ async function downloadDriveItem(input) {
     const name = resolveDownloadFileName(metadata, input.format);
     const transitName = input.fileName ?? name;
     const mimeType = resolveDownloadMimeType(metadata, response, input.format);
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: transitFiles.maxBytes,
+    const file = await storeResponseInTransit(response, transitFiles, {
+        name: transitName,
+        mimeType,
         fieldName: "OneDrive download",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: input.deps.signal,
     });
-    const file = await transitFiles.create(new File([toArrayBuffer(bytes)], transitName, { type: mimeType }));
     return {
         fileId,
         name,
@@ -1194,3 +1196,4 @@ function toArrayBuffer(bytes) {
     }
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
+export const triggers = [oneDriveItemChanged];

package/src/providers/one_drive/trigger-on-item-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const oneDriveItemChanged: PollDefinition;

package/src/providers/one_drive/trigger-on-item-changed.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/one_drive/trigger-on-item-changed.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const eventSchema = s.object({
+    changeType: s.stringEnum(["created", "updated", "deleted"]),
+    createdDateTime: { type: ["string", "null"] },
+    driveId: { type: ["string", "null"] },
+    eTag: { type: ["string", "null"] },
+    itemId: s.string(),
+    itemType: s.stringEnum(["file", "folder"]),
+    lastModifiedDateTime: { type: ["string", "null"] },
+    mimeType: { type: ["string", "null"] },
+    name: s.string(),
+    parentFolderId: { type: ["string", "null"] },
+    size: { type: ["number", "null"] },
+    webUrl: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "itemId",
+        "name",
+        "changeType",
+        "itemType",
+        "size",
+        "mimeType",
+        "webUrl",
+        "parentFolderId",
+        "driveId",
+        "createdDateTime",
+        "lastModifiedDateTime",
+        "eTag",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(["created", "updated", "deleted"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["created", "updated"],
+        },
+        { handle: "itemId", jsonSchema: s.string(), nullable: false, value: "" },
+        {
+            handle: "itemTypes",
+            jsonSchema: s.array(s.stringEnum(["file", "folder"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["file"],
+        },
+        {
+            handle: "maxItemsPerPoll",
+            jsonSchema: s.integer({ maximum: 200, minimum: 1 }),
+            nullable: false,
+            value: 50,
+        },
+        { handle: "parentFolderId", jsonSchema: s.string(), nullable: false, value: "" },
+    ],
+    definitionVersion: 2,
+    description: "Polls the OneDrive change feed and triggers when a file or folder is created, updated or deleted.",
+    displayName: "File or Folder Changed",
+    key: "one_drive.on_item_changed",
+    name: "on_item_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "one_drive",
+    type: "poll",
+};

package/src/providers/one_drive/trigger-on-item-changed.js

@@ -0,0 +1,214 @@
+import { canonicalJsonBytes, digestBytes } from "../../triggers/common/encoding.js";
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-item-changed.definition.js";
+export const oneDriveItemChanged = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return { checkpoint: (await seed(context, config)), events: [] };
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const { items, next } = await changedItems(context, checkpoint, config.maxItemsPerPoll);
+        const events = [];
+        let filtered = 0;
+        for (const [id, item] of items) {
+            const result = await evaluate(id, item, config, checkpoint);
+            if (result == "structural")
+                continue;
+            if (result == "filtered")
+                filtered += 1;
+            else
+                events.push(result);
+        }
+        return {
+            checkpoint: next.checkpoint,
+            events,
+            filtered,
+            ...(next.hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: value.events,
+        itemId: value.itemId.trim(),
+        itemTypes: value.itemTypes,
+        maxItemsPerPoll: value.maxItemsPerPoll,
+        parentFolderId: value.parentFolderId.trim(),
+    };
+}
+async function seed(context, config) {
+    const result = await get(context, "/me/drive/root/delta", { token: "latest" });
+    if (result.status == 404)
+        throw new PermanentPollError("OneDrive is not provisioned for this account.");
+    success(result, "delta seeding");
+    const link = record(result.data)?.["@odata.deltaLink"];
+    const token = link == null ? null : parseToken(link);
+    if (token == null)
+        throw new TransientPollError("OneDrive delta seeding response has no delta token.");
+    await validateItem(context, "parentFolderId", config.parentFolderId);
+    await validateItem(context, "itemId", config.itemId);
+    return { deltaToken: token, lastPolledAt: context.now.toISOString() };
+}
+async function validateItem(context, field, id) {
+    if (id.length == 0)
+        return;
+    const result = await get(context, `/me/drive/items/${encodeURIComponent(id)}`, {});
+    if (result.status == 400 || result.status == 404)
+        throw new PermanentPollError(`OneDrive ${field} does not identify an item in this drive.`);
+    success(result, `${field} validation`);
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    if (typeof checkpoint?.deltaToken != "string" ||
+        checkpoint.deltaToken.length == 0 ||
+        typeof checkpoint.lastPolledAt != "string" ||
+        Number.isNaN(Date.parse(checkpoint.lastPolledAt))) {
+        throw new PermanentPollError("OneDrive checkpoint is invalid; recreate the Trigger.");
+    }
+    return {
+        deltaToken: checkpoint.deltaToken,
+        lastPolledAt: checkpoint.lastPolledAt,
+        ...(typeof checkpoint.pageToken == "string" && checkpoint.pageToken.length > 0
+            ? { pageToken: checkpoint.pageToken }
+            : {}),
+    };
+}
+async function changedItems(context, checkpoint, pageSize) {
+    const items = new Map();
+    const result = await get(context, "/me/drive/root/delta", {
+        $top: Math.min(pageSize, maximumPollEventsPerPage),
+        token: checkpoint.pageToken ?? checkpoint.deltaToken,
+    });
+    deltaSuccess(result);
+    const parsed = (record(result.data) ?? {});
+    for (const item of parsed.value ?? [])
+        if (item.id != null && item.id.length > 0)
+            items.set(item.id, item);
+    if (parsed["@odata.deltaLink"]) {
+        return {
+            items,
+            next: {
+                checkpoint: {
+                    deltaToken: requireToken(parsed["@odata.deltaLink"]),
+                    lastPolledAt: context.now.toISOString(),
+                },
+                hasMore: false,
+            },
+        };
+    }
+    if (!parsed["@odata.nextLink"])
+        throw new TransientPollError("OneDrive delta response has no continuation link.");
+    return {
+        items,
+        next: {
+            checkpoint: {
+                deltaToken: checkpoint.deltaToken,
+                lastPolledAt: checkpoint.lastPolledAt,
+                pageToken: requireToken(parsed["@odata.nextLink"]),
+            },
+            hasMore: true,
+        },
+    };
+}
+async function evaluate(id, item, config, checkpoint) {
+    if (item.root != null)
+        return "structural";
+    const itemType = type(item);
+    if (itemType == null)
+        return "structural";
+    const change = item.deleted != null
+        ? "deleted"
+        : createdAfter(item.createdDateTime, new Date(checkpoint.lastPolledAt))
+            ? "created"
+            : "updated";
+    if (!config.events.includes(change) || !config.itemTypes.includes(itemType))
+        return "filtered";
+    if (config.parentFolderId.length > 0 && item.parentReference?.id !== config.parentFolderId)
+        return "filtered";
+    if (config.itemId.length > 0 && id !== config.itemId)
+        return "filtered";
+    return await event(id, item, change, itemType, checkpoint.deltaToken);
+}
+function type(item) {
+    if (item.file != null)
+        return "file";
+    if (item.folder != null)
+        return "folder";
+    return item.deleted != null ? "file" : null;
+}
+async function event(id, item, change, itemType, deltaToken) {
+    // 同一轮分页共用删除事件标识，后续 delta 周期必须使用新标识。
+    return {
+        dedupeKey: item.deleted != null
+            ? await digestBytes(canonicalJsonBytes(["one-drive-deleted", deltaToken, id]))
+            : `${id}:${item.eTag ?? item.lastModifiedDateTime}`,
+        payload: {
+            changeType: change,
+            createdDateTime: item.createdDateTime ?? item.fileSystemInfo?.createdDateTime ?? null,
+            driveId: item.parentReference?.driveId ?? null,
+            eTag: item.eTag ?? null,
+            itemId: id,
+            itemType,
+            lastModifiedDateTime: item.lastModifiedDateTime ?? item.fileSystemInfo?.lastModifiedDateTime ?? null,
+            mimeType: item.file?.mimeType ?? null,
+            name: item.name ?? "",
+            parentFolderId: item.parentReference?.id ?? null,
+            size: item.size ?? null,
+            webUrl: item.webUrl ?? "",
+        },
+    };
+}
+async function get(context, endpoint, query) {
+    try {
+        return await context.connector.execute({ endpoint, method: "GET", query }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`OneDrive proxy request to ${endpoint} failed.`, { cause });
+    }
+}
+function deltaSuccess(result) {
+    if (result.status == 410)
+        throw new PermanentPollError("OneDrive delta token expired; recreate the Trigger.");
+    if (result.status == 404)
+        throw new PermanentPollError("OneDrive is not provisioned for this account.");
+    if (result.status == 400)
+        throw new PermanentPollError("OneDrive rejected the delta token; recreate the Trigger.");
+    success(result, "delta list");
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError(`OneDrive ${operation} rejected the Connection.`);
+    throw new TransientPollError(`OneDrive ${operation} failed with status ${result.status}.`);
+}
+function requireToken(link) {
+    const token = parseToken(link);
+    if (token == null)
+        throw new TransientPollError("OneDrive delta link has no token.");
+    return token;
+}
+function parseToken(link) {
+    const raw = /[?&]token=([^&#]+)/.exec(link)?.[1] ?? /\(token='([^']+)'\)/.exec(link)?.[1];
+    if (raw == null)
+        return null;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function createdAfter(value, boundary) {
+    if (value == null || value.length == 0)
+        return false;
+    const date = new Date(value);
+    return !Number.isNaN(date.getTime()) && date >= boundary;
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/oomol_console/permission-groups.d.ts

@@ -17,7 +17,16 @@ export type ConnectionActionPermission = {
     mode: "selected";
     actionNames: string[];
 };
+export type ConnectionTriggerPermission = {
+    mode: "all";
+} | {
+    mode: "none";
+} | {
+    mode: "selected";
+    triggerIds: string[];
+};
 interface PermissionGrant {
+    triggerPermission?: ConnectionTriggerPermission;
     actionPermission: ConnectionActionPermission;
     appAccessConfig?: JsonObject;
 }
@@ -50,6 +59,7 @@ export declare function toPermissionGroupsView(state: ConnectionPermissionGroups
         memberScope: "all";
         deletable: false;
         actionPermission: ConnectionActionPermission;
+        triggerPermission: ConnectionTriggerPermission;
     };
     groups: Array<{
         kind: "custom";
@@ -57,6 +67,8 @@ export declare function toPermissionGroupsView(state: ConnectionPermissionGroups
         name: string;
         memberIds: string[];
         actionPermission: ConnectionActionPermission;
+        triggerPermission: ConnectionTriggerPermission;
     }>;
 };
+export declare function effectiveTriggerPermission(grant: PermissionGrant): ConnectionTriggerPermission;
 export {};

package/src/providers/oomol_console/permission-groups.js

@@ -104,6 +104,7 @@ export function toPermissionGroupsView(state) {
             memberScope: "all",
             deletable: false,
             actionPermission: state.defaultGroup.actionPermission,
+            triggerPermission: effectiveTriggerPermission(state.defaultGroup),
         },
         groups: state.groups.map((group) => ({
             kind: "custom",
@@ -111,6 +112,7 @@ export function toPermissionGroupsView(state) {
             name: group.name,
             memberIds: group.memberIds,
             actionPermission: group.actionPermission,
+            triggerPermission: effectiveTriggerPermission(group),
         })),
     };
 }
@@ -131,7 +133,7 @@ function parseMultiPermissionGroups(rule, target, currentMemberIds) {
     const groupsById = new Map();
     for (const value of rule.permissionRules.rules) {
         if (!isPlainObject(value) ||
-            !hasOnlyKeys(value, ["id", "name", "actions", "appAccessConfig"]) ||
+            !hasOnlyKeys(value, ["id", "name", "actions", "triggers", "appAccessConfig"]) ||
             !isNonWhitespaceString(value.id) ||
             !isNonWhitespaceString(value.name)) {
             return invalidParseResult;
@@ -202,7 +204,7 @@ function parseLegacyPermissionGroups(policy, rule, target, currentMemberIds) {
 function parsePermissionGrant(value, service, strict, allowedExtraKeys = []) {
     if (!isPlainObject(value))
         return invalidParseResult;
-    if (strict && !hasOnlyKeys(value, [...allowedExtraKeys, "actions", "appAccessConfig"])) {
+    if (strict && !hasOnlyKeys(value, [...allowedExtraKeys, "actions", "triggers", "appAccessConfig"])) {
         return invalidParseResult;
     }
     let actionPermission = { mode: "all" };
@@ -233,6 +235,18 @@ function parsePermissionGrant(value, service, strict, allowedExtraKeys = []) {
         appAccessConfig = parsed.value;
     }
     const grant = { actionPermission };
+    if (Object.hasOwn(value, "triggers")) {
+        if (value.triggers === "*")
+            grant.triggerPermission = { mode: "all" };
+        else if (Array.isArray(value.triggers) &&
+            value.triggers.every((id) => isNonWhitespaceString(id) && id.startsWith(`${service}.`) && id !== `${service}.*`) &&
+            new Set(value.triggers).size === value.triggers.length) {
+            grant.triggerPermission =
+                value.triggers.length === 0 ? { mode: "none" } : { mode: "selected", triggerIds: value.triggers.toSorted() };
+        }
+        else
+            return invalidParseResult;
+    }
     if (appAccessConfig !== undefined)
         grant.appAccessConfig = appAccessConfig;
     return { ok: true, value: grant };
@@ -301,11 +315,17 @@ function normalizeLegacyLingxingUid(value) {
 }
 function buildPermissionGrant(grant) {
     const result = {};
+    if (grant.triggerPermission) {
+        const permission = grant.triggerPermission;
+        result.triggers =
+            permission.mode === "all" ? "*" : permission.mode === "none" ? [] : uniqueSorted(permission.triggerIds);
+    }
     if (grant.actionPermission.mode !== "all") {
         result.actions = grant.actionPermission.mode === "none" ? [] : uniqueSorted(grant.actionPermission.actionNames);
     }
-    if (grant.appAccessConfig !== undefined)
+    if (grant.appAccessConfig !== undefined) {
         result.appAccessConfig = structuredClone(grant.appAccessConfig);
+    }
     return result;
 }
 function normalizeActionPermission(permission) {
@@ -363,3 +383,8 @@ function isJsonValue(value) {
         return value.every(isJsonValue);
     return isPlainObject(value) && isJsonObject(value);
 }
+export function effectiveTriggerPermission(grant) {
+    return (grant.triggerPermission ?? {
+        mode: grant.actionPermission.mode === "all" && grant.appAccessConfig === undefined ? "all" : "none",
+    });
+}

package/src/providers/oomol_console/runtime.js

@@ -1,7 +1,7 @@
 import { optionalNumber, optionalRawString } from "../../core/cast.js";
 import { randomUUIDv7 } from "../../core/uuid-v7.js";
 import { ProviderRequestError } from "../provider-runtime.js";
-import { parseConnectionPermissionGroups, replacePermissionGroupMembers, serializeConnectionPermissionGroups, toPermissionGroupsView, } from "./permission-groups.js";
+import { effectiveTriggerPermission, parseConnectionPermissionGroups, replacePermissionGroupMembers, serializeConnectionPermissionGroups, toPermissionGroupsView, } from "./permission-groups.js";
 import { requestOomolConsole, requestOomolConsoleWithResponse } from "./request.js";
 const dayMs = 24 * 60 * 60 * 1000;
 const maxBalancePages = 100;
@@ -73,7 +73,6 @@ export async function executeOomolConsoleAction(actionName, input, context, fetc
         }
         case "list_team_connections": {
             const teamId = requireTeamId(context);
-            await requireTeamManager(teamId, apiKey, fetcher, deps.endpoints);
             return {
                 connections: await listTeamConnections(teamId, apiKey, fetcher, deps.endpoints),
             };
@@ -129,7 +128,7 @@ async function listTeamConnections(teamId, apiKey, fetcher, endpoints) {
     return asArray(await requestOomolConsole({
         endpoints,
         endpoint: "connector",
-        path: "/v1/connections",
+        path: "/v1/apps",
         apiKey,
         fetcher,
         teamId,
@@ -245,6 +244,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
     let affectedMemberIds;
     switch (actionName) {
         case "update_connection_default_permission_group":
+            state.defaultGroup.triggerPermission ??= effectiveTriggerPermission(state.defaultGroup);
+            if (input.triggerPermission !== undefined)
+                state.defaultGroup.triggerPermission = await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints);
             state.defaultGroup.actionPermission = parseActionPermissionInput(input.actionPermission, loaded.availableActions);
             break;
         case "create_connection_permission_group": {
@@ -253,6 +255,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
             const memberIds = parseMemberIdsInput(input.memberIds, loaded.members);
             state.groups.push({
                 groupId,
+                triggerPermission: input.triggerPermission === undefined
+                    ? { mode: "none" }
+                    : await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints),
                 name: requireString(input.name, "name"),
                 memberIds,
                 actionPermission: parseActionPermissionInput(input.actionPermission, loaded.availableActions),
@@ -269,6 +274,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
             updatedSourceGroupId = groupId;
             const memberIds = parseMemberIdsInput(input.memberIds, loaded.members);
             group.name = requireString(input.name, "name");
+            if (input.triggerPermission !== undefined)
+                group.triggerPermission = await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints);
+            group.triggerPermission ??= effectiveTriggerPermission(group);
             group.actionPermission = parseActionPermissionInput(input.actionPermission, loaded.availableActions);
             state = replacePermissionGroupMembers(state, groupId, memberIds);
             break;
@@ -680,3 +688,21 @@ function compact(value) {
 function invalidResponse(message) {
     return new ProviderRequestError(502, `OOMOL Console response is invalid: ${message}`);
 }
+async function parseTriggerPermissionInput(value, service, apiKey, fetcher, endpoints) {
+    const permission = asRecord(value, "triggerPermission");
+    if (permission.mode === "all" || permission.mode === "none")
+        return { mode: permission.mode };
+    if (permission.mode !== "selected" || !Array.isArray(permission.triggerIds) || permission.triggerIds.length === 0)
+        throw new ProviderRequestError(400, "triggerPermission is invalid", undefined, "invalid_input");
+    const available = asArray(await requestOomolConsole({
+        endpoints,
+        endpoint: "connector",
+        path: `/v1/providers/${encodeURIComponent(service)}/trigger-permissions`,
+        apiKey,
+        fetcher,
+    }), "Trigger permissions").map((item) => asRecord(item, "Trigger permission").id);
+    const triggerIds = permission.triggerIds.map((id) => requireString(id, "triggerId"));
+    if (new Set(triggerIds).size !== triggerIds.length || triggerIds.some((id) => !available.includes(id)))
+        throw new ProviderRequestError(400, "Trigger cannot be selected for this Connection", undefined, "invalid_input");
+    return { mode: "selected", triggerIds: triggerIds.toSorted() };
+}

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

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

package/src/providers/opper/executors.js

@@ -0,0 +1,89 @@
+import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "opper";
+const apiBaseUrl = "https://api.opper.ai/v3/compat";
+const anthropicApiVersion = "2023-06-01";
+// Reasoning model completions may exceed the shared default request timeout.
+const inferenceTimeoutMs = 300_000;
+const handlers = {
+    create_chat_completion(input, context) {
+        if (input.stream === true) {
+            throw providerInputError("stream=true is not supported by connector actions");
+        }
+        return requestOpper({ path: "/chat/completions", body: input }, context);
+    },
+    create_message(input, context) {
+        if (input.stream === true) {
+            throw providerInputError("stream=true is not supported by connector actions");
+        }
+        return requestOpper({ path: "/v1/messages", body: input }, context);
+    },
+    list_models(_input, context) {
+        return requestOpper({ path: "/models" }, context);
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: apiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestOpper({ path: "/models" }, { apiKey: input.apiKey, fetcher, signal });
+        return {
+            profile: { displayName: "Opper API Key" },
+            grantedScopes: [],
+            metadata: {
+                validationEndpoint: "/models",
+                availableModels: looseArray(payload.data)
+                    .map((model) => optionalString(optionalRecord(model)?.id))
+                    .filter((id) => id !== undefined),
+            },
+        };
+    },
+};
+function requestOpper(input, context) {
+    const headers = new Headers({
+        authorization: `Bearer ${context.apiKey}`,
+        "content-type": "application/json",
+        "user-agent": providerUserAgent,
+    });
+    // The Anthropic Messages-compatible endpoint takes the same header as Anthropic's API.
+    if (input.path === "/v1/messages") {
+        headers.set("anthropic-version", anthropicApiVersion);
+    }
+    return runProviderRequest({
+        signal: context.signal,
+        label: "Opper",
+        timeoutMs: input.body === undefined ? undefined : inferenceTimeoutMs,
+    }, async (signal) => {
+        const response = await context.fetcher(`${apiBaseUrl}${input.path}`, {
+            method: input.body === undefined ? "GET" : "POST",
+            headers,
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Opper returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : (text) => ({ message: text }),
+        });
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalString(optionalRecord(error?.error)?.message) ??
+                optionalString(error?.error) ??
+                optionalString(error?.message) ??
+                `Opper request failed with HTTP ${response.status}`;
+            throw new ProviderRequestError(response.status, message, payload, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "Opper response");
+        if (input.path === "/models" && !Array.isArray(result.data)) {
+            throw providerResponseError("Opper returned a malformed model list");
+        }
+        return result;
+    });
+}

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const proxy: ProviderProxyExecutor;
 interface OutlookRequestInput {
     accessToken: string;
@@ -13,4 +15,5 @@ interface OutlookRequestInput {
 export declare const executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
 export declare function outlookJsonRequest<T>(pathOrUrl: string, input: OutlookRequestInput): Promise<T>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/outlook/executors.js

@@ -1,6 +1,7 @@
-import { compactObject, requiredRecord } from "../../core/cast.js";
+import { compactObject, optionalString, requiredRecord } from "../../core/cast.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, } from "../provider-runtime.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "./microsoft-graph.js";
+import { outlookMessageReceived } from "./trigger-on-message-received.js";
 const outlookGraphBaseUrl = "https://graph.microsoft.com/v1.0";
 export const proxy = defineProviderProxy({
     service: "outlook",
@@ -373,12 +374,12 @@ function buildMailboxSettingsPayload(input) {
         automaticRepliesSetting: input.automaticRepliesSetting && typeof input.automaticRepliesSetting === "object"
             ? buildAutomaticRepliesSettingPayload(asObject(input.automaticRepliesSetting))
             : undefined,
-        dateFormat: typeof input.dateFormat === "string" ? input.dateFormat : undefined,
+        dateFormat: optionalString(input.dateFormat),
         delegateMeetingMessageDeliveryOptions: typeof input.delegateMeetingMessageDeliveryOptions === "string"
             ? input.delegateMeetingMessageDeliveryOptions
             : undefined,
         language: input.language && typeof input.language === "object" ? buildLanguagePayload(asObject(input.language)) : undefined,
-        timeFormat: typeof input.timeFormat === "string" ? input.timeFormat : undefined,
+        timeFormat: optionalString(input.timeFormat),
         timeZone: typeof input.timeZone === "string" ? input.timeZone : undefined,
         workingHours: input.workingHours && typeof input.workingHours === "object"
             ? buildWorkingHoursPayload(asObject(input.workingHours))
@@ -434,3 +435,4 @@ function requiredString(value, field) {
 function asObject(value) {
     return requiredRecord(value, "object input", (message) => new ProviderRequestError(400, message));
 }
+export const triggers = [outlookMessageReceived];

package/src/providers/outlook/trigger-on-message-received.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const outlookMessageReceived: PollDefinition;