@dbx-tools/teams 0.3.44 → 0.4.0

package/lib/src/plugin.js

@@ -0,0 +1,430 @@
+/**
+ * AppKit plugin (registered name: `teams`) that owns the Teams Adaptive Card
+ * runtime - the resolved card version and the optional incoming-webhook URL the
+ * {@link teamsCardTool} and the AppKit `teams.createCard` tool read. Registering
+ * it resolves and logs the effective config (which card version is in force,
+ * whether a webhook is wired up) so a misconfiguration is visible in the boot
+ * logs rather than on the first card, and installs the plugin's `execute()` as
+ * the runtime's executor so every build / post picks up AppKit's cache / retry /
+ * timeout / telemetry chain.
+ *
+ * The plugin is also a `ToolProvider`, so an AppKit agent can reach a
+ * `teams.createCard` tool directly; the {@link teamsCardTool} export is the same
+ * capability for a Mastra agent. Both share the runtime primed here.
+ *
+ * The plugin mounts four routes under its base path (`/api/teams`):
+ *
+ *   - `POST /messages` is the REAL Microsoft Teams messaging endpoint - the URL
+ *     an Azure Bot registration points at. It validates the Bot Service JWT,
+ *     acknowledges immediately, and delivers the agent's card back over the
+ *     Connector API. This is the route that makes a Teams channel able to chat
+ *     with the app's agents, the same way the Mastra plugin exposes MCP at a
+ *     path.
+ *   - `POST /activity` runs the same turn SYNCHRONOUSLY, answering with the
+ *     reply activities in the response body. It needs no bot registration, so
+ *     it is what a local client (the in-repo preview chat), a test, or any
+ *     non-Teams caller uses.
+ *   - `POST /card` compiles a {@link card.CardSpec} into an Adaptive Card
+ *     document (the preview page posts here).
+ *   - `POST /post` pushes a compiled card to the configured Teams incoming
+ *     webhook when one is set.
+ *
+ * Mirrors the node-email add-on's shape.
+ *
+ * @module
+ */
+import { Plugin, toPlugin, } from "@databricks/appkit";
+import { defineTool, executeFromRegistry, toolsFromRegistry, } from "@databricks/appkit/beta";
+import { error, log, object, string } from "@dbx-tools/shared-core";
+import { activity as activityContract, card } from "@dbx-tools/shared-teams";
+import { verifyBotToken } from "./auth.js";
+import { TEAMS_CONFIG_SCHEMA } from "./config.js";
+import { promptOf, resolveCardAgent, resolveCardContextFactory, runCardTurn } from "./conversation.js";
+import { TEAMS_BUILD_SETTINGS, TEAMS_POST_SETTINGS, TEAMS_TURN_SETTINGS } from "./defaults.js";
+import { deliverTurn, resolveServiceUrl } from "./messaging.js";
+import { buildCard, getTeamsRuntime, postCard, resetTeamsRuntime, setTeamsExecutor, } from "./runtime.js";
+import { CREATE_CARD_DESCRIPTION } from "./tool.js";
+/** Mount-relative route (under `/api/teams`) for compiling a card. */
+const CARD_ROUTE = "/card";
+/** Mount-relative route (under `/api/teams`) for posting a card to a webhook. */
+const POST_ROUTE = "/post";
+/**
+ * Mount-relative route (under `/api/teams`) for one conversation turn: a Bot
+ * Framework activity in, activities carrying Adaptive Cards back.
+ */
+const ACTIVITY_ROUTE = "/activity";
+/**
+ * Mount-relative route (under `/api/teams`) for the Teams messaging endpoint.
+ * This is the path a bot registration's messaging endpoint points at, i.e.
+ * `https://<host>/api/teams/messages`.
+ */
+const MESSAGES_ROUTE = "/messages";
+/** Registry key of the agent tool, which agents address as `teams.createCard`. */
+const CREATE_TOOL = "createCard";
+const logger = log.logger("teams");
+/**
+ * AppKit plugin that configures the Adaptive Card builder used by the
+ * `create_teams_card` tool, and exposes card building as an AppKit agent tool.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as teamsPlugin } from "@dbx-tools/teams";
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     teamsPlugin.teams({ webhookUrl: process.env.TEAMS_WEBHOOK_URL }),
+ *   ],
+ * });
+ * ```
+ */
+export class TeamsPlugin extends Plugin {
+    static manifest = {
+        name: "teams",
+        displayName: "Teams",
+        description: "Answers chat turns as Microsoft Teams Adaptive Cards over a Bot " +
+            "Framework activity endpoint, builds cards from a small structured card " +
+            "description, and optionally posts them to a Teams incoming webhook.",
+        stability: "beta",
+        resources: {
+            required: [],
+            optional: [],
+        },
+        config: { schema: TEAMS_CONFIG_SCHEMA },
+    };
+    /**
+     * The tool this plugin offers to an AppKit agent.
+     *
+     * Marked `autoInheritable`: building a card is a pure, side-effect-free
+     * transform (nothing leaves the building), so it is safe to hand to any
+     * agent by default - unlike a send.
+     *
+     * `execute` re-parses its arguments with the local schema: AppKit validates
+     * against the same schema first, but re-parsing is what gives the body typed
+     * arguments instead of `unknown`.
+     */
+    tools = {
+        [CREATE_TOOL]: defineTool({
+            description: CREATE_CARD_DESCRIPTION,
+            schema: card.cardSpecSchema,
+            annotations: { effect: "read" },
+            autoInheritable: true,
+            execute: async (args, signal) => buildCard(card.cardSpecSchema.parse(args), signal),
+        }),
+    };
+    /**
+     * Prime the shared runtime from this plugin's config (over env), route the
+     * tool's builds through this plugin's interceptor chain, and log the
+     * effective config so the resolved card version and whether a webhook is
+     * wired up are obvious at boot.
+     */
+    async setup() {
+        const { config } = getTeamsRuntime(this.config);
+        setTeamsExecutor((fn, settings) => this.execute(fn, settings));
+        logger.info("ready", {
+            cardVersion: config.cardVersion,
+            webhook: config.webhookUrl ? "configured" : "disabled",
+            messaging: config.allowUnauthenticated
+                ? "UNAUTHENTICATED (development)"
+                : config.appId && config.appPassword
+                    ? "bot registration configured"
+                    : "disabled (no appId/appPassword)",
+        });
+        // An endpoint serving agent turns with no auth is worth a warning on every
+        // boot, not a line buried in an info payload.
+        if (config.allowUnauthenticated) {
+            logger.warn("POST /messages is serving UNAUTHENTICATED turns - any caller that can " +
+                "reach this route can drive the agent. Development only; never expose this.");
+        }
+    }
+    /** Drop the shared runtime. Idempotent. */
+    async shutdown() {
+        resetTeamsRuntime();
+    }
+    /**
+     * Mount the card-building and card-posting routes under the plugin base
+     * path (`/api/teams`). `POST /card` is what the dev display page calls to
+     * preview a card live; `POST /post` pushes a compiled card to the configured
+     * Teams incoming webhook.
+     *
+     * Neither route is wrapped in `asUser(req)`: compiling a card is a pure
+     * transform of the request body and posting goes to a preconfigured webhook,
+     * so neither reads workspace data on the caller's behalf and neither needs an
+     * OBO token. Wrapping them would make the routes throw
+     * `AuthenticationError` whenever the user-token header is absent (a local
+     * `curl`, a health probe), which - since AppKit does not catch a rejection
+     * raised inside the handler - takes the process down rather than answering
+     * 401.
+     */
+    injectRoutes(router) {
+        this.route(router, {
+            name: "buildCard",
+            method: "post",
+            path: CARD_ROUTE,
+            handler: async (req, res) => {
+                const result = await this.executeBuild(req.body);
+                if (!result.ok) {
+                    res.status(result.status).json({ error: result.message });
+                    return;
+                }
+                res.json(result.data);
+            },
+        });
+        this.route(router, {
+            name: "activity",
+            method: "post",
+            path: ACTIVITY_ROUTE,
+            handler: async (req, res) => {
+                const result = await this.executeTurn(req.body);
+                if (!result.ok) {
+                    res.status(result.status).json({ error: result.message });
+                    return;
+                }
+                res.json(result.data);
+            },
+        });
+        this.route(router, {
+            name: "postCard",
+            method: "post",
+            path: POST_ROUTE,
+            handler: async (req, res) => {
+                const result = await this.executePost(req.body);
+                if (!result.ok) {
+                    res.status(result.status).json({ error: result.message });
+                    return;
+                }
+                res.json({ ok: true });
+            },
+        });
+        // The real Teams messaging endpoint. Unlike every other route here it is
+        // called by Azure Bot Service over the public internet, so it authenticates
+        // itself from the inbound JWT and answers `200` before the agent has run.
+        this.route(router, {
+            name: "messages",
+            method: "post",
+            path: MESSAGES_ROUTE,
+            handler: async (req, res) => {
+                await this.handleMessage(req, res);
+            },
+        });
+    }
+    exports() {
+        return {
+            /**
+             * Compile a card spec into an Adaptive Card document. For agent-driven
+             * builds use {@link teamsCardTool} instead.
+             */
+            buildCard: (spec, signal) => buildCard(spec, signal),
+            /**
+             * Post a compiled card to the configured Teams incoming webhook. Throws
+             * when no webhook is configured.
+             */
+            postCard: (cardDocument, signal) => postCard(cardDocument, signal),
+        };
+    }
+    /** AppKit `ToolProvider`: the tool definitions offered to an agent. */
+    getAgentTools() {
+        return toolsFromRegistry(this.tools);
+    }
+    /**
+     * AppKit `ToolProvider`: run one tool call. Arguments are validated against
+     * the tool's schema first, and a validation failure comes back as an
+     * LLM-friendly string so the model can correct itself on the next turn.
+     */
+    async executeAgentTool(name, args, signal) {
+        return executeFromRegistry(this.tools, name, args, signal);
+    }
+    /**
+     * Handle one inbound request from Azure Bot Service on `POST /messages`.
+     *
+     * The order of operations is dictated by how Bot Service behaves, not by
+     * convenience:
+     *
+     *   1. **Refuse when unconfigured.** With no `appId` there is no audience to
+     *      validate a token against, so the endpoint cannot be operated safely;
+     *      it answers 503 rather than processing an unauthenticated activity.
+     *   2. **Validate the JWT before parsing the body.** The token is the only
+     *      trust boundary this endpoint has.
+     *   3. **Pin the reply destination to the token.** `serviceUrl` arrives in the
+     *      body, and replies carry the bot's credentials, so it is only honored
+     *      when it matches the verified token.
+     *   4. **Answer 200 immediately, then run the agent.** Bot Service times out
+     *      an unacknowledged activity in seconds and RETRIES it; a card takes far
+     *      longer than that, and a retry would post a duplicate card.
+     *
+     * Activities that carry no prompt (`typing`, `conversationUpdate`, an
+     * attachment-only message) are acknowledged and dropped - exactly what a bot
+     * does with them.
+     */
+    async handleMessage(req, res) {
+        const { config } = getTeamsRuntime(this.config);
+        // Local development mode: no bot registration, no token, and the reply comes
+        // back in the HTTP response rather than through the Connector API (there is
+        // no `serviceUrl` to call back to). This is what lets the in-repo preview
+        // chat and the Bot Framework Emulator drive the same route Teams uses.
+        if (config.allowUnauthenticated) {
+            // Accept both envelopes: a bare activity (what Bot Service and the
+            // emulator POST) and the `{ activity, agentId }` request shape the
+            // `/activity` route takes, so a local client can still choose an agent.
+            const body = object.isRecord(req.body) && object.isRecord(req.body.activity)
+                ? req.body
+                : { activity: req.body };
+            const result = await this.executeTurn(body);
+            if (!result.ok) {
+                res.status(result.status).json({ error: result.message });
+                return;
+            }
+            res.json(result.data);
+            return;
+        }
+        if (!config.appId || !config.appPassword) {
+            res.status(503).json({
+                error: "teams: messaging endpoint is not configured - set appId/appPassword " +
+                    "(TEAMS_APP_ID / TEAMS_APP_PASSWORD) from the Azure Bot registration",
+            });
+            return;
+        }
+        const authorization = readHeader(req.headers, "authorization");
+        let verified;
+        try {
+            verified = await verifyBotToken(authorization, {
+                appId: config.appId,
+                ...(config.appTenantId ? { appTenantId: config.appTenantId } : {}),
+            });
+        }
+        catch (err) {
+            // Deliberately terse: a caller failing authentication learns only that it
+            // failed, while the reason goes to the logs.
+            logger.warn("rejected an unauthenticated request", { error: error.errorMessage(err) });
+            res.status(401).json({ error: "unauthorized" });
+            return;
+        }
+        const parsed = activityContract.activitySchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: parsed.error.message });
+            return;
+        }
+        const inbound = parsed.data;
+        const serviceUrl = resolveServiceUrl(inbound, verified.serviceUrl);
+        if (!serviceUrl) {
+            logger.warn("rejected an activity with no usable serviceUrl", {
+                type: inbound.type,
+            });
+            res.status(400).json({ error: "activity carried no acceptable serviceUrl" });
+            return;
+        }
+        const agent = resolveCardAgent(this.context?.getPlugins(), config.agentPlugin);
+        if (!agent) {
+            logger.error("no agent available to answer a Teams turn", {
+                agentPlugin: config.agentPlugin,
+            });
+            res.status(503).json({ error: "no agent available" });
+            return;
+        }
+        // Acknowledge FIRST. Everything after this point is out-of-band work whose
+        // result reaches the user through the Connector API, not this response.
+        res.status(200).json({});
+        if (!promptOf(inbound))
+            return;
+        const createRequestContext = resolveCardContextFactory(this.context?.getPlugins(), config.agentPlugin);
+        void deliverTurn({
+            agent,
+            activity: inbound,
+            serviceUrl,
+            ...(createRequestContext ? { createRequestContext } : {}),
+            credentials: {
+                appId: config.appId,
+                appPassword: config.appPassword,
+                ...(config.appTenantId ? { appTenantId: config.appTenantId } : {}),
+            },
+        });
+    }
+    /** Compile a card, validating the request body against the spec schema. */
+    async executeBuild(body) {
+        const parsed = card.cardSpecSchema.safeParse(body);
+        if (!parsed.success) {
+            return { ok: false, status: 400, message: parsed.error.message };
+        }
+        return this.execute(async (signal) => buildCard(parsed.data, signal), TEAMS_BUILD_SETTINGS);
+    }
+    /**
+     * Run one conversation turn: validate the inbound activity, resolve the agent
+     * from the sibling agent plugin, and answer with card-carrying activities.
+     *
+     * Resolution failures are reported distinctly because they have different
+     * fixes: 503 when no agent plugin is mounted at all (a wiring problem), 404
+     * when the caller named an `agentId` that is not registered (a request
+     * problem).
+     */
+    async executeTurn(body) {
+        const parsed = activityContract.activityRequestSchema.safeParse(body);
+        if (!parsed.success) {
+            return { ok: false, status: 400, message: parsed.error.message };
+        }
+        const { activity, agentId } = parsed.data;
+        const { config } = getTeamsRuntime(this.config);
+        const agent = resolveCardAgent(this.context?.getPlugins(), config.agentPlugin, agentId);
+        if (!agent) {
+            return agentId
+                ? { ok: false, status: 404, message: `teams: unknown agent '${agentId}'` }
+                : {
+                    ok: false,
+                    status: 503,
+                    message: `teams: no agent available - is the '${config.agentPlugin}' plugin registered?`,
+                };
+        }
+        const createRequestContext = resolveCardContextFactory(this.context?.getPlugins(), config.agentPlugin);
+        return this.execute(async (signal) => {
+            const activities = await runCardTurn(agent, activity, {
+                ...(createRequestContext ? { createRequestContext } : {}),
+                ...(signal ? { signal } : {}),
+            });
+            return { activities };
+        }, TEAMS_TURN_SETTINGS);
+    }
+    /**
+     * Compile then post a card, validating the request body against the spec
+     * schema. The compile is folded INTO the executed callback so a throw from
+     * either half (a build failure, or `postCard` refusing because no webhook is
+     * configured) comes back as a failed {@link ExecutionResult} the route can
+     * answer with, rather than escaping the handler as an unhandled rejection.
+     */
+    async executePost(body) {
+        const parsed = card.cardSpecSchema.safeParse(body);
+        if (!parsed.success) {
+            return { ok: false, status: 400, message: parsed.error.message };
+        }
+        return this.execute(async (signal) => {
+            const built = await buildCard(parsed.data, signal);
+            await postCard(built.card, signal);
+        }, TEAMS_POST_SETTINGS);
+    }
+}
+/**
+ * Register the Teams plugin.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as teamsPlugin } from "@dbx-tools/teams";
+ *
+ * await createApp({
+ *   plugins: [server(), teamsPlugin.teams()],
+ * });
+ * ```
+ */
+export const teams = toPlugin(TeamsPlugin);
+/**
+ * Read one header value, normalizing Node's `string | string[]` shape.
+ *
+ * Express lower-cases incoming header names, but this is written against a
+ * structural `headers` record (so the handler stays testable without an Express
+ * request), hence the explicit case-insensitive lookup.
+ */
+function readHeader(headers, name) {
+    const direct = headers[name] ?? headers[name.toLowerCase()];
+    const value = Array.isArray(direct) ? direct[0] : direct;
+    return typeof value === "string" ? (string.trimToNull(value) ?? undefined) : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin (registered name: `teams`) that owns the Teams Adaptive Card\n * runtime - the resolved card version and the optional incoming-webhook URL the\n * {@link teamsCardTool} and the AppKit `teams.createCard` tool read. Registering\n * it resolves and logs the effective config (which card version is in force,\n * whether a webhook is wired up) so a misconfiguration is visible in the boot\n * logs rather than on the first card, and installs the plugin's `execute()` as\n * the runtime's executor so every build / post picks up AppKit's cache / retry /\n * timeout / telemetry chain.\n *\n * The plugin is also a `ToolProvider`, so an AppKit agent can reach a\n * `teams.createCard` tool directly; the {@link teamsCardTool} export is the same\n * capability for a Mastra agent. Both share the runtime primed here.\n *\n * The plugin mounts four routes under its base path (`/api/teams`):\n *\n *   - `POST /messages` is the REAL Microsoft Teams messaging endpoint - the URL\n *     an Azure Bot registration points at. It validates the Bot Service JWT,\n *     acknowledges immediately, and delivers the agent's card back over the\n *     Connector API. This is the route that makes a Teams channel able to chat\n *     with the app's agents, the same way the Mastra plugin exposes MCP at a\n *     path.\n *   - `POST /activity` runs the same turn SYNCHRONOUSLY, answering with the\n *     reply activities in the response body. It needs no bot registration, so\n *     it is what a local client (the in-repo preview chat), a test, or any\n *     non-Teams caller uses.\n *   - `POST /card` compiles a {@link card.CardSpec} into an Adaptive Card\n *     document (the preview page posts here).\n *   - `POST /post` pushes a compiled card to the configured Teams incoming\n *     webhook when one is set.\n *\n * Mirrors the node-email add-on's shape.\n *\n * @module\n */\n\nimport {\n  Plugin,\n  toPlugin,\n  type ExecutionResult,\n  type IAppRouter,\n  type PluginManifest,\n} from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  toolsFromRegistry,\n  type AgentToolDefinition,\n  type ToolProvider,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport { error, log, object, string } from \"@dbx-tools/shared-core\";\nimport { activity as activityContract, card } from \"@dbx-tools/shared-teams\";\nimport { verifyBotToken } from \"./auth\";\nimport { TEAMS_CONFIG_SCHEMA, type TeamsPluginConfig } from \"./config\";\nimport { promptOf, resolveCardAgent, resolveCardContextFactory, runCardTurn } from \"./conversation\";\nimport { TEAMS_BUILD_SETTINGS, TEAMS_POST_SETTINGS, TEAMS_TURN_SETTINGS } from \"./defaults\";\nimport { deliverTurn, resolveServiceUrl } from \"./messaging\";\nimport {\n  buildCard,\n  getTeamsRuntime,\n  postCard,\n  resetTeamsRuntime,\n  setTeamsExecutor,\n} from \"./runtime\";\nimport { CREATE_CARD_DESCRIPTION } from \"./tool\";\n\n/** Mount-relative route (under `/api/teams`) for compiling a card. */\nconst CARD_ROUTE = \"/card\";\n\n/** Mount-relative route (under `/api/teams`) for posting a card to a webhook. */\nconst POST_ROUTE = \"/post\";\n\n/**\n * Mount-relative route (under `/api/teams`) for one conversation turn: a Bot\n * Framework activity in, activities carrying Adaptive Cards back.\n */\nconst ACTIVITY_ROUTE = \"/activity\";\n\n/**\n * Mount-relative route (under `/api/teams`) for the Teams messaging endpoint.\n * This is the path a bot registration's messaging endpoint points at, i.e.\n * `https://<host>/api/teams/messages`.\n */\nconst MESSAGES_ROUTE = \"/messages\";\n\n/** Registry key of the agent tool, which agents address as `teams.createCard`. */\nconst CREATE_TOOL = \"createCard\";\n\nconst logger = log.logger(\"teams\");\n\n/**\n * AppKit plugin that configures the Adaptive Card builder used by the\n * `create_teams_card` tool, and exposes card building as an AppKit agent tool.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as teamsPlugin } from \"@dbx-tools/teams\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     teamsPlugin.teams({ webhookUrl: process.env.TEAMS_WEBHOOK_URL }),\n *   ],\n * });\n * ```\n */\nexport class TeamsPlugin extends Plugin<TeamsPluginConfig> implements ToolProvider {\n  static manifest = {\n    name: \"teams\",\n    displayName: \"Teams\",\n    description:\n      \"Answers chat turns as Microsoft Teams Adaptive Cards over a Bot \" +\n      \"Framework activity endpoint, builds cards from a small structured card \" +\n      \"description, and optionally posts them to a Teams incoming webhook.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [],\n    },\n    config: { schema: TEAMS_CONFIG_SCHEMA },\n  } satisfies PluginManifest<\"teams\">;\n\n  /**\n   * The tool this plugin offers to an AppKit agent.\n   *\n   * Marked `autoInheritable`: building a card is a pure, side-effect-free\n   * transform (nothing leaves the building), so it is safe to hand to any\n   * agent by default - unlike a send.\n   *\n   * `execute` re-parses its arguments with the local schema: AppKit validates\n   * against the same schema first, but re-parsing is what gives the body typed\n   * arguments instead of `unknown`.\n   */\n  private readonly tools: ToolRegistry = {\n    [CREATE_TOOL]: defineTool({\n      description: CREATE_CARD_DESCRIPTION,\n      schema: card.cardSpecSchema,\n      annotations: { effect: \"read\" },\n      autoInheritable: true,\n      execute: async (args, signal) => buildCard(card.cardSpecSchema.parse(args), signal),\n    }),\n  };\n\n  /**\n   * Prime the shared runtime from this plugin's config (over env), route the\n   * tool's builds through this plugin's interceptor chain, and log the\n   * effective config so the resolved card version and whether a webhook is\n   * wired up are obvious at boot.\n   */\n  override async setup(): Promise<void> {\n    const { config } = getTeamsRuntime(this.config);\n    setTeamsExecutor((fn, settings) => this.execute(fn, settings));\n    logger.info(\"ready\", {\n      cardVersion: config.cardVersion,\n      webhook: config.webhookUrl ? \"configured\" : \"disabled\",\n      messaging: config.allowUnauthenticated\n        ? \"UNAUTHENTICATED (development)\"\n        : config.appId && config.appPassword\n          ? \"bot registration configured\"\n          : \"disabled (no appId/appPassword)\",\n    });\n    // An endpoint serving agent turns with no auth is worth a warning on every\n    // boot, not a line buried in an info payload.\n    if (config.allowUnauthenticated) {\n      logger.warn(\n        \"POST /messages is serving UNAUTHENTICATED turns - any caller that can \" +\n          \"reach this route can drive the agent. Development only; never expose this.\",\n      );\n    }\n  }\n\n  /** Drop the shared runtime. Idempotent. */\n  async shutdown(): Promise<void> {\n    resetTeamsRuntime();\n  }\n\n  /**\n   * Mount the card-building and card-posting routes under the plugin base\n   * path (`/api/teams`). `POST /card` is what the dev display page calls to\n   * preview a card live; `POST /post` pushes a compiled card to the configured\n   * Teams incoming webhook.\n   *\n   * Neither route is wrapped in `asUser(req)`: compiling a card is a pure\n   * transform of the request body and posting goes to a preconfigured webhook,\n   * so neither reads workspace data on the caller's behalf and neither needs an\n   * OBO token. Wrapping them would make the routes throw\n   * `AuthenticationError` whenever the user-token header is absent (a local\n   * `curl`, a health probe), which - since AppKit does not catch a rejection\n   * raised inside the handler - takes the process down rather than answering\n   * 401.\n   */\n  override injectRoutes(router: IAppRouter): void {\n    this.route(router, {\n      name: \"buildCard\",\n      method: \"post\",\n      path: CARD_ROUTE,\n      handler: async (req, res) => {\n        const result = await this.executeBuild(req.body);\n        if (!result.ok) {\n          res.status(result.status).json({ error: result.message });\n          return;\n        }\n        res.json(result.data);\n      },\n    });\n    this.route(router, {\n      name: \"activity\",\n      method: \"post\",\n      path: ACTIVITY_ROUTE,\n      handler: async (req, res) => {\n        const result = await this.executeTurn(req.body);\n        if (!result.ok) {\n          res.status(result.status).json({ error: result.message });\n          return;\n        }\n        res.json(result.data);\n      },\n    });\n    this.route(router, {\n      name: \"postCard\",\n      method: \"post\",\n      path: POST_ROUTE,\n      handler: async (req, res) => {\n        const result = await this.executePost(req.body);\n        if (!result.ok) {\n          res.status(result.status).json({ error: result.message });\n          return;\n        }\n        res.json({ ok: true });\n      },\n    });\n    // The real Teams messaging endpoint. Unlike every other route here it is\n    // called by Azure Bot Service over the public internet, so it authenticates\n    // itself from the inbound JWT and answers `200` before the agent has run.\n    this.route(router, {\n      name: \"messages\",\n      method: \"post\",\n      path: MESSAGES_ROUTE,\n      handler: async (req, res) => {\n        await this.handleMessage(req, res);\n      },\n    });\n  }\n\n  override exports() {\n    return {\n      /**\n       * Compile a card spec into an Adaptive Card document. For agent-driven\n       * builds use {@link teamsCardTool} instead.\n       */\n      buildCard: (spec: card.CardSpec, signal?: AbortSignal): Promise<card.CardResult> =>\n        buildCard(spec, signal),\n      /**\n       * Post a compiled card to the configured Teams incoming webhook. Throws\n       * when no webhook is configured.\n       */\n      postCard: (cardDocument: card.AdaptiveCard, signal?: AbortSignal): Promise<void> =>\n        postCard(cardDocument, signal),\n    };\n  }\n\n  /** AppKit `ToolProvider`: the tool definitions offered to an agent. */\n  getAgentTools(): AgentToolDefinition[] {\n    return toolsFromRegistry(this.tools);\n  }\n\n  /**\n   * AppKit `ToolProvider`: run one tool call. Arguments are validated against\n   * the tool's schema first, and a validation failure comes back as an\n   * LLM-friendly string so the model can correct itself on the next turn.\n   */\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    return executeFromRegistry(this.tools, name, args, signal);\n  }\n\n  /**\n   * Handle one inbound request from Azure Bot Service on `POST /messages`.\n   *\n   * The order of operations is dictated by how Bot Service behaves, not by\n   * convenience:\n   *\n   *   1. **Refuse when unconfigured.** With no `appId` there is no audience to\n   *      validate a token against, so the endpoint cannot be operated safely;\n   *      it answers 503 rather than processing an unauthenticated activity.\n   *   2. **Validate the JWT before parsing the body.** The token is the only\n   *      trust boundary this endpoint has.\n   *   3. **Pin the reply destination to the token.** `serviceUrl` arrives in the\n   *      body, and replies carry the bot's credentials, so it is only honored\n   *      when it matches the verified token.\n   *   4. **Answer 200 immediately, then run the agent.** Bot Service times out\n   *      an unacknowledged activity in seconds and RETRIES it; a card takes far\n   *      longer than that, and a retry would post a duplicate card.\n   *\n   * Activities that carry no prompt (`typing`, `conversationUpdate`, an\n   * attachment-only message) are acknowledged and dropped - exactly what a bot\n   * does with them.\n   */\n  private async handleMessage(\n    req: { headers: Record<string, unknown>; body: unknown },\n    res: {\n      status(code: number): { json(body: unknown): void };\n      json(body: unknown): void;\n      headersSent?: boolean;\n    },\n  ): Promise<void> {\n    const { config } = getTeamsRuntime(this.config);\n\n    // Local development mode: no bot registration, no token, and the reply comes\n    // back in the HTTP response rather than through the Connector API (there is\n    // no `serviceUrl` to call back to). This is what lets the in-repo preview\n    // chat and the Bot Framework Emulator drive the same route Teams uses.\n    if (config.allowUnauthenticated) {\n      // Accept both envelopes: a bare activity (what Bot Service and the\n      // emulator POST) and the `{ activity, agentId }` request shape the\n      // `/activity` route takes, so a local client can still choose an agent.\n      const body =\n        object.isRecord(req.body) && object.isRecord(req.body.activity)\n          ? req.body\n          : { activity: req.body };\n      const result = await this.executeTurn(body);\n      if (!result.ok) {\n        res.status(result.status).json({ error: result.message });\n        return;\n      }\n      res.json(result.data);\n      return;\n    }\n\n    if (!config.appId || !config.appPassword) {\n      res.status(503).json({\n        error:\n          \"teams: messaging endpoint is not configured - set appId/appPassword \" +\n          \"(TEAMS_APP_ID / TEAMS_APP_PASSWORD) from the Azure Bot registration\",\n      });\n      return;\n    }\n\n    const authorization = readHeader(req.headers, \"authorization\");\n    let verified;\n    try {\n      verified = await verifyBotToken(authorization, {\n        appId: config.appId,\n        ...(config.appTenantId ? { appTenantId: config.appTenantId } : {}),\n      });\n    } catch (err) {\n      // Deliberately terse: a caller failing authentication learns only that it\n      // failed, while the reason goes to the logs.\n      logger.warn(\"rejected an unauthenticated request\", { error: error.errorMessage(err) });\n      res.status(401).json({ error: \"unauthorized\" });\n      return;\n    }\n\n    const parsed = activityContract.activitySchema.safeParse(req.body);\n    if (!parsed.success) {\n      res.status(400).json({ error: parsed.error.message });\n      return;\n    }\n    const inbound = parsed.data;\n\n    const serviceUrl = resolveServiceUrl(inbound, verified.serviceUrl);\n    if (!serviceUrl) {\n      logger.warn(\"rejected an activity with no usable serviceUrl\", {\n        type: inbound.type,\n      });\n      res.status(400).json({ error: \"activity carried no acceptable serviceUrl\" });\n      return;\n    }\n\n    const agent = resolveCardAgent(this.context?.getPlugins(), config.agentPlugin);\n    if (!agent) {\n      logger.error(\"no agent available to answer a Teams turn\", {\n        agentPlugin: config.agentPlugin,\n      });\n      res.status(503).json({ error: \"no agent available\" });\n      return;\n    }\n\n    // Acknowledge FIRST. Everything after this point is out-of-band work whose\n    // result reaches the user through the Connector API, not this response.\n    res.status(200).json({});\n\n    if (!promptOf(inbound)) return;\n\n    const createRequestContext = resolveCardContextFactory(\n      this.context?.getPlugins(),\n      config.agentPlugin,\n    );\n\n    void deliverTurn({\n      agent,\n      activity: inbound,\n      serviceUrl,\n      ...(createRequestContext ? { createRequestContext } : {}),\n      credentials: {\n        appId: config.appId,\n        appPassword: config.appPassword,\n        ...(config.appTenantId ? { appTenantId: config.appTenantId } : {}),\n      },\n    });\n  }\n\n  /** Compile a card, validating the request body against the spec schema. */\n  private async executeBuild(body: unknown): Promise<ExecutionResult<card.CardResult>> {\n    const parsed = card.cardSpecSchema.safeParse(body);\n    if (!parsed.success) {\n      return { ok: false, status: 400, message: parsed.error.message };\n    }\n    return this.execute(async (signal) => buildCard(parsed.data, signal), TEAMS_BUILD_SETTINGS);\n  }\n\n  /**\n   * Run one conversation turn: validate the inbound activity, resolve the agent\n   * from the sibling agent plugin, and answer with card-carrying activities.\n   *\n   * Resolution failures are reported distinctly because they have different\n   * fixes: 503 when no agent plugin is mounted at all (a wiring problem), 404\n   * when the caller named an `agentId` that is not registered (a request\n   * problem).\n   */\n  private async executeTurn(\n    body: unknown,\n  ): Promise<ExecutionResult<activityContract.ActivityResponse>> {\n    const parsed = activityContract.activityRequestSchema.safeParse(body);\n    if (!parsed.success) {\n      return { ok: false, status: 400, message: parsed.error.message };\n    }\n    const { activity, agentId } = parsed.data;\n    const { config } = getTeamsRuntime(this.config);\n    const agent = resolveCardAgent(this.context?.getPlugins(), config.agentPlugin, agentId);\n    if (!agent) {\n      return agentId\n        ? { ok: false, status: 404, message: `teams: unknown agent '${agentId}'` }\n        : {\n            ok: false,\n            status: 503,\n            message: `teams: no agent available - is the '${config.agentPlugin}' plugin registered?`,\n          };\n    }\n    const createRequestContext = resolveCardContextFactory(\n      this.context?.getPlugins(),\n      config.agentPlugin,\n    );\n    return this.execute(async (signal) => {\n      const activities = await runCardTurn(agent, activity, {\n        ...(createRequestContext ? { createRequestContext } : {}),\n        ...(signal ? { signal } : {}),\n      });\n      return { activities };\n    }, TEAMS_TURN_SETTINGS);\n  }\n\n  /**\n   * Compile then post a card, validating the request body against the spec\n   * schema. The compile is folded INTO the executed callback so a throw from\n   * either half (a build failure, or `postCard` refusing because no webhook is\n   * configured) comes back as a failed {@link ExecutionResult} the route can\n   * answer with, rather than escaping the handler as an unhandled rejection.\n   */\n  private async executePost(body: unknown): Promise<ExecutionResult<void>> {\n    const parsed = card.cardSpecSchema.safeParse(body);\n    if (!parsed.success) {\n      return { ok: false, status: 400, message: parsed.error.message };\n    }\n    return this.execute(async (signal) => {\n      const built = await buildCard(parsed.data, signal);\n      await postCard(built.card, signal);\n    }, TEAMS_POST_SETTINGS);\n  }\n}\n\n/**\n * Register the Teams plugin.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as teamsPlugin } from \"@dbx-tools/teams\";\n *\n * await createApp({\n *   plugins: [server(), teamsPlugin.teams()],\n * });\n * ```\n */\nexport const teams = toPlugin(TeamsPlugin);\n\n/**\n * Read one header value, normalizing Node's `string | string[]` shape.\n *\n * Express lower-cases incoming header names, but this is written against a\n * structural `headers` record (so the handler stays testable without an Express\n * request), hence the explicit case-insensitive lookup.\n */\nfunction readHeader(headers: Record<string, unknown>, name: string): string | undefined {\n  const direct = headers[name] ?? headers[name.toLowerCase()];\n  const value = Array.isArray(direct) ? direct[0] : direct;\n  return typeof value === \"string\" ? (string.trimToNull(value) ?? undefined) : undefined;\n}\n"]}

package/lib/src/runtime.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The Teams runtime: a lazily-resolved, process-wide config shared by the
+ * plugin and the `create_teams_card` tool, so both read one resolved card
+ * version / webhook set. The first caller (normally the plugin at setup)
+ * primes it from the plugin's config; later callers (the tool's `execute`)
+ * reuse it.
+ *
+ * The runtime also carries the {@link TeamsExecutor} every operation runs
+ * through. The plugin installs its own `execute()` there at setup, which is how
+ * the tool - a plain function with no plugin instance in scope - still gets
+ * AppKit's cache / retry / timeout / telemetry chain. Without a registered
+ * plugin (a direct call from a script or a test) the operations still run, just
+ * without interceptors.
+ *
+ * Like the web-search runtime and unlike the email one, there is no connection
+ * pool to hold - card building is in-process and a webhook post is a stateless
+ * HTTP call - so the runtime holds only the resolved config and that executor.
+ *
+ * @module
+ */
+import { type ExecutionResult } from "@databricks/appkit";
+import { card } from "@dbx-tools/shared-teams";
+import { type ResolvedTeamsConfig, type TeamsPluginConfig } from "./config.js";
+import { type TeamsExecutionSettings } from "./defaults.js";
+/**
+ * Runs one operation through AppKit's interceptor chain. Matches
+ * `Plugin.execute()`, which never throws: a failure comes back as
+ * `{ ok: false }`.
+ */
+export type TeamsExecutor = <T>(fn: (signal?: AbortSignal) => Promise<T>, settings: TeamsExecutionSettings) => Promise<ExecutionResult<T>>;
+/** The shared resolved config plus the executor operations run through. */
+export interface TeamsRuntime {
+    config: ResolvedTeamsConfig;
+    execute: TeamsExecutor;
+}
+/**
+ * Return the shared runtime, building it on first use from the supplied config
+ * layered over environment defaults. Overrides are only read when the runtime
+ * is first created, so prime it from the plugin's config at setup; subsequent
+ * calls (the tool's `execute`) pass nothing and get the same instance.
+ */
+export declare function getTeamsRuntime(overrides?: TeamsPluginConfig): TeamsRuntime;
+/**
+ * Install the executor operations run through. The plugin calls this at setup
+ * with its own `execute()`; a second call replaces the previous one, so a
+ * re-registered plugin does not leave the tool bound to a dead instance.
+ */
+export declare function setTeamsExecutor(execute: TeamsExecutor): void;
+/** Drop the memoized runtime so the next {@link getTeamsRuntime} rebuilds it. */
+export declare function resetTeamsRuntime(): void;
+/**
+ * Compile a card spec into an Adaptive Card document, stamped with the runtime's
+ * resolved card version. Runs through the shared executor so a build picks up
+ * the app's telemetry / timeout chain.
+ */
+export declare function buildCard(spec: card.CardSpec, signal?: AbortSignal): Promise<card.CardResult>;
+/**
+ * POST a compiled Adaptive Card to the configured Teams incoming webhook,
+ * wrapped in the `MessageCard` attachment envelope Teams expects. Throws when
+ * no webhook is configured, so a caller that reaches here without one gets a
+ * clear error rather than a silent no-op.
+ */
+export declare function postCard(cardDocument: card.AdaptiveCard, signal?: AbortSignal): Promise<void>;