@dbx-tools/teams 0.3.44 → 0.4.1

package/lib/src/config.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Configuration for the Teams plugin: the typed {@link TeamsPluginConfig}
+ * (the plugin's slice of AppKit config), the JSON Schema the manifest
+ * publishes for it, and {@link resolveTeamsConfig} which layers that config
+ * over environment defaults into the concrete {@link ResolvedTeamsConfig} the
+ * runtime + tools read.
+ *
+ * Building a card is a pure transform, so the config is deliberately small:
+ * the Adaptive Card version the builder targets, an optional Teams
+ * incoming-webhook URL a deployment can wire up to actually POST cards to a
+ * channel, and which sibling plugin owns the agents the conversation endpoint
+ * answers with.
+ *
+ * The remaining fields are the Azure Bot registration a real Teams channel
+ * needs: `appId` / `appPassword` (the bot's Entra application credentials, used
+ * both to validate the inbound JWT audience and to fetch the outbound Connector
+ * token) and `appTenantId` (set only for a single-tenant bot). When no `appId`
+ * is configured the `/messages` endpoint stays MOUNTED but refuses every
+ * request, so an unconfigured deployment cannot accidentally expose an
+ * unauthenticated bot endpoint.
+ *
+ * Env fallbacks: `TEAMS_CARD_VERSION`, `TEAMS_WEBHOOK_URL`,
+ * `TEAMS_AGENT_PLUGIN`, `TEAMS_APP_ID`, `TEAMS_APP_PASSWORD`,
+ * `TEAMS_APP_TENANT_ID`. The `MICROSOFT_APP_*` spellings the Bot Framework SDK
+ * uses are accepted as aliases so an existing bot's environment drops in
+ * unchanged.
+ *
+ * @module
+ */
+import { type BasePluginConfig } from "@databricks/appkit";
+import type { JSONSchema7 } from "json-schema";
+/** Dedicated override for the Adaptive Card schema version the builder targets. */
+export declare const CARD_VERSION_ENV = "TEAMS_CARD_VERSION";
+/** Environment name for an optional Teams incoming-webhook URL. */
+export declare const WEBHOOK_URL_ENV = "TEAMS_WEBHOOK_URL";
+/** Environment name overriding which sibling plugin provides the agents. */
+export declare const AGENT_PLUGIN_ENV = "TEAMS_AGENT_PLUGIN";
+/**
+ * Environment names for the bot's Entra app id, in precedence order. The
+ * `MICROSOFT_APP_ID` alias is what the Bot Framework SDK and the Azure portal's
+ * generated settings use, so an existing bot deployment needs no new variable.
+ */
+export declare const APP_ID_ENVS: readonly ["TEAMS_APP_ID", "MICROSOFT_APP_ID"];
+/** Environment names for the bot's client secret, in precedence order. */
+export declare const APP_PASSWORD_ENVS: readonly ["TEAMS_APP_PASSWORD", "MICROSOFT_APP_PASSWORD"];
+/**
+ * Environment names for the bot's tenant, in precedence order. Set only for a
+ * single-tenant bot; a multi-tenant bot leaves it unset.
+ */
+export declare const APP_TENANT_ENVS: readonly ["TEAMS_APP_TENANT_ID", "MICROSOFT_APP_TENANT_ID"];
+/**
+ * Environment name for the unauthenticated-messaging escape hatch. Named
+ * `TEAMS_ALLOW_UNAUTHENTICATED` (rather than something softer like `TEAMS_DEV`)
+ * so what it disables is unmistakable in a shell history or deploy manifest.
+ */
+export declare const ALLOW_UNAUTHENTICATED_ENV = "TEAMS_ALLOW_UNAUTHENTICATED";
+/**
+ * Default registered name of the plugin the conversation endpoint asks for an
+ * agent. `mastra` is the name `@dbx-tools/appkit-mastra` registers under.
+ */
+export declare const DEFAULT_AGENT_PLUGIN = "mastra";
+/** AppKit config accepted by the Teams plugin. */
+export interface TeamsPluginConfig extends BasePluginConfig {
+    /**
+     * Adaptive Card schema version the builder targets. Defaults to
+     * {@link card.ADAPTIVE_CARD_VERSION} (`"1.5"`, what Teams supports). Falls
+     * back to `TEAMS_CARD_VERSION`.
+     */
+    cardVersion?: string;
+    /**
+     * Optional Teams incoming-webhook URL. When set, the plugin's `postCard`
+     * export / route posts the compiled card to this channel; when unset,
+     * posting is disabled and the plugin only builds cards for the UI to render.
+     * Falls back to `TEAMS_WEBHOOK_URL`.
+     */
+    webhookUrl?: string;
+    /**
+     * Registered name of the sibling plugin whose agents answer a conversation
+     * turn. Defaults to {@link DEFAULT_AGENT_PLUGIN} (`"mastra"`); set it when the
+     * Mastra plugin is mounted under a `config.name` override. Falls back to
+     * `TEAMS_AGENT_PLUGIN`.
+     */
+    agentPlugin?: string;
+    /**
+     * The bot's Entra application (client) id from its Azure Bot registration.
+     * Required before `POST /api/teams/messages` will accept a request: it is the
+     * audience an inbound Bot Framework token must carry, and the client id used
+     * to fetch an outbound Connector token. Falls back to `TEAMS_APP_ID` /
+     * `MICROSOFT_APP_ID`.
+     */
+    appId?: string;
+    /**
+     * Client secret for {@link appId}. Needed to send replies through the
+     * Connector API; without it inbound activities still validate but the bot
+     * cannot answer. Falls back to `TEAMS_APP_PASSWORD` /
+     * `MICROSOFT_APP_PASSWORD`.
+     */
+    appPassword?: string;
+    /**
+     * Tenant id for a SINGLE-tenant bot registration. Leave unset for a
+     * multi-tenant bot. Falls back to `TEAMS_APP_TENANT_ID` /
+     * `MICROSOFT_APP_TENANT_ID`.
+     */
+    appTenantId?: string;
+    /**
+     * Serve `POST /messages` with NO inbound token validation, and reply in the
+     * HTTP response instead of through the Connector API.
+     *
+     * This exists so the messaging endpoint can be exercised locally - by the
+     * in-repo preview chat, a `curl`, or the Bot Framework Emulator - without an
+     * Azure Bot registration. It removes the endpoint's ONLY trust boundary: any
+     * caller that can reach the route can drive the agent and read its answers.
+     *
+     * Never enable it on a deployment reachable from the internet. It is ignored
+     * unless `NODE_ENV` is `development` (see {@link resolveTeamsConfig}), so a
+     * production build cannot be talked into it by an environment variable alone.
+     * Falls back to `TEAMS_ALLOW_UNAUTHENTICATED`.
+     */
+    allowUnauthenticated?: boolean;
+}
+/** The concrete config the runtime reads, after config + env resolution. */
+export interface ResolvedTeamsConfig {
+    /** Adaptive Card schema version the builder stamps onto every document. */
+    cardVersion: string;
+    /** Teams incoming-webhook URL, or `undefined` when posting is disabled. */
+    webhookUrl?: string;
+    /** Registered name of the plugin the conversation endpoint resolves agents from. */
+    agentPlugin: string;
+    /** Bot app (client) id, or `undefined` when no bot registration is configured. */
+    appId?: string;
+    /** Bot client secret, or `undefined` when replies cannot be sent. */
+    appPassword?: string;
+    /** Tenant id for a single-tenant bot, or `undefined` for a multi-tenant one. */
+    appTenantId?: string;
+    /**
+     * Whether `POST /messages` serves turns with NO token validation. See
+     * {@link TeamsPluginConfig.allowUnauthenticated}.
+     */
+    allowUnauthenticated: boolean;
+}
+/** JSON Schema published in the plugin manifest for {@link TeamsPluginConfig}. */
+export declare const TEAMS_CONFIG_SCHEMA: JSONSchema7;
+/**
+ * Layer the plugin config over environment defaults into the concrete config
+ * the runtime uses. Fails loudly on a webhook URL that is present but not a
+ * valid absolute URL, since that is a deploy-time mistake.
+ */
+export declare function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeamsConfig;

package/lib/src/config.js

@@ -0,0 +1,163 @@
+/**
+ * Configuration for the Teams plugin: the typed {@link TeamsPluginConfig}
+ * (the plugin's slice of AppKit config), the JSON Schema the manifest
+ * publishes for it, and {@link resolveTeamsConfig} which layers that config
+ * over environment defaults into the concrete {@link ResolvedTeamsConfig} the
+ * runtime + tools read.
+ *
+ * Building a card is a pure transform, so the config is deliberately small:
+ * the Adaptive Card version the builder targets, an optional Teams
+ * incoming-webhook URL a deployment can wire up to actually POST cards to a
+ * channel, and which sibling plugin owns the agents the conversation endpoint
+ * answers with.
+ *
+ * The remaining fields are the Azure Bot registration a real Teams channel
+ * needs: `appId` / `appPassword` (the bot's Entra application credentials, used
+ * both to validate the inbound JWT audience and to fetch the outbound Connector
+ * token) and `appTenantId` (set only for a single-tenant bot). When no `appId`
+ * is configured the `/messages` endpoint stays MOUNTED but refuses every
+ * request, so an unconfigured deployment cannot accidentally expose an
+ * unauthenticated bot endpoint.
+ *
+ * Env fallbacks: `TEAMS_CARD_VERSION`, `TEAMS_WEBHOOK_URL`,
+ * `TEAMS_AGENT_PLUGIN`, `TEAMS_APP_ID`, `TEAMS_APP_PASSWORD`,
+ * `TEAMS_APP_TENANT_ID`. The `MICROSOFT_APP_*` spellings the Bot Framework SDK
+ * uses are accepted as aliases so an existing bot's environment drops in
+ * unchanged.
+ *
+ * @module
+ */
+import { ValidationError } from "@databricks/appkit";
+import { object, string } from "@dbx-tools/shared-core";
+import { card } from "@dbx-tools/shared-teams";
+/** Dedicated override for the Adaptive Card schema version the builder targets. */
+export const CARD_VERSION_ENV = "TEAMS_CARD_VERSION";
+/** Environment name for an optional Teams incoming-webhook URL. */
+export const WEBHOOK_URL_ENV = "TEAMS_WEBHOOK_URL";
+/** Environment name overriding which sibling plugin provides the agents. */
+export const AGENT_PLUGIN_ENV = "TEAMS_AGENT_PLUGIN";
+/**
+ * Environment names for the bot's Entra app id, in precedence order. The
+ * `MICROSOFT_APP_ID` alias is what the Bot Framework SDK and the Azure portal's
+ * generated settings use, so an existing bot deployment needs no new variable.
+ */
+export const APP_ID_ENVS = ["TEAMS_APP_ID", "MICROSOFT_APP_ID"];
+/** Environment names for the bot's client secret, in precedence order. */
+export const APP_PASSWORD_ENVS = ["TEAMS_APP_PASSWORD", "MICROSOFT_APP_PASSWORD"];
+/**
+ * Environment names for the bot's tenant, in precedence order. Set only for a
+ * single-tenant bot; a multi-tenant bot leaves it unset.
+ */
+export const APP_TENANT_ENVS = ["TEAMS_APP_TENANT_ID", "MICROSOFT_APP_TENANT_ID"];
+/**
+ * Environment name for the unauthenticated-messaging escape hatch. Named
+ * `TEAMS_ALLOW_UNAUTHENTICATED` (rather than something softer like `TEAMS_DEV`)
+ * so what it disables is unmistakable in a shell history or deploy manifest.
+ */
+export const ALLOW_UNAUTHENTICATED_ENV = "TEAMS_ALLOW_UNAUTHENTICATED";
+/**
+ * Default registered name of the plugin the conversation endpoint asks for an
+ * agent. `mastra` is the name `@dbx-tools/appkit-mastra` registers under.
+ */
+export const DEFAULT_AGENT_PLUGIN = "mastra";
+/** JSON Schema published in the plugin manifest for {@link TeamsPluginConfig}. */
+export const TEAMS_CONFIG_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        cardVersion: {
+            type: "string",
+            description: `Adaptive Card schema version the builder targets. ${CARD_VERSION_ENV} overrides it.`,
+        },
+        webhookUrl: {
+            type: "string",
+            description: `Optional Teams incoming-webhook URL used to post cards. ${WEBHOOK_URL_ENV} overrides it.`,
+        },
+        agentPlugin: {
+            type: "string",
+            description: `Registered name of the sibling plugin whose agents answer a conversation turn. ${AGENT_PLUGIN_ENV} overrides it.`,
+        },
+        appId: {
+            type: "string",
+            description: `Entra app (client) id of the Azure Bot registration. Required for the Teams messaging endpoint. ${APP_ID_ENVS[0]} overrides it.`,
+        },
+        appPassword: {
+            type: "string",
+            description: `Client secret for the bot app id, used to fetch an outbound Connector token. ${APP_PASSWORD_ENVS[0]} overrides it.`,
+        },
+        appTenantId: {
+            type: "string",
+            description: `Tenant id for a single-tenant bot registration; unset for multi-tenant. ${APP_TENANT_ENVS[0]} overrides it.`,
+        },
+        allowUnauthenticated: {
+            type: "boolean",
+            description: "Serve the Teams messaging endpoint with NO token validation, replying in " +
+                "the HTTP response. Local development only; ignored unless NODE_ENV is " +
+                `development. ${ALLOW_UNAUTHENTICATED_ENV} overrides it.`,
+        },
+    },
+};
+/**
+ * Layer the plugin config over environment defaults into the concrete config
+ * the runtime uses. Fails loudly on a webhook URL that is present but not a
+ * valid absolute URL, since that is a deploy-time mistake.
+ */
+export function resolveTeamsConfig(overrides) {
+    const cardVersion = string.trimToNull(overrides?.cardVersion) ??
+        string.trimToNull(process.env[CARD_VERSION_ENV]) ??
+        card.ADAPTIVE_CARD_VERSION;
+    const webhookUrl = string.trimToNull(overrides?.webhookUrl) ?? string.trimToNull(process.env[WEBHOOK_URL_ENV]);
+    if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {
+        throw ValidationError.invalidValue(WEBHOOK_URL_ENV, webhookUrl, "an absolute https URL for the Teams webhook");
+    }
+    const agentPlugin = string.trimToNull(overrides?.agentPlugin) ??
+        string.trimToNull(process.env[AGENT_PLUGIN_ENV]) ??
+        DEFAULT_AGENT_PLUGIN;
+    // Two independent conditions must BOTH hold: the operator asked for it, and
+    // this is a development build. Gating on `NODE_ENV` as well means a stray
+    // variable in a production environment cannot silently expose the endpoint.
+    const requested = overrides?.allowUnauthenticated ?? object.toBoolean(process.env[ALLOW_UNAUTHENTICATED_ENV]);
+    const allowUnauthenticated = requested === true && process.env.NODE_ENV === "development";
+    return {
+        cardVersion,
+        agentPlugin,
+        allowUnauthenticated,
+        ...(webhookUrl !== null ? { webhookUrl } : {}),
+        ...spread("appId", string.trimToNull(overrides?.appId) ?? fromEnv(APP_ID_ENVS)),
+        ...spread("appPassword", string.trimToNull(overrides?.appPassword) ?? fromEnv(APP_PASSWORD_ENVS)),
+        ...spread("appTenantId", string.trimToNull(overrides?.appTenantId) ?? fromEnv(APP_TENANT_ENVS)),
+    };
+}
+/**
+ * First non-empty value among `names` in the environment, or `null`. Lets a
+ * `TEAMS_*` variable win over the `MICROSOFT_APP_*` alias the Bot Framework SDK
+ * uses without duplicating the lookup per field.
+ */
+function fromEnv(names) {
+    for (const name of names) {
+        const value = string.trimToNull(process.env[name]);
+        if (value !== null)
+            return value;
+    }
+    return null;
+}
+/**
+ * `{ [key]: value }` when `value` is present, otherwise nothing - so an absent
+ * optional field stays ABSENT rather than becoming an explicit `undefined`,
+ * which `exactOptionalPropertyTypes` rejects.
+ */
+function spread(key, value) {
+    return value === null ? undefined : { [key]: value };
+}
+/** Whether `value` parses as an absolute URL. */
+function isAbsoluteUrl(value) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration for the Teams plugin: the typed {@link TeamsPluginConfig}\n * (the plugin's slice of AppKit config), the JSON Schema the manifest\n * publishes for it, and {@link resolveTeamsConfig} which layers that config\n * over environment defaults into the concrete {@link ResolvedTeamsConfig} the\n * runtime + tools read.\n *\n * Building a card is a pure transform, so the config is deliberately small:\n * the Adaptive Card version the builder targets, an optional Teams\n * incoming-webhook URL a deployment can wire up to actually POST cards to a\n * channel, and which sibling plugin owns the agents the conversation endpoint\n * answers with.\n *\n * The remaining fields are the Azure Bot registration a real Teams channel\n * needs: `appId` / `appPassword` (the bot's Entra application credentials, used\n * both to validate the inbound JWT audience and to fetch the outbound Connector\n * token) and `appTenantId` (set only for a single-tenant bot). When no `appId`\n * is configured the `/messages` endpoint stays MOUNTED but refuses every\n * request, so an unconfigured deployment cannot accidentally expose an\n * unauthenticated bot endpoint.\n *\n * Env fallbacks: `TEAMS_CARD_VERSION`, `TEAMS_WEBHOOK_URL`,\n * `TEAMS_AGENT_PLUGIN`, `TEAMS_APP_ID`, `TEAMS_APP_PASSWORD`,\n * `TEAMS_APP_TENANT_ID`. The `MICROSOFT_APP_*` spellings the Bot Framework SDK\n * uses are accepted as aliases so an existing bot's environment drops in\n * unchanged.\n *\n * @module\n */\n\nimport { ValidationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { object, string } from \"@dbx-tools/shared-core\";\nimport { card } from \"@dbx-tools/shared-teams\";\nimport type { JSONSchema7 } from \"json-schema\";\n\n/** Dedicated override for the Adaptive Card schema version the builder targets. */\nexport const CARD_VERSION_ENV = \"TEAMS_CARD_VERSION\";\n\n/** Environment name for an optional Teams incoming-webhook URL. */\nexport const WEBHOOK_URL_ENV = \"TEAMS_WEBHOOK_URL\";\n\n/** Environment name overriding which sibling plugin provides the agents. */\nexport const AGENT_PLUGIN_ENV = \"TEAMS_AGENT_PLUGIN\";\n\n/**\n * Environment names for the bot's Entra app id, in precedence order. The\n * `MICROSOFT_APP_ID` alias is what the Bot Framework SDK and the Azure portal's\n * generated settings use, so an existing bot deployment needs no new variable.\n */\nexport const APP_ID_ENVS = [\"TEAMS_APP_ID\", \"MICROSOFT_APP_ID\"] as const;\n\n/** Environment names for the bot's client secret, in precedence order. */\nexport const APP_PASSWORD_ENVS = [\"TEAMS_APP_PASSWORD\", \"MICROSOFT_APP_PASSWORD\"] as const;\n\n/**\n * Environment names for the bot's tenant, in precedence order. Set only for a\n * single-tenant bot; a multi-tenant bot leaves it unset.\n */\nexport const APP_TENANT_ENVS = [\"TEAMS_APP_TENANT_ID\", \"MICROSOFT_APP_TENANT_ID\"] as const;\n\n/**\n * Environment name for the unauthenticated-messaging escape hatch. Named\n * `TEAMS_ALLOW_UNAUTHENTICATED` (rather than something softer like `TEAMS_DEV`)\n * so what it disables is unmistakable in a shell history or deploy manifest.\n */\nexport const ALLOW_UNAUTHENTICATED_ENV = \"TEAMS_ALLOW_UNAUTHENTICATED\";\n\n/**\n * Default registered name of the plugin the conversation endpoint asks for an\n * agent. `mastra` is the name `@dbx-tools/appkit-mastra` registers under.\n */\nexport const DEFAULT_AGENT_PLUGIN = \"mastra\";\n\n/** AppKit config accepted by the Teams plugin. */\nexport interface TeamsPluginConfig extends BasePluginConfig {\n  /**\n   * Adaptive Card schema version the builder targets. Defaults to\n   * {@link card.ADAPTIVE_CARD_VERSION} (`\"1.5\"`, what Teams supports). Falls\n   * back to `TEAMS_CARD_VERSION`.\n   */\n  cardVersion?: string;\n  /**\n   * Optional Teams incoming-webhook URL. When set, the plugin's `postCard`\n   * export / route posts the compiled card to this channel; when unset,\n   * posting is disabled and the plugin only builds cards for the UI to render.\n   * Falls back to `TEAMS_WEBHOOK_URL`.\n   */\n  webhookUrl?: string;\n  /**\n   * Registered name of the sibling plugin whose agents answer a conversation\n   * turn. Defaults to {@link DEFAULT_AGENT_PLUGIN} (`\"mastra\"`); set it when the\n   * Mastra plugin is mounted under a `config.name` override. Falls back to\n   * `TEAMS_AGENT_PLUGIN`.\n   */\n  agentPlugin?: string;\n  /**\n   * The bot's Entra application (client) id from its Azure Bot registration.\n   * Required before `POST /api/teams/messages` will accept a request: it is the\n   * audience an inbound Bot Framework token must carry, and the client id used\n   * to fetch an outbound Connector token. Falls back to `TEAMS_APP_ID` /\n   * `MICROSOFT_APP_ID`.\n   */\n  appId?: string;\n  /**\n   * Client secret for {@link appId}. Needed to send replies through the\n   * Connector API; without it inbound activities still validate but the bot\n   * cannot answer. Falls back to `TEAMS_APP_PASSWORD` /\n   * `MICROSOFT_APP_PASSWORD`.\n   */\n  appPassword?: string;\n  /**\n   * Tenant id for a SINGLE-tenant bot registration. Leave unset for a\n   * multi-tenant bot. Falls back to `TEAMS_APP_TENANT_ID` /\n   * `MICROSOFT_APP_TENANT_ID`.\n   */\n  appTenantId?: string;\n  /**\n   * Serve `POST /messages` with NO inbound token validation, and reply in the\n   * HTTP response instead of through the Connector API.\n   *\n   * This exists so the messaging endpoint can be exercised locally - by the\n   * in-repo preview chat, a `curl`, or the Bot Framework Emulator - without an\n   * Azure Bot registration. It removes the endpoint's ONLY trust boundary: any\n   * caller that can reach the route can drive the agent and read its answers.\n   *\n   * Never enable it on a deployment reachable from the internet. It is ignored\n   * unless `NODE_ENV` is `development` (see {@link resolveTeamsConfig}), so a\n   * production build cannot be talked into it by an environment variable alone.\n   * Falls back to `TEAMS_ALLOW_UNAUTHENTICATED`.\n   */\n  allowUnauthenticated?: boolean;\n}\n\n/** The concrete config the runtime reads, after config + env resolution. */\nexport interface ResolvedTeamsConfig {\n  /** Adaptive Card schema version the builder stamps onto every document. */\n  cardVersion: string;\n  /** Teams incoming-webhook URL, or `undefined` when posting is disabled. */\n  webhookUrl?: string;\n  /** Registered name of the plugin the conversation endpoint resolves agents from. */\n  agentPlugin: string;\n  /** Bot app (client) id, or `undefined` when no bot registration is configured. */\n  appId?: string;\n  /** Bot client secret, or `undefined` when replies cannot be sent. */\n  appPassword?: string;\n  /** Tenant id for a single-tenant bot, or `undefined` for a multi-tenant one. */\n  appTenantId?: string;\n  /**\n   * Whether `POST /messages` serves turns with NO token validation. See\n   * {@link TeamsPluginConfig.allowUnauthenticated}.\n   */\n  allowUnauthenticated: boolean;\n}\n\n/** JSON Schema published in the plugin manifest for {@link TeamsPluginConfig}. */\nexport const TEAMS_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  additionalProperties: false,\n  properties: {\n    cardVersion: {\n      type: \"string\",\n      description: `Adaptive Card schema version the builder targets. ${CARD_VERSION_ENV} overrides it.`,\n    },\n    webhookUrl: {\n      type: \"string\",\n      description: `Optional Teams incoming-webhook URL used to post cards. ${WEBHOOK_URL_ENV} overrides it.`,\n    },\n    agentPlugin: {\n      type: \"string\",\n      description: `Registered name of the sibling plugin whose agents answer a conversation turn. ${AGENT_PLUGIN_ENV} overrides it.`,\n    },\n    appId: {\n      type: \"string\",\n      description: `Entra app (client) id of the Azure Bot registration. Required for the Teams messaging endpoint. ${APP_ID_ENVS[0]} overrides it.`,\n    },\n    appPassword: {\n      type: \"string\",\n      description: `Client secret for the bot app id, used to fetch an outbound Connector token. ${APP_PASSWORD_ENVS[0]} overrides it.`,\n    },\n    appTenantId: {\n      type: \"string\",\n      description: `Tenant id for a single-tenant bot registration; unset for multi-tenant. ${APP_TENANT_ENVS[0]} overrides it.`,\n    },\n    allowUnauthenticated: {\n      type: \"boolean\",\n      description:\n        \"Serve the Teams messaging endpoint with NO token validation, replying in \" +\n        \"the HTTP response. Local development only; ignored unless NODE_ENV is \" +\n        `development. ${ALLOW_UNAUTHENTICATED_ENV} overrides it.`,\n    },\n  },\n};\n\n/**\n * Layer the plugin config over environment defaults into the concrete config\n * the runtime uses. Fails loudly on a webhook URL that is present but not a\n * valid absolute URL, since that is a deploy-time mistake.\n */\nexport function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeamsConfig {\n  const cardVersion =\n    string.trimToNull(overrides?.cardVersion) ??\n    string.trimToNull(process.env[CARD_VERSION_ENV]) ??\n    card.ADAPTIVE_CARD_VERSION;\n  const webhookUrl =\n    string.trimToNull(overrides?.webhookUrl) ?? string.trimToNull(process.env[WEBHOOK_URL_ENV]);\n  if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {\n    throw ValidationError.invalidValue(\n      WEBHOOK_URL_ENV,\n      webhookUrl,\n      \"an absolute https URL for the Teams webhook\",\n    );\n  }\n  const agentPlugin =\n    string.trimToNull(overrides?.agentPlugin) ??\n    string.trimToNull(process.env[AGENT_PLUGIN_ENV]) ??\n    DEFAULT_AGENT_PLUGIN;\n  // Two independent conditions must BOTH hold: the operator asked for it, and\n  // this is a development build. Gating on `NODE_ENV` as well means a stray\n  // variable in a production environment cannot silently expose the endpoint.\n  const requested =\n    overrides?.allowUnauthenticated ?? object.toBoolean(process.env[ALLOW_UNAUTHENTICATED_ENV]);\n  const allowUnauthenticated = requested === true && process.env.NODE_ENV === \"development\";\n  return {\n    cardVersion,\n    agentPlugin,\n    allowUnauthenticated,\n    ...(webhookUrl !== null ? { webhookUrl } : {}),\n    ...spread(\"appId\", string.trimToNull(overrides?.appId) ?? fromEnv(APP_ID_ENVS)),\n    ...spread(\n      \"appPassword\",\n      string.trimToNull(overrides?.appPassword) ?? fromEnv(APP_PASSWORD_ENVS),\n    ),\n    ...spread(\"appTenantId\", string.trimToNull(overrides?.appTenantId) ?? fromEnv(APP_TENANT_ENVS)),\n  };\n}\n\n/**\n * First non-empty value among `names` in the environment, or `null`. Lets a\n * `TEAMS_*` variable win over the `MICROSOFT_APP_*` alias the Bot Framework SDK\n * uses without duplicating the lookup per field.\n */\nfunction fromEnv(names: readonly string[]): string | null {\n  for (const name of names) {\n    const value = string.trimToNull(process.env[name]);\n    if (value !== null) return value;\n  }\n  return null;\n}\n\n/**\n * `{ [key]: value }` when `value` is present, otherwise nothing - so an absent\n * optional field stays ABSENT rather than becoming an explicit `undefined`,\n * which `exactOptionalPropertyTypes` rejects.\n */\nfunction spread<K extends string>(key: K, value: string | null): Record<K, string> | undefined {\n  return value === null ? undefined : ({ [key]: value } as Record<K, string>);\n}\n\n/** Whether `value` parses as an absolute URL. */\nfunction isAbsoluteUrl(value: string): boolean {\n  try {\n    // eslint-disable-next-line no-new\n    new URL(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"]}

package/lib/src/connector.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Bot Framework Connector API client - how a reply actually reaches Teams.
+ *
+ * This is the part that makes the difference between a chat API and a bot. Azure
+ * Bot Service does NOT read replies from the body of the `/messages` response:
+ * it expects `200` (an acknowledgement that the activity was accepted) and then
+ * a separate, authenticated call back to the `serviceUrl` the activity arrived
+ * with. So a turn is inherently asynchronous - acknowledge, think, then deliver.
+ *
+ * Two calls are modelled, both `POST` to the conversation's activity collection:
+ *
+ *   - {@link sendActivity} - `POST /v3/conversations/{id}/activities/{replyToId}`
+ *     delivers a reply threaded under the user's message.
+ *   - {@link sendTyping} - the same call with a `typing` activity, which is what
+ *     puts the "…" indicator in the channel while the agent works.
+ *
+ * `serviceUrl` is always supplied by the CALLER from a validated source (see
+ * `isAllowedServiceUrl`), never read straight off an untrusted request body:
+ * these calls carry the bot's bearer token, so the destination host is a
+ * security-relevant input.
+ *
+ * @module
+ */
+import type { activity as activityContract } from "@dbx-tools/shared-teams";
+/** Everything needed to address one Connector call. */
+export interface ConnectorTarget {
+    /** Base URL the activity arrived from, e.g. `https://smba.trafficmanager.net/amer/`. */
+    serviceUrl: string;
+    /** Conversation the reply belongs to. */
+    conversationId: string;
+    /** Bearer token for the bot's app registration. */
+    token: string;
+    /** Activity the reply threads under, when replying to a specific message. */
+    replyToId?: string;
+    /** Cancels the request with the turn. */
+    signal?: AbortSignal;
+}
+/**
+ * Deliver one activity to a conversation through the Connector API.
+ *
+ * Returns the id the channel assigned the posted activity, when it reports one -
+ * useful for a later update/delete, and for correlating logs with what a user
+ * sees in the channel.
+ */
+export declare const sendActivity: (activity: activityContract.Activity, target: ConnectorTarget) => Promise<string | undefined>;
+/**
+ * Show the typing indicator in the conversation.
+ *
+ * Best-effort by design: a failed indicator must never fail the turn, because
+ * the card that follows is the actual answer. A failure is logged at debug and
+ * swallowed.
+ */
+export declare const sendTyping: (target: ConnectorTarget) => Promise<void>;

package/lib/src/connector.js

@@ -0,0 +1,82 @@
+/**
+ * Bot Framework Connector API client - how a reply actually reaches Teams.
+ *
+ * This is the part that makes the difference between a chat API and a bot. Azure
+ * Bot Service does NOT read replies from the body of the `/messages` response:
+ * it expects `200` (an acknowledgement that the activity was accepted) and then
+ * a separate, authenticated call back to the `serviceUrl` the activity arrived
+ * with. So a turn is inherently asynchronous - acknowledge, think, then deliver.
+ *
+ * Two calls are modelled, both `POST` to the conversation's activity collection:
+ *
+ *   - {@link sendActivity} - `POST /v3/conversations/{id}/activities/{replyToId}`
+ *     delivers a reply threaded under the user's message.
+ *   - {@link sendTyping} - the same call with a `typing` activity, which is what
+ *     puts the "…" indicator in the channel while the agent works.
+ *
+ * `serviceUrl` is always supplied by the CALLER from a validated source (see
+ * `isAllowedServiceUrl`), never read straight off an untrusted request body:
+ * these calls carry the bot's bearer token, so the destination host is a
+ * security-relevant input.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("teams:connector");
+/**
+ * Build the activities URL for a conversation.
+ *
+ * `replyToId` selects the threaded form, which is what makes a reply appear
+ * attached to the user's message rather than as a loose channel post.
+ */
+const activitiesUrl = (target) => {
+    const base = target.serviceUrl.replace(/\/+$/, "");
+    const conversation = encodeURIComponent(target.conversationId);
+    const suffix = target.replyToId ? `/${encodeURIComponent(target.replyToId)}` : "";
+    return `${base}/v3/conversations/${conversation}/activities${suffix}`;
+};
+/**
+ * Deliver one activity to a conversation through the Connector API.
+ *
+ * Returns the id the channel assigned the posted activity, when it reports one -
+ * useful for a later update/delete, and for correlating logs with what a user
+ * sees in the channel.
+ */
+export const sendActivity = async (activity, target) => {
+    const response = await fetch(activitiesUrl(target), {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${target.token}`,
+        },
+        body: JSON.stringify(activity),
+        ...(target.signal ? { signal: target.signal } : {}),
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(`teams: connector rejected the activity (${response.status}) ${detail}`.trim());
+    }
+    const payload = (await response.json().catch(() => null));
+    const id = typeof payload?.id === "string" ? payload.id : undefined;
+    logger.debug("activity delivered", { conversation: target.conversationId, id });
+    return id;
+};
+/**
+ * Show the typing indicator in the conversation.
+ *
+ * Best-effort by design: a failed indicator must never fail the turn, because
+ * the card that follows is the actual answer. A failure is logged at debug and
+ * swallowed.
+ */
+export const sendTyping = async (target) => {
+    try {
+        await sendActivity({ type: "typing" }, target);
+    }
+    catch (err) {
+        logger.debug("typing indicator failed", {
+            conversation: target.conversationId,
+            error: err.message,
+        });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connector.js","sourceRoot":"","sources":["../../src/connector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAG7C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAgB7C;;;;;GAKG;AACH,MAAM,aAAa,GAAG,CAAC,MAAuB,EAAU,EAAE;IACxD,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACnD,MAAM,YAAY,GAAG,kBAAkB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClF,OAAO,GAAG,IAAI,qBAAqB,YAAY,cAAc,MAAM,EAAE,CAAC;AACxE,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAC/B,QAAmC,EACnC,MAAuB,EACM,EAAE;IAC/B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;QAClD,MAAM,EAAE,MAAM;QACd,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB;YAClC,aAAa,EAAE,UAAU,MAAM,CAAC,KAAK,EAAE;SACxC;QACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QAC9B,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpD,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,2CAA2C,QAAQ,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,OAAO,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAA4B,CAAC;IACrF,MAAM,EAAE,GAAG,OAAO,OAAO,EAAE,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,YAAY,EAAE,MAAM,CAAC,cAAc,EAAE,EAAE,EAAE,CAAC,CAAC;IAChF,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,EAAE,MAAuB,EAAiB,EAAE;IACzE,IAAI,CAAC;QACH,MAAM,YAAY,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE;YACtC,YAAY,EAAE,MAAM,CAAC,cAAc;YACnC,KAAK,EAAG,GAAa,CAAC,OAAO;SAC9B,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC","sourcesContent":["/**\n * Bot Framework Connector API client - how a reply actually reaches Teams.\n *\n * This is the part that makes the difference between a chat API and a bot. Azure\n * Bot Service does NOT read replies from the body of the `/messages` response:\n * it expects `200` (an acknowledgement that the activity was accepted) and then\n * a separate, authenticated call back to the `serviceUrl` the activity arrived\n * with. So a turn is inherently asynchronous - acknowledge, think, then deliver.\n *\n * Two calls are modelled, both `POST` to the conversation's activity collection:\n *\n *   - {@link sendActivity} - `POST /v3/conversations/{id}/activities/{replyToId}`\n *     delivers a reply threaded under the user's message.\n *   - {@link sendTyping} - the same call with a `typing` activity, which is what\n *     puts the \"…\" indicator in the channel while the agent works.\n *\n * `serviceUrl` is always supplied by the CALLER from a validated source (see\n * `isAllowedServiceUrl`), never read straight off an untrusted request body:\n * these calls carry the bot's bearer token, so the destination host is a\n * security-relevant input.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { activity as activityContract } from \"@dbx-tools/shared-teams\";\n\nconst logger = log.logger(\"teams:connector\");\n\n/** Everything needed to address one Connector call. */\nexport interface ConnectorTarget {\n  /** Base URL the activity arrived from, e.g. `https://smba.trafficmanager.net/amer/`. */\n  serviceUrl: string;\n  /** Conversation the reply belongs to. */\n  conversationId: string;\n  /** Bearer token for the bot's app registration. */\n  token: string;\n  /** Activity the reply threads under, when replying to a specific message. */\n  replyToId?: string;\n  /** Cancels the request with the turn. */\n  signal?: AbortSignal;\n}\n\n/**\n * Build the activities URL for a conversation.\n *\n * `replyToId` selects the threaded form, which is what makes a reply appear\n * attached to the user's message rather than as a loose channel post.\n */\nconst activitiesUrl = (target: ConnectorTarget): string => {\n  const base = target.serviceUrl.replace(/\\/+$/, \"\");\n  const conversation = encodeURIComponent(target.conversationId);\n  const suffix = target.replyToId ? `/${encodeURIComponent(target.replyToId)}` : \"\";\n  return `${base}/v3/conversations/${conversation}/activities${suffix}`;\n};\n\n/**\n * Deliver one activity to a conversation through the Connector API.\n *\n * Returns the id the channel assigned the posted activity, when it reports one -\n * useful for a later update/delete, and for correlating logs with what a user\n * sees in the channel.\n */\nexport const sendActivity = async (\n  activity: activityContract.Activity,\n  target: ConnectorTarget,\n): Promise<string | undefined> => {\n  const response = await fetch(activitiesUrl(target), {\n    method: \"POST\",\n    headers: {\n      \"content-type\": \"application/json\",\n      authorization: `Bearer ${target.token}`,\n    },\n    body: JSON.stringify(activity),\n    ...(target.signal ? { signal: target.signal } : {}),\n  });\n  if (!response.ok) {\n    const detail = await response.text().catch(() => \"\");\n    throw new Error(`teams: connector rejected the activity (${response.status}) ${detail}`.trim());\n  }\n  const payload = (await response.json().catch(() => null)) as { id?: unknown } | null;\n  const id = typeof payload?.id === \"string\" ? payload.id : undefined;\n  logger.debug(\"activity delivered\", { conversation: target.conversationId, id });\n  return id;\n};\n\n/**\n * Show the typing indicator in the conversation.\n *\n * Best-effort by design: a failed indicator must never fail the turn, because\n * the card that follows is the actual answer. A failure is logged at debug and\n * swallowed.\n */\nexport const sendTyping = async (target: ConnectorTarget): Promise<void> => {\n  try {\n    await sendActivity({ type: \"typing\" }, target);\n  } catch (err) {\n    logger.debug(\"typing indicator failed\", {\n      conversation: target.conversationId,\n      error: (err as Error).message,\n    });\n  }\n};\n"]}