@dbx-tools/teams 0.3.44 → 0.4.0

package/lib/src/runtime.js

@@ -0,0 +1,143 @@
+/**
+ * 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 { AppKitError, ExecutionError } from "@databricks/appkit";
+import { async, error, 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";
+const logger = log.logger("teams/runtime");
+/**
+ * Executor used until (or unless) the plugin installs its own: run the call
+ * 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),
+        };
+    }
+};
+let runtime;
+/**
+ * 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 function getTeamsRuntime(overrides) {
+    if (!runtime) {
+        runtime = { config: resolveTeamsConfig(overrides), execute: directExecute };
+    }
+    return runtime;
+}
+/**
+ * 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 function setTeamsExecutor(execute) {
+    getTeamsRuntime().execute = execute;
+}
+/** Drop the memoized runtime so the next {@link getTeamsRuntime} rebuilds it. */
+export function resetTeamsRuntime() {
+    runtime = undefined;
+}
+/**
+ * Run one operation through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed call arrives as `{ ok: false }` with a
+ * status the interceptors already sanitized; it is logged here and re-raised as
+ * a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text.
+ */
+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", {
+        operation,
+        status: result.status,
+        error: result.message,
+    });
+    throw new ExecutionError(`teams: ${operation} failed`, {
+        context: { operation, status: result.status },
+    });
+}
+/**
+ * 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 async function buildCard(spec, signal) {
+    const { config } = getTeamsRuntime();
+    return run("build", TEAMS_BUILD_SETTINGS, async () => {
+        const result = buildCardResult(spec);
+        result.card.version = config.cardVersion;
+        return result;
+    }, signal);
+}
+/**
+ * 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 async function postCard(cardDocument, signal) {
+    const { config } = getTeamsRuntime();
+    const webhookUrl = config.webhookUrl;
+    if (!webhookUrl) {
+        throw new ExecutionError("teams: no webhook configured", {
+            context: { operation: "post" },
+        });
+    }
+    await run("post", TEAMS_POST_SETTINGS, async (executeSignal) => {
+        const body = {
+            type: "message",
+            attachments: [
+                {
+                    contentType: "application/vnd.microsoft.card.adaptive",
+                    content: cardDocument,
+                },
+            ],
+        };
+        const response = await fetch(webhookUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            ...(executeSignal ? { signal: executeSignal } : {}),
+        });
+        if (!response.ok) {
+            throw new ExecutionError(`teams: webhook responded ${response.status}`, {
+                context: { operation: "post", status: response.status },
+            });
+        }
+    }, 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\";\nimport { resolveTeamsConfig, type ResolvedTeamsConfig, type TeamsPluginConfig } from \"./config\";\nimport { TEAMS_BUILD_SETTINGS, TEAMS_POST_SETTINGS, type TeamsExecutionSettings } from \"./defaults\";\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"]}

package/lib/src/tool.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The `create_teams_card` Mastra tool: a model describes a card in the small
+ * {@link card.CardSpec} vocabulary and gets back a compiled Adaptive Card
+ * document. Unlike `send_email`, building a card is a pure, side-effect-free
+ * transform - nothing leaves the building - so it is NOT approval-gated: the
+ * card is data the app then decides what to do with (render it in a preview,
+ * post it to a Teams incoming webhook, attach it to a bot reply).
+ *
+ * The build runs through the executor the plugin installs on the shared
+ * runtime, so a build from this tool picks up the same telemetry / timeout
+ * chain as one from the AppKit tool. In a Mastra app with no AppKit plugin
+ * registered the build still runs, just without interceptors.
+ *
+ * @module
+ */
+/**
+ * The model-facing description of the card-building capability, shared by the
+ * Mastra {@link teamsCardTool} and the AppKit `teams.createCard` tool so both
+ * agents get the same guidance about the vocabulary and when to reach for it.
+ */
+export declare const CREATE_CARD_DESCRIPTION: string;
+/** Options accepted by {@link teamsCardTool}. */
+export interface TeamsCardToolOptions {
+    /**
+     * Override the tool id. Defaults to `"create_teams_card"`. A UI that renders
+     * the returned card keys off this id, so keep it unless you also teach the
+     * client about the new name.
+     */
+    id?: string;
+}
+/**
+ * Build the `create_teams_card` tool. Spread it into the agents that should be
+ * able to produce Teams cards.
+ *
+ * @example
+ * ```ts
+ * import { teamsCardTool } from "@dbx-tools/teams";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = createAgent({
+ *   instructions: "...",
+ *   tools: () => ({ create_teams_card: teamsCardTool() }),
+ * });
+ * ```
+ */
+export declare function teamsCardTool(opts?: TeamsCardToolOptions): import("@mastra/core/tools").Tool<{
+    title: string;
+    subtitle?: string | undefined;
+    text?: string | undefined;
+    facts?: {
+        title: string;
+        value: string;
+    }[] | undefined;
+    actions?: {
+        title: string;
+        url: string;
+    }[] | undefined;
+}, {
+    title: string;
+    card: {
+        type: "AdaptiveCard";
+        $schema: string;
+        version: string;
+        body: Record<string, unknown>[];
+        actions?: Record<string, unknown>[] | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;

package/lib/src/tool.js

@@ -0,0 +1,71 @@
+/**
+ * The `create_teams_card` Mastra tool: a model describes a card in the small
+ * {@link card.CardSpec} vocabulary and gets back a compiled Adaptive Card
+ * document. Unlike `send_email`, building a card is a pure, side-effect-free
+ * transform - nothing leaves the building - so it is NOT approval-gated: the
+ * card is data the app then decides what to do with (render it in a preview,
+ * post it to a Teams incoming webhook, attach it to a bot reply).
+ *
+ * The build runs through the executor the plugin installs on the shared
+ * runtime, so a build from this tool picks up the same telemetry / timeout
+ * chain as one from the AppKit tool. In a Mastra app with no AppKit plugin
+ * registered the build still runs, just without interceptors.
+ *
+ * @module
+ */
+import { log, string } from "@dbx-tools/shared-core";
+import { card } from "@dbx-tools/shared-teams";
+import { createTool } from "@mastra/core/tools";
+import { buildCard } from "./runtime.js";
+const logger = log.logger("teams/tool/create-card");
+/**
+ * The model-facing description of the card-building capability, shared by the
+ * Mastra {@link teamsCardTool} and the AppKit `teams.createCard` tool so both
+ * agents get the same guidance about the vocabulary and when to reach for it.
+ */
+export const CREATE_CARD_DESCRIPTION = string.toDescription(`
+  Build a Microsoft Teams Adaptive Card from a short structured description.
+  Provide a title, an optional subtitle and body text, an optional list of
+  key/value facts, and optional link buttons; the tool returns a compiled
+  Adaptive Card document (Adaptive Card 1.5) ready to render or post to Teams.
+  Use it when the user asks to summarize a status, result, or record as a Teams
+  card / message card, or to prepare something to post to a channel. Keep body
+  text to the Teams Markdown subset - **bold**, _italic_, links, and '-'
+  bullet lists - and put tabular key/value detail in the 'facts' array, not in
+  the text. Do NOT hand-author raw Adaptive Card JSON; describe the card and
+  this tool compiles the valid document.
+`);
+/**
+ * Build the `create_teams_card` tool. Spread it into the agents that should be
+ * able to produce Teams cards.
+ *
+ * @example
+ * ```ts
+ * import { teamsCardTool } from "@dbx-tools/teams";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = createAgent({
+ *   instructions: "...",
+ *   tools: () => ({ create_teams_card: teamsCardTool() }),
+ * });
+ * ```
+ */
+export function teamsCardTool(opts = {}) {
+    return createTool({
+        id: opts.id ?? "create_teams_card",
+        description: CREATE_CARD_DESCRIPTION,
+        inputSchema: card.cardSpecSchema,
+        outputSchema: card.cardResultSchema,
+        execute: async (input, context) => {
+            const spec = card.cardSpecSchema.parse(input);
+            const result = await buildCard(spec, context?.abortSignal);
+            logger.info("built", {
+                title: result.title,
+                elements: result.card.body.length,
+                actions: result.card.actions?.length ?? 0,
+            });
+            return result;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/auth.ts","../src/builder.ts","../src/config.ts","../src/connector.ts","../src/conversation.ts","../src/defaults.ts","../src/messaging.ts","../src/plugin.ts","../src/runtime.ts","../src/tool.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -17,24 +17,28 @@
     "@mastra/core": "^1.47.0",
     "jose": "^6.2.3",
     "zod": "4.3.6",
-    "@dbx-tools/shared-core": "0.3.44",
-    "@dbx-tools/shared-teams": "0.3.44"
+    "@dbx-tools/shared-core": "0.4.0",
+    "@dbx-tools/shared-teams": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [