@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/kaonavi/actions.js

@@ -0,0 +1,144 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { kaonaviAdditionalDefinitions } from "./additional-actions.js";
+const record = s.looseObject("Provider-defined record fields.", {});
+const empty = s.requiredObject("No input fields are required.", {});
+const updatedSince = s.string("Only records updated on or after this date (YYYY-MM-DD).", {
+    format: "date",
+});
+const getCalcType = s.boolean("Include calculation field types. Defaults to false.");
+const sheetId = s.integer("Sheet identifier.");
+const calcInput = s.object("Layout query options.", { getCalcType }, { optional: ["getCalcType"] });
+const updatedInput = s.object("Member query options.", { updatedSince }, { optional: ["updatedSince"] });
+const sheetLayout = s.looseObject("Sheet layout and custom field definitions.", {
+    id: sheetId,
+    name: s.string("Sheet name."),
+    record_type: s.integer("Zero for single-record sheets; one for multiple-record sheets."),
+    custom_fields: s.array("Custom field definitions.", record),
+});
+function collection(key, description) {
+    return s.looseObject(description, { [key]: s.array("Returned records.", record) });
+}
+export const kaonaviActionDefinitions = [
+    {
+        name: "list_members",
+        path: "/members",
+        description: "List employee records, optionally filtered by update date.",
+        inputSchema: updatedInput,
+        outputSchema: s.looseObject("Employee records and last update time.", {
+            updated_at: s.string("Last update timestamp."),
+            member_data: s.array("Employee records, including custom fields.", record),
+        }),
+    },
+    {
+        name: "get_member_layout",
+        path: "/member_layouts",
+        description: "Get employee field definitions and required-field settings.",
+        inputSchema: calcInput,
+        outputSchema: s.object("Employee field layout, keyed by native field names.", { custom_fields: s.array("Custom employee field definitions.", record) }, { required: [], additionalProperties: true }),
+    },
+    {
+        name: "list_sheet_layouts",
+        path: "/sheet_layouts",
+        description: "List accessible personnel sheet layouts and custom field definitions.",
+        inputSchema: calcInput,
+        outputSchema: s.looseObject("Available sheet layouts.", {
+            sheets: s.array("Sheet layouts.", sheetLayout),
+        }),
+    },
+    {
+        name: "get_sheet_layout",
+        path: "/sheet_layouts/{sheetId}",
+        description: "Get the field layout of a personnel sheet.",
+        inputSchema: s.object("Sheet layout query.", { sheetId, getCalcType }, { optional: ["getCalcType"] }),
+        outputSchema: sheetLayout,
+    },
+    {
+        name: "get_sheet",
+        path: "/sheets/{sheetId}",
+        description: "Get personnel sheet records, optionally filtered by member update date.",
+        inputSchema: s.object("Sheet data query.", { sheetId, updatedSince }, { optional: ["updatedSince"] }),
+        outputSchema: s.looseObject("Personnel sheet data.", {
+            id: sheetId,
+            name: s.string("Sheet name."),
+            record_type: s.integer("Zero for single-record sheets; one for multiple-record sheets."),
+            updated_at: s.string("Last update timestamp."),
+            member_data: s.array("Employee sheet records and custom field values.", record),
+        }),
+    },
+    {
+        name: "list_departments",
+        path: "/departments",
+        description: "List organizational departments and their parent relationships.",
+        inputSchema: empty,
+        outputSchema: collection("department_data", "Organization tree records."),
+    },
+    {
+        name: "list_users",
+        path: "/users",
+        description: "List Kaonavi login users and account settings.",
+        inputSchema: empty,
+        outputSchema: collection("user_data", "Login user records."),
+    },
+    {
+        name: "get_user",
+        path: "/users/{userId}",
+        description: "Get a Kaonavi login user by ID.",
+        inputSchema: s.requiredObject("User lookup.", { userId: s.integer("User identifier.") }),
+        outputSchema: s.looseObject("Login user and account settings.", {
+            id: s.integer("User identifier."),
+            email: s.string("Login email address."),
+            member_code: s.nullable(s.string("Linked employee code, or null.")),
+            last_login_at: s.nullable(s.string("Last login timestamp, or null.")),
+        }),
+    },
+    {
+        name: "list_roles",
+        path: "/roles",
+        description: "List available Kaonavi user roles.",
+        inputSchema: empty,
+        outputSchema: collection("role_data", "Available user roles."),
+    },
+    {
+        name: "list_enum_options",
+        path: "/enum_options",
+        description: "List master options for custom fields.",
+        inputSchema: empty,
+        outputSchema: collection("custom_field_data", "Custom fields and their master options."),
+    },
+    {
+        name: "get_enum_options",
+        path: "/enum_options/{customFieldId}",
+        description: "Get master options for one custom field.",
+        inputSchema: s.requiredObject("Custom field lookup.", {
+            customFieldId: s.integer("Custom field identifier."),
+        }),
+        outputSchema: s.looseObject("Master options for a custom field.", {
+            id: s.integer("Custom field identifier."),
+            name: s.string("Custom field name."),
+            sheet_name: s.string("Sheet name."),
+            enum_option_data: s.array("Master options.", record),
+        }),
+    },
+    {
+        name: "get_task",
+        path: "/tasks/{taskId}",
+        description: "Get the status and messages of an asynchronous Kaonavi task.",
+        inputSchema: s.requiredObject("Task lookup.", { taskId: s.integer("Task identifier.") }),
+        outputSchema: s.looseObject("Asynchronous task status.", {
+            id: s.integer("Task identifier."),
+            status: s.string("Task status: OK, NG, ERROR, WAITING, or RUNNING."),
+            messages: s.array("Task validation or execution messages.", s.string("Task message.")),
+        }),
+    },
+    ...kaonaviAdditionalDefinitions,
+];
+export const kaonaviActions = kaonaviActionDefinitions.map((definition) => defineProviderAction("kaonavi", {
+    name: definition.name,
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema,
+    operationType: definition.operationType ?? "read",
+    requiredScopes: [],
+    asyncLifecycle: definition.asyncLifecycle,
+}));

package/src/providers/kaonavi/additional-actions.d.ts

@@ -0,0 +1,10 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export interface KaonaviActionDefinition extends Pick<ActionDefinition, "name" | "description" | "inputSchema" | "outputSchema"> {
+    path: string;
+    method?: "GET" | "POST" | "PATCH" | "DELETE";
+    operationType?: ActionDefinition["operationType"];
+    asyncLifecycle?: ActionDefinition["asyncLifecycle"];
+    bodyField?: "members" | "users" | "user";
+    bodyWrapper?: "member_data" | "user_data";
+}
+export declare const kaonaviAdditionalDefinitions: KaonaviActionDefinition[];

package/src/providers/kaonavi/additional-actions.js

@@ -0,0 +1,203 @@
+import { s } from "../../core/json-schema.js";
+const dryRun = s.boolean("Validate without changing data. Defaults to false.");
+const sheetId = s.integer("Sheet identifier.");
+const customFieldId = s.integer("Custom field identifier.");
+const userId = s.integer("User identifier.");
+const code = s.nonEmptyString("Employee code.");
+const fields = s.array("Custom field values; consult the field layout for types and allowed values.", s.requiredObject("Custom field value.", {
+    id: s.integer("Custom field identifier."),
+    values: s.array("Field values; multiple values are supported only for checkboxes. Use an empty string to clear a value.", s.string("Field value.")),
+}));
+const department = s.requiredObject("Department assignment; use a code from list_departments.", {
+    code: s.string("Department code; an empty string clears the assignment."),
+});
+const member = s.object("Employee fields; required fields and allowed values depend on get_member_layout. Omitted fields remain unchanged during updates.", {
+    code,
+    name: s.string("Employee name."),
+    name_kana: s.string("Phonetic employee name."),
+    mail: s.string("Employee email address."),
+    entered_date: s.string("Employment start date, or an empty string to clear it."),
+    retired_date: s.string("Employment end date, or an empty string to clear it."),
+    gender: s.string("Gender value from the employee layout."),
+    birthday: s.string("Birth date, or an empty string to clear it."),
+    department,
+    sub_departments: s.array("Secondary department assignments.", department),
+    custom_fields: fields,
+}, { required: ["code"] });
+const sheetMember = s.requiredObject("Sheet records for an employee.", {
+    code,
+    records: s.array("Ordered records. For a multiple-record sheet update, provide the complete replacement set for this employee; append uses only the new records.", s.object("Sheet record.", { custom_fields: fields }, { required: [] })),
+});
+const userFields = {
+    email: s.string("Login email address."),
+    member_code: s.string("Linked employee code."),
+    password: s.string("Login password."),
+    role: s.requiredObject("User role.", { id: s.integer("Role identifier from list_roles.") }),
+    is_active: s.boolean("Whether the account is enabled; false disables login."),
+    password_locked: s.boolean("Whether password login is locked."),
+    use_smartphone: s.boolean("Whether smartphone browser access is enabled."),
+    use_native_app: s.boolean("Whether native mobile app access is enabled."),
+};
+const createUser = s.object("New login user. Unspecified account settings use Kaonavi defaults; secure access cannot be configured through this API.", userFields, { required: ["email", "member_code", "password", "role"] });
+const updateUser = {
+    ...s.object("User fields to update; omitted fields remain unchanged. Secure access cannot be changed through this API.", userFields, { required: [] }),
+    minProperties: 1,
+};
+const userOutput = s.looseObject("Created or updated login user.", {
+    id: userId,
+    email: s.string("Login email address."),
+    member_code: s.nullable(s.string("Linked employee code, or null.")),
+    role: s.looseObject("Assigned role.", {
+        id: s.integer("Role identifier."),
+        name: s.string("Role name."),
+        type: s.string("Role type."),
+    }),
+    is_active: s.boolean("Whether the account is enabled."),
+    password_locked: s.boolean("Whether password login is locked."),
+    use_smartphone: s.boolean("Whether smartphone browser access is enabled."),
+    use_native_app: s.boolean("Whether native mobile app access is enabled."),
+});
+const task = s.looseObject("Submitted asynchronous task; use get_task to check completion. A successful submission does not mean the mutation has completed.", { task_id: s.integer("Submitted task identifier.") });
+const updatedSince = s.string("Only files updated on or after this date (YYYY-MM-DD).", {
+    format: "date",
+});
+const fileFields = {
+    file_name: s.string("File name."),
+    download_url: s.string("Signed download URL, valid for 15 minutes after issuance."),
+    updated_at: s.string("Last file update timestamp."),
+};
+export const kaonaviAdditionalDefinitions = [
+    ...[
+        [
+            "create_members",
+            "POST",
+            "Create employees with their basic fields and department assignments. Consult get_member_layout for required fields.",
+        ],
+        [
+            "update_members",
+            "PATCH",
+            "Update only the supplied employee fields. Omitted fields remain unchanged; use an empty string to clear a value.",
+        ],
+    ].map(([name, method, description]) => ({
+        name,
+        method,
+        description,
+        path: "/members",
+        operationType: "write",
+        bodyField: "members",
+        bodyWrapper: "member_data",
+        inputSchema: s.object("Employee mutation request.", { members: s.array("Employees to create or update.", member, { minItems: 1 }), dryRun }, { optional: ["dryRun"] }),
+        outputSchema: task,
+        asyncLifecycle: { startActionId: `kaonavi.${name}`, statusActionId: "kaonavi.get_task" },
+    })),
+    ...[
+        [
+            "update_sheet",
+            "PATCH",
+            "/sheets/{sheetId}",
+            "Update a personnel sheet. Single-record sheets preserve omitted fields; multiple-record sheets replace the entire record set for each supplied employee. Other employees remain unchanged.",
+        ],
+        [
+            "append_sheet_records",
+            "POST",
+            "/sheets/{sheetId}/add",
+            "Append records to a multiple-record personnel sheet. Single-record sheets are not supported.",
+        ],
+    ].map(([name, method, path, description]) => ({
+        name,
+        method,
+        path,
+        description,
+        operationType: "write",
+        bodyField: "members",
+        bodyWrapper: "member_data",
+        inputSchema: s.object("Personnel sheet mutation request.", {
+            sheetId,
+            members: s.array("Employee sheet records.", sheetMember, { minItems: 1 }),
+            dryRun,
+        }, { optional: ["dryRun"] }),
+        outputSchema: task,
+        asyncLifecycle: { startActionId: `kaonavi.${name}`, statusActionId: "kaonavi.get_task" },
+    })),
+    {
+        name: "create_user",
+        method: "POST",
+        path: "/users",
+        operationType: "write",
+        description: "Create a Kaonavi login user linked to an employee.",
+        bodyField: "user",
+        inputSchema: s.object("User creation request.", { user: createUser, dryRun }, { optional: ["dryRun"] }),
+        outputSchema: userOutput,
+    },
+    {
+        name: "update_user",
+        method: "PATCH",
+        path: "/users/{userId}",
+        operationType: "destructive",
+        description: "Update a login user, including role, password, access settings, or disabling the account. Omitted fields remain unchanged.",
+        bodyField: "user",
+        inputSchema: s.object("User update request.", { userId, user: updateUser, dryRun }, { optional: ["dryRun"] }),
+        outputSchema: userOutput,
+    },
+    {
+        name: "delete_user",
+        method: "DELETE",
+        path: "/users/{userId}",
+        operationType: "destructive",
+        description: "Delete a Kaonavi login user.",
+        inputSchema: s.requiredObject("User deletion request.", { userId }),
+        outputSchema: s.requiredObject("Deletion result.", {
+            success: s.boolean("Whether the user was deleted."),
+        }),
+    },
+    {
+        name: "create_users",
+        method: "POST",
+        path: "/users/bulk",
+        operationType: "write",
+        description: "Create multiple Kaonavi login users asynchronously.",
+        bodyField: "users",
+        bodyWrapper: "user_data",
+        inputSchema: s.object("Bulk user creation request.", { users: s.array("Users to create.", createUser, { minItems: 1 }), dryRun }, { optional: ["dryRun"] }),
+        outputSchema: task,
+        asyncLifecycle: { startActionId: "kaonavi.create_users", statusActionId: "kaonavi.get_task" },
+    },
+    {
+        name: "update_users",
+        method: "PATCH",
+        path: "/users/bulk",
+        operationType: "destructive",
+        description: "Update multiple login users asynchronously, including disabling accounts. Omitted fields remain unchanged.",
+        bodyField: "users",
+        bodyWrapper: "user_data",
+        inputSchema: s.object("Bulk user update request.", {
+            users: s.array("Users to update, identified by user ID.", s.object("User update fields.", { id: userId, ...userFields }, { required: ["id"] }), { minItems: 1 }),
+            dryRun,
+        }, { optional: ["dryRun"] }),
+        outputSchema: task,
+        asyncLifecycle: { startActionId: "kaonavi.update_users", statusActionId: "kaonavi.get_task" },
+    },
+    {
+        name: "list_member_photo_urls",
+        path: "/members/face_image",
+        operationType: "read",
+        description: "Get employee photo download URLs. Links expire after 15 minutes; request new URLs when needed.",
+        inputSchema: s.object("Employee photo query.", { updatedSince }, { optional: ["updatedSince"] }),
+        outputSchema: s.looseObject("Employee photo download links.", {
+            member_data: s.array("Employee photos.", s.looseObject("Employee photo.", { code, ...fileFields })),
+        }),
+    },
+    {
+        name: "list_sheet_file_urls",
+        path: "/sheets/{sheetId}/custom_fields/{customFieldId}/file",
+        operationType: "read",
+        description: "Get download URLs for files in a sheet attachment field. Only records containing files are returned. Links expire after 15 minutes.",
+        inputSchema: s.object("Sheet attachment query.", { sheetId, customFieldId, updatedSince }, { optional: ["updatedSince"] }),
+        outputSchema: s.looseObject("Sheet attachment download links.", {
+            member_data: s.array("Employee attachments.", s.looseObject("Employee attachment records.", {
+                code,
+                records: s.array("Attached files.", s.looseObject("Attached file.", fileFields)),
+            })),
+        }),
+    },
+];

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

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

package/src/providers/kaonavi/executors.js

@@ -0,0 +1,69 @@
+import { defineProviderExecutors, defineProviderProxy, requireCustomCredential, runProviderRequest, ProviderRequestError, } from "../provider-runtime.js";
+import { kaonaviActionDefinitions } from "./actions.js";
+import { getKaonaviToken, kaonaviBaseUrl, readKaonaviResponse } from "./runtime.js";
+export const executors = defineProviderExecutors({
+    service: "kaonavi",
+    async createContext(context, fetcher) {
+        const credential = await requireCustomCredential(context, "kaonavi");
+        return { values: credential.values, fetcher, signal: context.signal };
+    },
+    handlers: Object.fromEntries(kaonaviActionDefinitions.map((definition) => [
+        definition.name,
+        async (data, context) => {
+            let path = definition.path;
+            for (const key of ["sheetId", "customFieldId", "userId", "taskId"]) {
+                if (data[key] !== undefined)
+                    path = path.replace(`{${key}}`, encodeURIComponent(String(data[key])));
+            }
+            const url = new URL(kaonaviBaseUrl + path);
+            if (data.updatedSince !== undefined)
+                url.searchParams.set("updated_since", String(data.updatedSince));
+            if (data.getCalcType !== undefined)
+                url.searchParams.set("get_calc_type", String(data.getCalcType));
+            const bodyValue = definition.bodyField ? data[definition.bodyField] : undefined;
+            const body = bodyValue === undefined
+                ? undefined
+                : JSON.stringify(definition.bodyWrapper ? { [definition.bodyWrapper]: bodyValue } : bodyValue);
+            const token = await getKaonaviToken(context.values, context.fetcher, context.signal);
+            return runProviderRequest({ label: "Kaonavi", signal: context.signal }, async (signal) => {
+                const headers = new Headers({ "Kaonavi-Token": token, accept: "application/json" });
+                if (body !== undefined)
+                    headers.set("content-type", "application/json");
+                if (data.dryRun !== undefined)
+                    headers.set("Dry-Run", data.dryRun ? "1" : "0");
+                const response = await context.fetcher(url, { method: definition.method ?? "GET", headers, body, signal });
+                if (definition.method === "DELETE" && response.status === 204)
+                    return { success: true };
+                return readKaonaviResponse(response);
+            });
+        },
+    ])),
+});
+export const credentialValidators = {
+    async customCredential(input, { fetcher, signal }) {
+        await getKaonaviToken(input.values, fetcher, signal, true);
+        return { profile: { displayName: "Kaonavi Account" }, grantedScopes: [] };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "kaonavi",
+    baseUrl: kaonaviBaseUrl,
+    auth: { type: "none" },
+    sensitiveHeaders: ["Kaonavi-Token"],
+    async customizeRequest({ context, fetcher, headers }) {
+        const credential = await requireCustomCredential(context, "kaonavi");
+        headers.set("Kaonavi-Token", await getKaonaviToken(credential.values, fetcher, context.signal));
+        headers.set("accept", "application/json");
+    },
+    async readError(response) {
+        try {
+            await readKaonaviResponse(response);
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError)
+                return error;
+            throw error;
+        }
+        return new ProviderRequestError(response.status, "Kaonavi request failed", undefined, "provider_error");
+    },
+});

package/src/providers/kaonavi/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderFetch } from "../provider-runtime.ts";
+export declare const kaonaviBaseUrl = "https://api.kaonavi.jp/api/v2.0";
+export declare function readKaonaviResponse(response: Response): Promise<Record<string, unknown>>;
+export declare function getKaonaviToken(values: Record<string, string>, fetcher: ProviderFetch, signal?: AbortSignal, fresh?: boolean): Promise<string>;

package/src/providers/kaonavi/runtime.js

@@ -0,0 +1,69 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { looseArray, recordOrEmpty, optionalString, optionalNumber } from "../../core/cast.js";
+import { basicAuthorizationHeader, isAbortLikeError, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
+export const kaonaviBaseUrl = "https://api.kaonavi.jp/api/v2.0";
+const tokens = new Map();
+export async function readKaonaviResponse(response) {
+    const code = response.status === 429 ? "rate_limited" : "provider_error";
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (error) {
+        if (isAbortLikeError(error))
+            throw error;
+        throw new ProviderRequestError(response.ok ? 502 : response.status, "Kaonavi returned a non-JSON response", undefined, code);
+    }
+    if (!response.ok) {
+        const messages = looseArray(recordOrEmpty(payload).errors).map(optionalString).filter(Boolean);
+        throw new ProviderRequestError(response.status, messages.join("; ") || `Kaonavi request failed (${response.status})`, undefined, code);
+    }
+    return requiredResponseRecord(payload, "Kaonavi response");
+}
+export async function getKaonaviToken(values, fetcher, signal, fresh = false) {
+    const key = requiredInputString(values.consumerKey, "consumerKey");
+    const secret = requiredInputString(values.consumerSecret, "consumerSecret");
+    if (key.includes(":"))
+        throw providerInputError("consumerKey must not contain a colon");
+    const cacheKey = sha256Hex(JSON.stringify([key, secret]));
+    const existing = fresh ? undefined : tokens.get(cacheKey);
+    if (existing) {
+        const token = await existing;
+        if (token.expiresAt > Date.now())
+            return token.value;
+        if (tokens.get(cacheKey) !== existing)
+            return getKaonaviToken(values, fetcher, signal);
+    }
+    const pending = runProviderRequest({ label: "Kaonavi token", signal }, async (requestSignal) => {
+        const response = await fetcher(`${kaonaviBaseUrl}/token`, {
+            method: "POST",
+            signal: requestSignal,
+            headers: {
+                authorization: basicAuthorizationHeader(`${key}:${secret}`),
+                "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+                accept: "application/json",
+            },
+            body: new URLSearchParams({ grant_type: "client_credentials" }).toString(),
+        });
+        const payload = await readKaonaviResponse(response);
+        const value = optionalString(payload.access_token);
+        const ttl = optionalNumber(payload.expire_in);
+        if (!value?.trim() || ttl === undefined || !Number.isFinite(ttl) || ttl <= 0)
+            throw providerResponseError("Kaonavi token response is missing a valid access_token or expire_in");
+        return { value, expiresAt: Date.now() + Math.max(0, ttl * 1000 - 60_000) };
+    });
+    tokens.set(cacheKey, pending);
+    if (tokens.size > 1024) {
+        const oldest = tokens.keys().next().value;
+        if (oldest !== undefined)
+            tokens.delete(oldest);
+    }
+    try {
+        return (await pending).value;
+    }
+    catch (error) {
+        if (tokens.get(cacheKey) === pending)
+            tokens.delete(cacheKey);
+        throw error;
+    }
+}

package/src/providers/keenable/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/keenable/executors.js

@@ -0,0 +1,20 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { createKeenableContext, keenableActionHandlers, keenableApiBaseUrl, keenableAppTitle, validateKeenableCredential, } from "./runtime.js";
+const service = "keenable";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: keenableActionHandlers,
+    createContext: createKeenableContext,
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: keenableApiBaseUrl,
+    auth: { type: "optional_api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("x-keenable-title"))
+            headers.set("x-keenable-title", keenableAppTitle);
+    },
+});
+export const credentialValidators = { apiKey: validateKeenableCredential };

package/src/providers/keenable/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { CredentialValidationResult, ExecutionContext } from "../../core/types.ts";
+import type { ProviderFetch } from "../provider-runtime.ts";
+export declare const keenableApiBaseUrl = "https://api.keenable.ai";
+/** Keenable requires keyless callers to name their app in the X-Keenable-Title header. */
+export declare const keenableAppTitle = "OpenConnector";
+interface KeenableContext {
+    apiKey?: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type KeenableActionHandler = (input: Record<string, unknown>, context: KeenableContext) => Promise<unknown>;
+export declare const keenableActionHandlers: Record<string, KeenableActionHandler>;
+/**
+ * Build the action context. A no_auth connection has no key and uses the keyless endpoints.
+ */
+export declare function createKeenableContext(context: ExecutionContext, fetcher: ProviderFetch): Promise<KeenableContext>;
+/**
+ * Validate a key through a one-result search on the keyed endpoint.
+ */
+export declare function validateKeenableCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+export {};

package/src/providers/keenable/runtime.js

@@ -0,0 +1,89 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { parseProviderJsonBodyText, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredResponseRecord, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const keenableApiBaseUrl = "https://api.keenable.ai";
+/** Keenable requires keyless callers to name their app in the X-Keenable-Title header. */
+export const keenableAppTitle = "OpenConnector";
+export const keenableActionHandlers = {
+    search(input, context) {
+        return requestKeenable({
+            context,
+            method: "POST",
+            path: context.apiKey ? "/v1/search" : "/v1/search/public",
+            body: input,
+        });
+    },
+    fetch(input, context) {
+        const query = Object.fromEntries(Object.entries(input)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, String(value)]));
+        return requestKeenable({ context, method: "GET", path: context.apiKey ? "/v1/fetch" : "/v1/fetch/public", query });
+    },
+};
+/**
+ * Build the action context. A no_auth connection has no key and uses the keyless endpoints.
+ */
+export async function createKeenableContext(context, fetcher) {
+    const credential = await context.getCredential("keenable");
+    return {
+        apiKey: credential?.authType === "api_key" ? credential.apiKey : undefined,
+        fetcher,
+        signal: context.signal,
+    };
+}
+/**
+ * Validate a key through a one-result search on the keyed endpoint.
+ */
+export async function validateKeenableCredential(input, options) {
+    await requestKeenable({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        method: "POST",
+        path: "/v1/search",
+        body: { query: "Keenable", max_results: 1 },
+    });
+    return {
+        profile: { displayName: "Keenable API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: keenableApiBaseUrl, validationEndpoint: "/v1/search" },
+    };
+}
+async function requestKeenable(request) {
+    const { context } = request;
+    const url = new URL(request.path, keenableApiBaseUrl);
+    setSearchParams(url, request.query ?? {});
+    const headers = new Headers({
+        accept: "application/json",
+        "user-agent": providerUserAgent,
+        "x-keenable-title": keenableAppTitle,
+    });
+    if (context.apiKey)
+        headers.set("x-api-key", context.apiKey);
+    if (request.body)
+        headers.set("content-type", "application/json");
+    return runProviderRequest({ signal: context.signal, label: "Keenable" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: request.method,
+            headers,
+            body: request.body ? JSON.stringify(request.body) : undefined,
+            signal,
+        });
+        if (!response.ok) {
+            throw await readKeenableError(response);
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "Keenable response"), {
+            emptyBody: {},
+            invalidJsonMessage: "Keenable returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "Keenable response");
+    });
+}
+async function readKeenableError(response) {
+    const status = response.status;
+    const body = optionalRecord(parseProviderJsonBodyText(await readProviderErrorTextBody(response, "Keenable error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "Keenable returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    }));
+    const message = optionalString(body?.message) ?? optionalString(body?.error) ?? `Keenable request failed with HTTP ${status}`;
+    const details = withRetryAfterSeconds(response, body ?? {});
+    return new ProviderRequestError(status, message, details, status === 429 ? "rate_limited" : "provider_error");
+}

package/src/providers/kolsprite_mcp/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const kolspriteMcpActions: readonly ActionDefinition[];