@dbx-tools/teams 0.6.46 → 0.6.49

package/lib/src/config.js

@@ -28,7 +28,7 @@
  * @module
  */
 import { ValidationError } from "@databricks/appkit";
-import { object, string } from "@dbx-tools/shared-core";
+import { env, object } 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";
@@ -103,52 +103,27 @@ export const TEAMS_CONFIG_SCHEMA = {
  * 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]);
+    const cardVersion = env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;
+    const webhookUrl = env.string(overrides?.webhookUrl, 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;
+    const agentPlugin = env.string(overrides?.agentPlugin, 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 requested = env.boolean(overrides?.allowUnauthenticated, 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)),
+        ...object.optional("webhookUrl", webhookUrl),
+        ...object.optional("appId", env.string(overrides?.appId, APP_ID_ENVS)),
+        ...object.optional("appPassword", env.string(overrides?.appPassword, APP_PASSWORD_ENVS)),
+        ...object.optional("appTenantId", env.string(overrides?.appTenantId, 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 {
@@ -160,4 +135,4 @@ function isAbsoluteUrl(value) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,eAAe,EAAyB,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAG/C,mFAAmF;AACnF,MAAM,CAAC,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAErD,mEAAmE;AACnE,MAAM,CAAC,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAEnD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,cAAc,EAAE,kBAAkB,CAAU,CAAC;AAEzE,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,oBAAoB,EAAE,wBAAwB,CAAU,CAAC;AAE3F;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,qBAAqB,EAAE,yBAAyB,CAAU,CAAC;AAE3F;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,6BAA6B,CAAC;AAEvE;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,QAAQ,CAAC;AAmF7C,kFAAkF;AAClF,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC9C,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,qDAAqD,gBAAgB,gBAAgB;SACnG;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,2DAA2D,eAAe,gBAAgB;SACxG;QACD,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,kFAAkF,gBAAgB,gBAAgB;SAChI;QACD,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,mGAAmG,WAAW,CAAC,CAAC,CAAC,gBAAgB;SAC/I;QACD,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,gFAAgF,iBAAiB,CAAC,CAAC,CAAC,gBAAgB;SAClI;QACD,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,2EAA2E,eAAe,CAAC,CAAC,CAAC,gBAAgB;SAC3H;QACD,oBAAoB,EAAE;YACpB,IAAI,EAAE,SAAS;YACf,WAAW,EACT,2EAA2E;gBAC3E,wEAAwE;gBACxE,gBAAgB,yBAAyB,gBAAgB;SAC5D;KACF;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAA6B;IAC9D,MAAM,WAAW,GACf,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAChD,IAAI,CAAC,qBAAqB,CAAC;IAC7B,MAAM,UAAU,GACd,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC;IAC9F,IAAI,UAAU,KAAK,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC;QACtD,MAAM,eAAe,CAAC,YAAY,CAChC,eAAe,EACf,UAAU,EACV,6CAA6C,CAC9C,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GACf,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAChD,oBAAoB,CAAC;IACvB,4EAA4E;IAC5E,0EAA0E;IAC1E,4EAA4E;IAC5E,MAAM,SAAS,GACb,SAAS,EAAE,oBAAoB,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC,CAAC;IAC9F,MAAM,oBAAoB,GAAG,SAAS,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;IAC1F,OAAO;QACL,WAAW;QACX,WAAW;QACX,oBAAoB;QACpB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,GAAG,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/E,GAAG,MAAM,CACP,aAAa,EACb,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,CAAC,IAAI,OAAO,CAAC,iBAAiB,CAAC,CACxE;QACD,GAAG,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,CAAC,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;KAChG,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,OAAO,CAAC,KAAwB;IACvC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QACnD,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;IACnC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,MAAM,CAAmB,GAAM,EAAE,KAAoB;IAC5D,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAwB,CAAC;AAC9E,CAAC;AAED,iDAAiD;AACjD,SAAS,aAAa,CAAC,KAAa;IAClC,IAAI,CAAC;QACH,kCAAkC;QAClC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","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"]}
+//# 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 { env, object } 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    env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;\n  const webhookUrl = env.string(overrides?.webhookUrl, 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 = env.string(overrides?.agentPlugin, AGENT_PLUGIN_ENV) ?? 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 = env.boolean(overrides?.allowUnauthenticated, ALLOW_UNAUTHENTICATED_ENV);\n  const allowUnauthenticated = requested === true && process.env.NODE_ENV === \"development\";\n  return {\n    cardVersion,\n    agentPlugin,\n    allowUnauthenticated,\n    ...object.optional(\"webhookUrl\", webhookUrl),\n    ...object.optional(\"appId\", env.string(overrides?.appId, APP_ID_ENVS)),\n    ...object.optional(\"appPassword\", env.string(overrides?.appPassword, APP_PASSWORD_ENVS)),\n    ...object.optional(\"appTenantId\", env.string(overrides?.appTenantId, APP_TENANT_ENVS)),\n  };\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/runtime.js

@@ -18,8 +18,8 @@
  *
  * @module
  */
-import { AppKitError, ExecutionError } from "@databricks/appkit";
-import { async, error, log } from "@dbx-tools/shared-core";
+import { ExecutionError } from "@databricks/appkit";
+import { execution, log } from "@dbx-tools/shared-core";
 import { buildCardResult } from "./builder.js";
 import { resolveTeamsConfig } from "./config.js";
 import { TEAMS_BUILD_SETTINGS, TEAMS_POST_SETTINGS, } from "./defaults.js";
@@ -29,18 +29,7 @@ const logger = log.logger("teams/runtime");
  * directly, mapping a throw onto the same {@link ExecutionResult} shape so
  * call sites branch on `ok` either way.
  */
-const directExecute = async (fn) => {
-    try {
-        return { ok: true, data: await fn() };
-    }
-    catch (err) {
-        return {
-            ok: false,
-            status: err instanceof AppKitError ? err.statusCode : 500,
-            message: error.errorMessage(err),
-        };
-    }
-};
+const directExecute = execution.directExecutor();
 let runtime;
 /**
  * Return the shared runtime, building it on first use from the supplied config
@@ -76,18 +65,23 @@ export function resetTeamsRuntime() {
  */
 async function run(operation, settings, fn, signal) {
     const { execute } = getTeamsRuntime();
-    const result = await execute((executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)), settings);
-    if (result.ok)
-        return result.data;
-    if (signal?.aborted)
-        throw ExecutionError.canceled();
-    logger.warn("execution-failed", {
+    return execution.run({
         operation,
-        status: result.status,
-        error: result.message,
-    });
-    throw new ExecutionError(`teams: ${operation} failed`, {
-        context: { operation, status: result.status },
+        settings,
+        execute,
+        fn,
+        signal,
+        canceled: ExecutionError.canceled,
+        failed: (failure) => {
+            logger.warn("execution-failed", {
+                operation: failure.operation,
+                status: failure.status,
+                error: failure.message,
+            });
+            return new ExecutionError(`teams: ${failure.operation} failed`, {
+                context: { operation: failure.operation, status: failure.status },
+            });
+        },
     });
 }
 /**
@@ -140,4 +134,4 @@ export async function postCard(cardDocument, signal) {
         }
     }, signal);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Teams runtime: a lazily-resolved, process-wide config shared by the\n * plugin and the `create_teams_card` tool, so both read one resolved card\n * version / webhook set. The first caller (normally the plugin at setup)\n * primes it from the plugin's config; later callers (the tool's `execute`)\n * reuse it.\n *\n * The runtime also carries the {@link TeamsExecutor} every operation runs\n * through. The plugin installs its own `execute()` there at setup, which is how\n * the tool - a plain function with no plugin instance in scope - still gets\n * AppKit's cache / retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the operations still run, just\n * without interceptors.\n *\n * Like the web-search runtime and unlike the email one, there is no connection\n * pool to hold - card building is in-process and a webhook post is a stateless\n * HTTP call - so the runtime holds only the resolved config and that executor.\n *\n * @module\n */\n\nimport { AppKitError, ExecutionError, type ExecutionResult } from \"@databricks/appkit\";\nimport { async, error, log } from \"@dbx-tools/shared-core\";\nimport { card } from \"@dbx-tools/shared-teams\";\nimport { buildCardResult } from \"./builder.ts\";\nimport { resolveTeamsConfig, type ResolvedTeamsConfig, type TeamsPluginConfig } from \"./config.ts\";\nimport {\n  TEAMS_BUILD_SETTINGS,\n  TEAMS_POST_SETTINGS,\n  type TeamsExecutionSettings,\n} from \"./defaults.ts\";\n\nconst logger = log.logger(\"teams/runtime\");\n\n/**\n * Runs one operation through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type TeamsExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: TeamsExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared resolved config plus the executor operations run through. */\nexport interface TeamsRuntime {\n  config: ResolvedTeamsConfig;\n  execute: TeamsExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the call\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute: TeamsExecutor = async (fn) => {\n  try {\n    return { ok: true, data: await fn() };\n  } catch (err) {\n    return {\n      ok: false,\n      status: err instanceof AppKitError ? err.statusCode : 500,\n      message: error.errorMessage(err),\n    };\n  }\n};\n\nlet runtime: TeamsRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use from the supplied config\n * layered over environment defaults. Overrides are only read when the runtime\n * is first created, so prime it from the plugin's config at setup; subsequent\n * calls (the tool's `execute`) pass nothing and get the same instance.\n */\nexport function getTeamsRuntime(overrides?: TeamsPluginConfig): TeamsRuntime {\n  if (!runtime) {\n    runtime = { config: resolveTeamsConfig(overrides), execute: directExecute };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor operations run through. The plugin calls this at setup\n * with its own `execute()`; a second call replaces the previous one, so a\n * re-registered plugin does not leave the tool bound to a dead instance.\n */\nexport function setTeamsExecutor(execute: TeamsExecutor): void {\n  getTeamsRuntime().execute = execute;\n}\n\n/** Drop the memoized runtime so the next {@link getTeamsRuntime} rebuilds it. */\nexport function resetTeamsRuntime(): void {\n  runtime = undefined;\n}\n\n/**\n * Run one operation through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed call arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised as\n * a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text.\n */\nasync function run<T>(\n  operation: string,\n  settings: TeamsExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getTeamsRuntime();\n  const result = await execute(\n    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),\n    settings,\n  );\n  if (result.ok) return result.data;\n  if (signal?.aborted) throw ExecutionError.canceled();\n  logger.warn(\"execution-failed\", {\n    operation,\n    status: result.status,\n    error: result.message,\n  });\n  throw new ExecutionError(`teams: ${operation} failed`, {\n    context: { operation, status: result.status },\n  });\n}\n\n/**\n * Compile a card spec into an Adaptive Card document, stamped with the runtime's\n * resolved card version. Runs through the shared executor so a build picks up\n * the app's telemetry / timeout chain.\n */\nexport async function buildCard(\n  spec: card.CardSpec,\n  signal?: AbortSignal,\n): Promise<card.CardResult> {\n  const { config } = getTeamsRuntime();\n  return run(\n    \"build\",\n    TEAMS_BUILD_SETTINGS,\n    async () => {\n      const result = buildCardResult(spec);\n      result.card.version = config.cardVersion;\n      return result;\n    },\n    signal,\n  );\n}\n\n/**\n * POST a compiled Adaptive Card to the configured Teams incoming webhook,\n * wrapped in the `MessageCard` attachment envelope Teams expects. Throws when\n * no webhook is configured, so a caller that reaches here without one gets a\n * clear error rather than a silent no-op.\n */\nexport async function postCard(\n  cardDocument: card.AdaptiveCard,\n  signal?: AbortSignal,\n): Promise<void> {\n  const { config } = getTeamsRuntime();\n  const webhookUrl = config.webhookUrl;\n  if (!webhookUrl) {\n    throw new ExecutionError(\"teams: no webhook configured\", {\n      context: { operation: \"post\" },\n    });\n  }\n  await run(\n    \"post\",\n    TEAMS_POST_SETTINGS,\n    async (executeSignal) => {\n      const body = {\n        type: \"message\",\n        attachments: [\n          {\n            contentType: \"application/vnd.microsoft.card.adaptive\",\n            content: cardDocument,\n          },\n        ],\n      };\n      const response = await fetch(webhookUrl, {\n        method: \"POST\",\n        headers: { \"content-type\": \"application/json\" },\n        body: JSON.stringify(body),\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      if (!response.ok) {\n        throw new ExecutionError(`teams: webhook responded ${response.status}`, {\n          context: { operation: \"post\", status: response.status },\n        });\n      }\n    },\n    signal,\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Teams runtime: a lazily-resolved, process-wide config shared by the\n * plugin and the `create_teams_card` tool, so both read one resolved card\n * version / webhook set. The first caller (normally the plugin at setup)\n * primes it from the plugin's config; later callers (the tool's `execute`)\n * reuse it.\n *\n * The runtime also carries the {@link TeamsExecutor} every operation runs\n * through. The plugin installs its own `execute()` there at setup, which is how\n * the tool - a plain function with no plugin instance in scope - still gets\n * AppKit's cache / retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the operations still run, just\n * without interceptors.\n *\n * Like the web-search runtime and unlike the email one, there is no connection\n * pool to hold - card building is in-process and a webhook post is a stateless\n * HTTP call - so the runtime holds only the resolved config and that executor.\n *\n * @module\n */\n\nimport { ExecutionError, type ExecutionResult } from \"@databricks/appkit\";\nimport { execution, log } from \"@dbx-tools/shared-core\";\nimport { card } from \"@dbx-tools/shared-teams\";\nimport { buildCardResult } from \"./builder.ts\";\nimport { resolveTeamsConfig, type ResolvedTeamsConfig, type TeamsPluginConfig } from \"./config.ts\";\nimport {\n  TEAMS_BUILD_SETTINGS,\n  TEAMS_POST_SETTINGS,\n  type TeamsExecutionSettings,\n} from \"./defaults.ts\";\n\nconst logger = log.logger(\"teams/runtime\");\n\n/**\n * Runs one operation through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type TeamsExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: TeamsExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared resolved config plus the executor operations run through. */\nexport interface TeamsRuntime {\n  config: ResolvedTeamsConfig;\n  execute: TeamsExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the call\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute = execution.directExecutor<TeamsExecutionSettings>();\n\nlet runtime: TeamsRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use from the supplied config\n * layered over environment defaults. Overrides are only read when the runtime\n * is first created, so prime it from the plugin's config at setup; subsequent\n * calls (the tool's `execute`) pass nothing and get the same instance.\n */\nexport function getTeamsRuntime(overrides?: TeamsPluginConfig): TeamsRuntime {\n  if (!runtime) {\n    runtime = { config: resolveTeamsConfig(overrides), execute: directExecute };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor operations run through. The plugin calls this at setup\n * with its own `execute()`; a second call replaces the previous one, so a\n * re-registered plugin does not leave the tool bound to a dead instance.\n */\nexport function setTeamsExecutor(execute: TeamsExecutor): void {\n  getTeamsRuntime().execute = execute;\n}\n\n/** Drop the memoized runtime so the next {@link getTeamsRuntime} rebuilds it. */\nexport function resetTeamsRuntime(): void {\n  runtime = undefined;\n}\n\n/**\n * Run one operation through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed call arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised as\n * a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text.\n */\nasync function run<T>(\n  operation: string,\n  settings: TeamsExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getTeamsRuntime();\n  return execution.run({\n    operation,\n    settings,\n    execute,\n    fn,\n    signal,\n    canceled: ExecutionError.canceled,\n    failed: (failure) => {\n      logger.warn(\"execution-failed\", {\n        operation: failure.operation,\n        status: failure.status,\n        error: failure.message,\n      });\n      return new ExecutionError(`teams: ${failure.operation} failed`, {\n        context: { operation: failure.operation, status: failure.status },\n      });\n    },\n  });\n}\n\n/**\n * Compile a card spec into an Adaptive Card document, stamped with the runtime's\n * resolved card version. Runs through the shared executor so a build picks up\n * the app's telemetry / timeout chain.\n */\nexport async function buildCard(\n  spec: card.CardSpec,\n  signal?: AbortSignal,\n): Promise<card.CardResult> {\n  const { config } = getTeamsRuntime();\n  return run(\n    \"build\",\n    TEAMS_BUILD_SETTINGS,\n    async () => {\n      const result = buildCardResult(spec);\n      result.card.version = config.cardVersion;\n      return result;\n    },\n    signal,\n  );\n}\n\n/**\n * POST a compiled Adaptive Card to the configured Teams incoming webhook,\n * wrapped in the `MessageCard` attachment envelope Teams expects. Throws when\n * no webhook is configured, so a caller that reaches here without one gets a\n * clear error rather than a silent no-op.\n */\nexport async function postCard(\n  cardDocument: card.AdaptiveCard,\n  signal?: AbortSignal,\n): Promise<void> {\n  const { config } = getTeamsRuntime();\n  const webhookUrl = config.webhookUrl;\n  if (!webhookUrl) {\n    throw new ExecutionError(\"teams: no webhook configured\", {\n      context: { operation: \"post\" },\n    });\n  }\n  await run(\n    \"post\",\n    TEAMS_POST_SETTINGS,\n    async (executeSignal) => {\n      const body = {\n        type: \"message\",\n        attachments: [\n          {\n            contentType: \"application/vnd.microsoft.card.adaptive\",\n            content: cardDocument,\n          },\n        ],\n      };\n      const response = await fetch(webhookUrl, {\n        method: \"POST\",\n        headers: { \"content-type\": \"application/json\" },\n        body: JSON.stringify(body),\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      if (!response.ok) {\n        throw new ExecutionError(`teams: webhook responded ${response.status}`, {\n          context: { operation: \"post\", status: response.status },\n        });\n      }\n    },\n    signal,\n  );\n}\n"]}

package/package.json

@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/shared-core": "0.6.46",
-    "@dbx-tools/shared-teams": "0.6.46",
+    "@dbx-tools/shared-core": "0.6.49",
+    "@dbx-tools/shared-teams": "0.6.49",
     "@mastra/core": "^1.47.0",
     "jose": "^6.2.3",
     "zod": "4.3.6"
@@ -46,7 +46,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.46",
+  "version": "0.6.49",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/config.ts

@@ -29,7 +29,7 @@
  */
 
 import { ValidationError, type BasePluginConfig } from "@databricks/appkit";
-import { object, string } from "@dbx-tools/shared-core";
+import { env, object } from "@dbx-tools/shared-core";
 import { card } from "@dbx-tools/shared-teams";
 import type { JSONSchema7 } from "json-schema";
 
@@ -198,11 +198,8 @@ export const TEAMS_CONFIG_SCHEMA: JSONSchema7 = {
  */
 export function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeamsConfig {
   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]);
+    env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;
+  const webhookUrl = env.string(overrides?.webhookUrl, WEBHOOK_URL_ENV);
   if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {
     throw ValidationError.invalidValue(
       WEBHOOK_URL_ENV,
@@ -210,52 +207,23 @@ export function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeams
       "an absolute https URL for the Teams webhook",
     );
   }
-  const agentPlugin =
-    string.trimToNull(overrides?.agentPlugin) ??
-    string.trimToNull(process.env[AGENT_PLUGIN_ENV]) ??
-    DEFAULT_AGENT_PLUGIN;
+  const agentPlugin = env.string(overrides?.agentPlugin, 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 requested = env.boolean(overrides?.allowUnauthenticated, 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)),
+    ...object.optional("webhookUrl", webhookUrl),
+    ...object.optional("appId", env.string(overrides?.appId, APP_ID_ENVS)),
+    ...object.optional("appPassword", env.string(overrides?.appPassword, APP_PASSWORD_ENVS)),
+    ...object.optional("appTenantId", env.string(overrides?.appTenantId, 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: readonly string[]): string | null {
-  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<K extends string>(key: K, value: string | null): Record<K, string> | undefined {
-  return value === null ? undefined : ({ [key]: value } as Record<K, string>);
-}
-
 /** Whether `value` parses as an absolute URL. */
 function isAbsoluteUrl(value: string): boolean {
   try {

package/src/runtime.ts

@@ -19,8 +19,8 @@
  * @module
  */
 
-import { AppKitError, ExecutionError, type ExecutionResult } from "@databricks/appkit";
-import { async, error, log } from "@dbx-tools/shared-core";
+import { ExecutionError, type ExecutionResult } from "@databricks/appkit";
+import { execution, log } from "@dbx-tools/shared-core";
 import { card } from "@dbx-tools/shared-teams";
 import { buildCardResult } from "./builder.ts";
 import { resolveTeamsConfig, type ResolvedTeamsConfig, type TeamsPluginConfig } from "./config.ts";
@@ -53,17 +53,7 @@ export interface TeamsRuntime {
  * directly, mapping a throw onto the same {@link ExecutionResult} shape so
  * call sites branch on `ok` either way.
  */
-const directExecute: TeamsExecutor = async (fn) => {
-  try {
-    return { ok: true, data: await fn() };
-  } catch (err) {
-    return {
-      ok: false,
-      status: err instanceof AppKitError ? err.statusCode : 500,
-      message: error.errorMessage(err),
-    };
-  }
-};
+const directExecute = execution.directExecutor<TeamsExecutionSettings>();
 
 let runtime: TeamsRuntime | undefined;
 
@@ -109,19 +99,23 @@ async function run<T>(
   signal?: AbortSignal,
 ): Promise<T> {
   const { execute } = getTeamsRuntime();
-  const result = await execute(
-    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),
-    settings,
-  );
-  if (result.ok) return result.data;
-  if (signal?.aborted) throw ExecutionError.canceled();
-  logger.warn("execution-failed", {
+  return execution.run({
     operation,
-    status: result.status,
-    error: result.message,
-  });
-  throw new ExecutionError(`teams: ${operation} failed`, {
-    context: { operation, status: result.status },
+    settings,
+    execute,
+    fn,
+    signal,
+    canceled: ExecutionError.canceled,
+    failed: (failure) => {
+      logger.warn("execution-failed", {
+        operation: failure.operation,
+        status: failure.status,
+        error: failure.message,
+      });
+      return new ExecutionError(`teams: ${failure.operation} failed`, {
+        context: { operation: failure.operation, status: failure.status },
+      });
+    },
   });
 }