@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -2,11 +2,16 @@ import type { CredentialValidators, ProviderExecutors } from "../../core/types.t
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 export declare const slackApiBaseUrl = "https://slack.com/api";
-type SlackActionContext = Omit<OAuthProviderContext, "providerSecret" | "tokenType">;
+interface SlackActionContext extends Omit<OAuthProviderContext, "providerSecret" | "tokenType"> {
+    /** Stored OAuth response metadata; empty for API-key credentials. */
+    metadata: Record<string, unknown>;
+}
 type SlackOAuthTokenKind = "bot" | "user";
 export type SlackActionHandler = (input: Record<string, unknown>, context: SlackActionContext) => Promise<unknown>;
 /** Build Slack executors that reject credentials issued for the other authorization path. */
 export declare function defineSlackProviderExecutors(service: "slack" | "slackbot", tokenKind: SlackOAuthTokenKind, handlers: Record<string, SlackActionHandler>): ProviderExecutors;
 export declare const slackActionHandlers: ProviderActionHandlers<"slack", SlackActionHandler>;
 export declare const slackCredentialValidators: CredentialValidators;
+/** Read the workspace and installer from stored OAuth metadata. */
+export declare function slackbotInstallationHandler(_input: Record<string, unknown>, context: SlackActionContext): Promise<unknown>;
 export {};

package/src/providers/slack/runtime.js

@@ -12,11 +12,13 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
         async createContext(context, fetcher) {
             const credential = await context.getCredential(service);
             let accessToken;
+            let metadata = {};
             if (credential?.authType === "oauth2") {
                 if (readSlackTokenKind(credential.accessToken, credential.metadata) != tokenKind) {
                     throw new ProviderRequestError(401, `Reconnect ${service} with ${tokenKind} authorization before running its actions.`);
                 }
                 accessToken = credential.accessToken;
+                metadata = credential.metadata;
             }
             else if (credential?.authType === "api_key") {
                 // A pasted token was authorized by no OAuth flow, so the user/bot flow
@@ -31,6 +33,7 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
             const providerContext = {
                 accessToken,
                 fetcher,
+                metadata,
                 signal: context.signal,
             };
             if (context.transitFiles) {
@@ -176,6 +179,24 @@ async function slackGetCurrentUser(context) {
     const identity = readSlackAuthTestIdentity(await slackAuthTest(context));
     return { teamId: identity.teamId, userId: identity.userId, isBot: identity.botId !== undefined };
 }
+/** Read the workspace and installer from stored OAuth metadata. */
+export async function slackbotInstallationHandler(_input, context) {
+    const team = optionalRecord(context.metadata.team);
+    const authedUser = optionalRecord(context.metadata.authed_user);
+    const teamId = optionalString(team?.id);
+    const authedUserId = optionalString(authedUser?.id);
+    const botUserId = optionalString(context.metadata.bot_user_id);
+    if (!teamId || !authedUserId || !botUserId) {
+        return null;
+    }
+    return {
+        teamId,
+        teamName: optionalString(team?.name) ?? null,
+        authedUserId,
+        botUserId,
+        appId: optionalString(context.metadata.app_id) ?? null,
+    };
+}
 async function slackListChannels(input, context) {
     const url = slackApiUrl("conversations.list");
     if (input.limit != null) {

package/src/providers/slackbot/actions.js

@@ -1,7 +1,8 @@
+import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
 import { slackActions } from "../slack/actions.js";
 const service = "slackbot";
-export const slackbotActions = slackActions
+const sharedActions = slackActions
     .filter((action) => action.name != "search_messages" && action.name != "search_context" && action.name != "get_current_user")
     .map((action) => defineProviderAction(service, {
     name: action.name,
@@ -11,3 +12,18 @@ export const slackbotActions = slackActions
     inputSchema: action.inputSchema,
     outputSchema: action.outputSchema,
 }));
+const getInstallation = defineProviderAction(service, {
+    name: "get_installation",
+    operationType: "read",
+    description: "Get the workspace and authorizing user from stored OAuth metadata. This information is available only for OAuth connections. Returns null for API-key connections or incomplete OAuth metadata. OAuth credentials may be refreshed before execution.",
+    requiredScopes: [],
+    inputSchema: s.object({}),
+    outputSchema: s.nullable(s.object({
+        teamId: s.nonEmptyString("The Slack workspace ID the app was installed in."),
+        teamName: s.nullable(s.string({ description: "The workspace display name, when the install carried one." })),
+        authedUserId: s.nonEmptyString("The Slack user ID of the person who approved the install."),
+        botUserId: s.nonEmptyString("The Slack user ID of the app's bot user."),
+        appId: s.nullable(s.string({ description: "The Slack app ID, when the install carried one." })),
+    }, { required: ["teamId", "teamName", "authedUserId", "botUserId", "appId"] })),
+});
+export const slackbotActions = [...sharedActions, getInstallation];

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

@@ -1,3 +1,5 @@
 import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/slackbot/executors.js

@@ -1,8 +1,11 @@
 import { getProviderActionHandler, mapProviderActionHandlers } from "../provider-runtime.js";
-import { defineSlackProviderExecutors, slackActionHandlers, slackCredentialValidators } from "../slack/runtime.js";
+import { defineSlackProviderExecutors, slackActionHandlers, slackbotInstallationHandler, slackCredentialValidators, } from "../slack/runtime.js";
 import { slackbotActions } from "./actions.js";
+import { slackBotEvents } from "./trigger-on-event.js";
 const service = "slackbot";
 const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotActions, (action) => {
+    if (action.name === "get_installation")
+        return slackbotInstallationHandler;
     const handler = getProviderActionHandler(slackActionHandlers, action.name);
     if (!handler) {
         throw new Error(`Missing shared Slack handler for action: ${action.name}`);
@@ -11,3 +14,4 @@ const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotAction
 });
 export const executors = defineSlackProviderExecutors(service, "bot", slackbotActionHandlers);
 export const credentialValidators = slackCredentialValidators;
+export const triggers = [slackBotEvents];

package/src/providers/slackbot/trigger-on-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const slackBotEvents: IntegrationDefinition;

package/src/providers/slackbot/trigger-on-event.definition.d.ts

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

package/src/providers/slackbot/trigger-on-event.definition.js

@@ -0,0 +1,57 @@
+export const snapshot = {
+    key: "slackbot.on_event",
+    provider: "slackbot",
+    name: "on_event",
+    displayName: "Mention or Direct Message",
+    description: "Receives user mentions and new direct messages through a shared Slack application event source. Slack Connect events are excluded.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: ["app_mention", "message.im"] },
+                minItems: 1,
+                maxItems: 2,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["app_mention", "message.im"],
+        },
+        {
+            handle: "channelIds",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                maxItems: 100,
+                uniqueItems: true,
+                title: "Channel IDs",
+            },
+            nullable: true,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "appId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "teamId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "channel", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "user", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "text", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "ts", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "threadTs", jsonSchema: { type: "string" }, nullable: true },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/slackbot/trigger-on-event.js

@@ -0,0 +1,23 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { slackApplication } from "../../triggers/sources/slack.js";
+import { snapshot } from "./trigger-on-event.definition.js";
+export const slackBotEvents = {
+    snapshot,
+    eventSource: "slack",
+    source: slackApplication,
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Slack event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Slack event sources.");
+    },
+};

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

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

package/src/providers/smarthr/actions.js

@@ -0,0 +1,286 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { smarthrSupplementalActions } from "./supplemental-actions.js";
+export const smarthrActions = [
+    ...smarthrSupplementalActions,
+    defineProviderAction("smarthr", {
+        name: "list_employees",
+        description: "List SmartHR employees with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing employees.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            employeeCode: s.string("Filter by employee number."),
+            employmentTypeIds: s.array("Filter by employment type IDs.", s.string("One identifier or field name.", { minLength: 1 }), { minItems: 1 }),
+            employmentStatus: s.stringEnum("Filter by employment status.", ["employed", "absent", "retired"]),
+            gender: s.stringEnum("Filter by legal gender.", ["male", "female"]),
+            sort: s.string("Sort fields separated by commas; prefix a field with - for descending order."),
+            userIds: s.array("Filter by user IDs.", s.string("One identifier or field name.", { minLength: 1 }), {
+                minItems: 1,
+            }),
+            departmentIds: s.array("Filter by department IDs.", s.string("One identifier or field name.", { minLength: 1 }), { minItems: 1 }),
+            positionIds: s.array("Filter by position IDs.", s.string("One identifier or field name.", { minLength: 1 }), {
+                minItems: 1,
+            }),
+            employeeIds: s.array("Filter by employee IDs.", s.string("One identifier or field name.", { minLength: 1 }), {
+                minItems: 1,
+            }),
+            fields: s.array("Employee field names to return. Omit to use the upstream default.", s.string("One identifier or field name.", { minLength: 1 }), { minItems: 1 }),
+            query: s.string("Search names, business names, departments, and positions."),
+            preferBusinessName: s.boolean("Prefer business names when searching."),
+            enteredAtFrom: s.string("Joined on or after this date.", { format: "date" }),
+            enteredAtTo: s.string("Joined on or before this date.", { format: "date" }),
+            resignedAtFrom: s.string("Resigned on or after this date.", { format: "date" }),
+            resignedAtTo: s.string("Resigned on or before this date.", { format: "date" }),
+        }, { required: [] }),
+        outputSchema: s.object("One page of employees.", {
+            employees: s.array("Returned employees.", s.object("Employee data; fields depend on the token permissions and requested fields.", {
+                id: s.string("Employee ID."),
+                emp_code: s.string("Employee number."),
+                last_name: s.string("Family name."),
+                first_name: s.string("Given name."),
+                emp_status: s.string("Employment status."),
+            }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["employees", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_companies",
+        description: "List SmartHR companies with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing companies.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            embed: s.stringEnum("Optionally include the company owner.", ["owner"]),
+        }, { required: [] }),
+        outputSchema: s.object("One page of companies.", {
+            companies: s.array("Returned companies.", s.object("Company information.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["companies", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_departments",
+        description: "List SmartHR departments with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing departments.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            code: s.string("Filter by department code."),
+            sort: s.string("Sort fields separated by commas; prefix a field with - for descending order."),
+        }, { required: [] }),
+        outputSchema: s.object("One page of departments.", {
+            departments: s.array("Returned departments.", s.object("Department data, including any nested hierarchy returned by SmartHR.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["departments", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_employment_types",
+        description: "List SmartHR employment types with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing employment types.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+        }, { required: [] }),
+        outputSchema: s.object("One page of employment types.", {
+            employmentTypes: s.array("Returned employment types.", s.object("Employment type information.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["employmentTypes", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_custom_fields",
+        description: "List SmartHR custom employee fields with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing custom employee fields.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            embed: s.stringEnum("Include the field group instead of group_id.", ["group"]),
+        }, { required: [] }),
+        outputSchema: s.object("One page of custom employee fields.", {
+            customFields: s.array("Returned custom employee fields.", s.object("Custom field definition, including type and dropdown elements when available.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["customFields", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_custom_field_groups",
+        description: "List SmartHR custom employee field groups with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing custom employee field groups.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            embed: s.stringEnum("Include the templates belonging to each group.", ["templates"]),
+        }, { required: [] }),
+        outputSchema: s.object("One page of custom employee field groups.", {
+            customFieldGroups: s.array("Returned custom employee field groups.", s.object("Custom field group information.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["customFieldGroups", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "list_business_establishments",
+        description: "List SmartHR business establishments with pagination.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for listing business establishments.", {
+            page: s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 }),
+            perPage: s.integer("Results per page, from 1 to 100. Defaults to 10.", {
+                minimum: 1,
+                maximum: 100,
+            }),
+            embed: s.stringEnum("Related object to include in the response.", [
+                "soc_ins_owner",
+                "lab_ins_owner",
+                "company",
+            ]),
+        }, { required: [] }),
+        outputSchema: s.object("One page of business establishments.", {
+            businessEstablishments: s.array("Returned business establishments.", s.object("Business establishment information.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true })),
+            page: s.integer("Requested page number."),
+            perPage: s.integer("Requested page size."),
+            totalCount: s.nullable(s.integer("Total matching records from x-total-count, or null when unavailable.")),
+            nextPage: s.nullable(s.integer("Next page number from the Link header, or null when no next link is provided.")),
+        }, { required: ["businessEstablishments", "page", "perPage", "totalCount", "nextPage"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "get_employee",
+        description: "Get a SmartHR employee by ID.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Resource lookup parameters.", {
+            employeeId: s.string("The employee ID.", { minLength: 1 }),
+            fields: s.array("Employee field names to return. Omit to use the upstream default.", s.string("One identifier or field name.", { minLength: 1 }), { minItems: 1 }),
+        }, { required: ["employeeId"] }),
+        outputSchema: s.object("Requested resource.", {
+            employee: s.object("Employee data; fields depend on the token permissions and requested fields.", {
+                id: s.string("Employee ID."),
+                emp_code: s.string("Employee number."),
+                last_name: s.string("Family name."),
+                first_name: s.string("Given name."),
+                emp_status: s.string("Employment status."),
+            }, { required: [], additionalProperties: true }),
+        }, { required: ["employee"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "get_department",
+        description: "Get a SmartHR department by ID.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Resource lookup parameters.", { departmentId: s.string("The department ID.", { minLength: 1 }) }, { required: ["departmentId"] }),
+        outputSchema: s.object("Requested resource.", {
+            department: s.object("Department data, including any nested hierarchy returned by SmartHR.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true }),
+        }, { required: ["department"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "get_employment_type",
+        description: "Get a SmartHR employment type by ID.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Resource lookup parameters.", { employmentTypeId: s.string("The employment type ID.", { minLength: 1 }) }, { required: ["employmentTypeId"] }),
+        outputSchema: s.object("Requested resource.", {
+            employmentType: s.object("Employment type information.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true }),
+        }, { required: ["employmentType"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "create_department",
+        description: "Create a SmartHR department.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Department write parameters.", {
+            name: s.string("Department name; must not contain a slash. Required by the official create and update schemas.", { minLength: 1, pattern: "^[^/]+$" }),
+            code: s.string("Department code."),
+            position: s.integer("Display position; automatically assigned on creation when omitted."),
+            companyId: s.string("Company ID."),
+            parentId: s.string("Parent department ID."),
+        }, { required: ["name"] }),
+        outputSchema: s.object("Department write result.", {
+            department: s.object("Department data, including any nested hierarchy returned by SmartHR.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true }),
+        }, { required: ["department"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "update_department",
+        description: "Partially update a SmartHR department, preserving unspecified attributes. SmartHR requires name.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Department write parameters.", {
+            departmentId: s.string("The department ID.", { minLength: 1 }),
+            name: s.string("Department name; must not contain a slash. Required by the official create and update schemas.", { minLength: 1, pattern: "^[^/]+$" }),
+            code: s.string("Department code."),
+            position: s.integer("Display position; automatically assigned on creation when omitted."),
+            companyId: s.string("Company ID."),
+            parentId: s.string("Parent department ID."),
+        }, { required: ["name", "departmentId"] }),
+        outputSchema: s.object("Department write result.", {
+            department: s.object("Department data, including any nested hierarchy returned by SmartHR.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true }),
+        }, { required: ["department"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "replace_department",
+        description: "Replace a SmartHR department. Unspecified attributes are cleared by SmartHR.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Department write parameters.", {
+            departmentId: s.string("The department ID.", { minLength: 1 }),
+            name: s.string("Department name; must not contain a slash. Required by the official create and update schemas.", { minLength: 1, pattern: "^[^/]+$" }),
+            code: s.string("Department code."),
+            position: s.integer("Display position; automatically assigned on creation when omitted."),
+            companyId: s.string("Company ID."),
+            parentId: s.string("Parent department ID."),
+        }, { required: ["name", "departmentId"] }),
+        outputSchema: s.object("Department write result.", {
+            department: s.object("Department data, including any nested hierarchy returned by SmartHR.", { id: s.string("Resource ID."), name: s.string("Resource name.") }, { required: [], additionalProperties: true }),
+        }, { required: ["department"] }),
+    }),
+    defineProviderAction("smarthr", {
+        name: "discontinue_department",
+        description: "Discontinue a SmartHR department on its last active date. The date must be in the past; scheduled employee changes can prevent discontinuation.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: s.object("Department discontinuation parameters.", {
+            departmentId: s.string("The department ID.", { minLength: 1 }),
+            discontinuedDate: s.string("Last date the department existed, in YYYY-MM-DD format; must be in the past.", {
+                format: "date",
+            }),
+        }, { required: ["departmentId", "discontinuedDate"] }),
+        outputSchema: s.object("Department discontinuation result.", { discontinued: s.boolean("Whether SmartHR accepted the discontinuation.") }, { required: ["discontinued"] }),
+    }),
+];

package/src/providers/smarthr/employee-runtime.d.ts

@@ -0,0 +1 @@
+export declare function prepareEmployeeWrite(value: unknown, fetcher: typeof fetch, signal?: AbortSignal): Promise<Record<string, unknown>>;

package/src/providers/smarthr/employee-runtime.js

@@ -0,0 +1,63 @@
+import { Buffer } from "node:buffer";
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readBoundedResponseBytes } from "../../core/request.js";
+import { providerInputError, requiredInputString, runProviderRequest } from "../provider-runtime.js";
+import { employeeAttachmentFields } from "./employee-schema.js";
+async function attachmentPayload(value, fieldName, fetcher, signal) {
+    if (value === null || value === undefined)
+        return value;
+    const attachment = optionalRecord(value);
+    const fileName = requiredInputString(attachment?.fileName, `${fieldName}.fileName`);
+    const fileUrl = requiredInputString(attachment?.fileUrl, `${fieldName}.fileUrl`);
+    const bytes = await runProviderRequest({ label: "SmartHR attachment", timeoutMs: 15_000, signal }, async (requestSignal) => {
+        const response = await fetcher(fileUrl, { signal: requestSignal });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw providerInputError(`${fieldName}.fileUrl download failed with HTTP ${response.status}`);
+        }
+        return readBoundedResponseBytes(response, {
+            maxBytes: 10 * 1024 * 1024,
+            fieldName: `${fieldName}.fileUrl`,
+            createError: providerInputError,
+            signal: requestSignal,
+        });
+    });
+    return { file_name: fileName, content: Buffer.from(bytes).toString("base64") };
+}
+export async function prepareEmployeeWrite(value, fetcher, signal) {
+    const employee = optionalRecord(value);
+    if (!employee)
+        throw providerInputError("employee must be an object");
+    const body = structuredClone(employee);
+    if (Array.isArray(body.bank_accounts)) {
+        const withSetting = body.bank_accounts.filter((entry) => optionalRawString(optionalRecord(entry)?.bank_account_setting_id) !== undefined).length;
+        if (withSetting !== 0 && withSetting !== body.bank_accounts.length) {
+            throw providerInputError("All bank_accounts must either supply bank_account_setting_id or omit it");
+        }
+    }
+    for (const key of employeeAttachmentFields) {
+        if (body[key] !== undefined)
+            body[key] = await attachmentPayload(body[key], `employee.${key}`, fetcher, signal);
+    }
+    if (Array.isArray(body.bank_accounts)) {
+        for (const entry of body.bank_accounts) {
+            const account = optionalRecord(entry);
+            if (account?.bankbook_image !== undefined)
+                account.bankbook_image = await attachmentPayload(account.bankbook_image, "employee.bank_accounts.bankbook_image", fetcher, signal);
+        }
+    }
+    if (Array.isArray(body.custom_fields)) {
+        for (const entry of body.custom_fields) {
+            const field = optionalRecord(entry);
+            if (field?.file !== undefined) {
+                const attachment = await attachmentPayload(field.file, "employee.custom_fields.file", fetcher, signal);
+                if (attachment) {
+                    field.value = attachment.content;
+                    field.file_name = attachment.file_name;
+                }
+                delete field.file;
+            }
+        }
+    }
+    return body;
+}

package/src/providers/smarthr/employee-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const employeeAttachmentFields: string[];
+export declare const employeeWriteSchema: JsonSchema;