@cuylabs/channel-teams-agent-core 0.4.0

package/dist/index.js

@@ -0,0 +1,836 @@
+import {
+  Conversation,
+  ConversationBuilder,
+  ConversationReferenceBuilder,
+  CreateConversationOptionsBuilder,
+  captureM365ConversationReference,
+  captureTeamsConversationReference,
+  continueM365Conversation,
+  restoreM365ConversationReference
+} from "./chunk-ZULHZARA.js";
+
+// src/index.ts
+export * from "@cuylabs/channel-teams";
+
+// src/adapter.ts
+import {
+  createM365ChannelAdapter,
+  extractUserIdentity,
+  runWithM365TurnContext
+} from "@cuylabs/channel-m365-agent-core";
+import { ActivityTypes } from "@microsoft/agents-activity";
+import { parseTeamsActivity, sendTeamsInvoke } from "@cuylabs/channel-teams";
+function createTeamsChannelAdapter(options) {
+  const {
+    prepareTurn,
+    handlers,
+    onInvoke: fallbackInvoke,
+    onTurn: onTurnHook,
+    strictChannelData,
+    ...baseOptions
+  } = options;
+  const base = createM365ChannelAdapter({
+    ...baseOptions,
+    prepareTurn: async (request) => {
+      const teams = parseTeamsActivity(request.turnContext, {
+        strictChannelData
+      });
+      const prepared = prepareTurn ? await prepareTurn({
+        ...request,
+        teams,
+        channelData: teams.channelData
+      }) : void 0;
+      return {
+        ...prepared ?? {},
+        scopeName: prepared?.scopeName?.trim() || "teams-activity",
+        scopeAttributes: {
+          teamsKind: teams.kind,
+          teamsSurface: teams.surface,
+          teamsTenantId: teams.tenantId,
+          teamsTeamId: teams.teamId,
+          teamsChannelId: teams.channelThreadId,
+          teamsMeetingId: teams.meetingId,
+          teamsInvokeName: teams.invokeName,
+          teamsEventType: teams.eventType,
+          ...prepared?.scopeAttributes ?? {}
+        },
+        context: {
+          ...prepared?.context ?? {},
+          teams
+        }
+      };
+    },
+    onInvoke: async (context) => {
+      const teams = parseTeamsActivity(context, {
+        strictChannelData
+      });
+      const dispatch = await dispatchTeamsHandler(
+        handlers,
+        teams.kind,
+        await createHandlerContext(options, base, context, teams)
+      );
+      if (!dispatch.handled && fallbackInvoke) {
+        await fallbackInvoke(context);
+      } else if (!dispatch.handled) {
+        await sendTeamsInvoke(context, void 0, 501);
+      }
+    }
+  });
+  async function coreHandler(context) {
+    const teams = parseTeamsActivity(context, {
+      strictChannelData
+    });
+    if (teams.channelId !== "msteams") {
+      await base.handler(context);
+      return;
+    }
+    const isTeamsSpecificEvent = context.activity.type === ActivityTypes.Event && teams.kind !== "other";
+    const isTeamsSpecificActivity = context.activity.type === ActivityTypes.ConversationUpdate || context.activity.type === ActivityTypes.MessageUpdate || context.activity.type === ActivityTypes.MessageDelete || context.activity.type === ActivityTypes.MessageReaction || isTeamsSpecificEvent;
+    if (isTeamsSpecificActivity) {
+      const dispatch = await dispatchTeamsHandler(
+        handlers,
+        teams.kind,
+        await createHandlerContext(options, base, context, teams)
+      );
+      if (dispatch.handled) {
+        return;
+      }
+    }
+    await base.handler(context);
+  }
+  async function handler(context) {
+    if (onTurnHook) {
+      await onTurnHook(context, () => coreHandler(context));
+    } else {
+      await coreHandler(context);
+    }
+  }
+  return {
+    ...base,
+    handler,
+    m365: base
+  };
+}
+async function createHandlerContext(options, base, turnContext, teams = parseTeamsActivity(turnContext)) {
+  const conversationId = turnContext.activity.conversation?.id ?? "unknown";
+  const channelId = turnContext.activity.channelId ?? "unknown";
+  const sessionId = await base.getSessionId(conversationId, channelId);
+  const user = extractUserIdentity(turnContext);
+  const source = resolveSource(options);
+  const ambient = {
+    turnContext,
+    user,
+    sessionId,
+    message: (turnContext.activity.text ?? "").trim(),
+    teams,
+    context: { teams }
+  };
+  const context = {
+    turnContext,
+    user,
+    teams,
+    channelData: teams.channelData,
+    sessionId,
+    source,
+    runAgent(message, runOptions) {
+      return runAgentWithTeamsContext(
+        ambient,
+        source,
+        sessionId,
+        message,
+        runOptions
+      );
+    },
+    async sendInvoke(body, status = 200) {
+      setInvokeResponseSent(context, true);
+      await sendTeamsInvoke(turnContext, body, status);
+    }
+  };
+  setInvokeResponseSent(context, false);
+  return context;
+}
+async function dispatchTeamsHandler(handlers, kind, context) {
+  const handler = resolveHandler(handlers, kind);
+  if (!handler) {
+    return { handled: false };
+  }
+  const result = await handler(context);
+  if (context.turnContext.activity.type === ActivityTypes.Invoke && result !== "continue") {
+    if (!getInvokeResponseSent(context) && isTeamsInvokeResult(result)) {
+      await context.sendInvoke(result.body, result.status);
+    } else if (!getInvokeResponseSent(context) && result === void 0) {
+      await context.sendInvoke();
+    }
+  }
+  return { handled: result !== "continue" };
+}
+function resolveHandler(handlers, kind) {
+  switch (kind) {
+    case "conversation-update":
+      return handlers?.conversationUpdate;
+    case "members-added":
+      return handlers?.membersAdded ?? handlers?.conversationUpdate;
+    case "members-removed":
+      return handlers?.membersRemoved ?? handlers?.conversationUpdate;
+    case "channel-created":
+      return handlers?.channelCreated ?? handlers?.conversationUpdate;
+    case "channel-deleted":
+      return handlers?.channelDeleted ?? handlers?.conversationUpdate;
+    case "channel-renamed":
+      return handlers?.channelRenamed ?? handlers?.conversationUpdate;
+    case "channel-restored":
+      return handlers?.channelRestored ?? handlers?.conversationUpdate;
+    case "channel-shared":
+      return handlers?.channelShared ?? handlers?.conversationUpdate;
+    case "channel-unshared":
+      return handlers?.channelUnshared ?? handlers?.conversationUpdate;
+    case "team-renamed":
+      return handlers?.teamRenamed ?? handlers?.conversationUpdate;
+    case "team-archived":
+      return handlers?.teamArchived ?? handlers?.conversationUpdate;
+    case "team-unarchived":
+      return handlers?.teamUnarchived ?? handlers?.conversationUpdate;
+    case "team-deleted":
+      return handlers?.teamDeleted ?? handlers?.conversationUpdate;
+    case "team-hard-deleted":
+      return handlers?.teamHardDeleted ?? handlers?.conversationUpdate;
+    case "team-restored":
+      return handlers?.teamRestored ?? handlers?.conversationUpdate;
+    case "message-edit":
+      return handlers?.messageEdited;
+    case "message-delete":
+      return handlers?.messageDeleted;
+    case "message-restore":
+      return handlers?.messageRestored;
+    case "reaction":
+      return handlers?.reaction;
+    case "read-receipt":
+      return handlers?.readReceipt;
+    case "config-fetch":
+      return handlers?.configFetch ?? handlers?.invoke;
+    case "config-submit":
+      return handlers?.configSubmit ?? handlers?.invoke;
+    case "file-consent":
+      return handlers?.fileConsent ?? handlers?.invoke;
+    case "actionable-message-execute-action":
+      return handlers?.actionableMessageExecuteAction ?? handlers?.invoke;
+    case "adaptive-card-action":
+      return handlers?.adaptiveCardAction ?? handlers?.cardSubmit;
+    case "adaptive-card-search":
+      return handlers?.adaptiveCardSearch ?? handlers?.searchCommand;
+    case "feedback":
+      return handlers?.feedbackSubmit ?? handlers?.cardSubmit;
+    case "card-submit":
+      return handlers?.cardSubmit;
+    case "dialog-open":
+      return handlers?.dialogOpen;
+    case "dialog-submit":
+      return handlers?.dialogSubmit;
+    case "search-command":
+      return handlers?.searchCommand;
+    case "message-extension-query":
+      return handlers?.messageExtensionQuery ?? handlers?.searchCommand;
+    case "message-extension-query-link":
+      return handlers?.messageExtensionQueryLink ?? handlers?.searchCommand;
+    case "message-extension-anonymous-query-link":
+      return handlers?.messageExtensionAnonymousQueryLink ?? handlers?.searchCommand;
+    case "select-result":
+      return handlers?.selectResult;
+    case "message-extension-select-item":
+      return handlers?.messageExtensionSelectItem ?? handlers?.selectResult;
+    case "message-extension-submit-action":
+      return handlers?.messageExtensionSubmitAction ?? handlers?.cardSubmit;
+    case "message-extension-fetch-task":
+      return handlers?.messageExtensionFetchTask ?? handlers?.dialogOpen;
+    case "message-extension-query-setting-url":
+      return handlers?.messageExtensionQuerySettingUrl ?? handlers?.invoke;
+    case "message-extension-setting":
+      return handlers?.messageExtensionSetting ?? handlers?.invoke;
+    case "message-extension-card-button-clicked":
+      return handlers?.messageExtensionCardButtonClicked ?? handlers?.invoke;
+    case "task-fetch":
+      return handlers?.taskFetch ?? handlers?.dialogOpen;
+    case "task-submit":
+      return handlers?.taskSubmit ?? handlers?.dialogSubmit;
+    case "tab-fetch":
+      return handlers?.tabFetch ?? handlers?.invoke;
+    case "tab-submit":
+      return handlers?.tabSubmit ?? handlers?.invoke;
+    case "invoke":
+      return handlers?.invoke;
+    case "meeting-start":
+      return handlers?.meetingStart;
+    case "meeting-end":
+      return handlers?.meetingEnd;
+    case "participants-join":
+      return handlers?.participantsJoin;
+    case "participants-leave":
+      return handlers?.participantsLeave;
+    case "meeting-room-join":
+      return handlers?.meetingRoomJoin;
+    case "meeting-room-leave":
+      return handlers?.meetingRoomLeave;
+    case "meeting-stage-view":
+      return handlers?.meetingStageView;
+    case "meeting-smart-reply":
+      return handlers?.meetingSmartReply;
+    case "meeting-reaction":
+      return handlers?.meetingReaction;
+    case "meeting-poll-response":
+      return handlers?.meetingPollResponse;
+    case "meeting-apps-installed":
+      return handlers?.meetingAppsInstalled;
+    case "meeting-apps-uninstalled":
+      return handlers?.meetingAppsUninstalled;
+    case "meeting-recording-started":
+      return handlers?.meetingRecordingStarted;
+    case "meeting-recording-stopped":
+      return handlers?.meetingRecordingStopped;
+    case "meeting-focus-change":
+      return handlers?.meetingFocusChange;
+    case "meeting-screen-share-start":
+      return handlers?.meetingScreenShareStart;
+    case "meeting-screen-share-stop":
+      return handlers?.meetingScreenShareStop;
+    default:
+      return void 0;
+  }
+}
+function isTeamsInvokeResult(value) {
+  return !!value && typeof value === "object" && "status" in value;
+}
+function getInvokeResponseSent(context) {
+  return context.__invokeResponseSent === true;
+}
+function setInvokeResponseSent(context, value) {
+  context.__invokeResponseSent = value;
+}
+function resolveSource(options) {
+  if (options.source) return options.source;
+  if (options.agent) return options.agent;
+  throw new Error(
+    "Provide exactly one of TeamsChannelOptions.agent or TeamsChannelOptions.source."
+  );
+}
+function runAgentWithTeamsContext(ambient, source, sessionId, message, options) {
+  return streamAgentWithTeamsContext(
+    ambient,
+    source,
+    sessionId,
+    message,
+    options
+  );
+}
+async function* streamAgentWithTeamsContext(ambient, source, sessionId, message, options) {
+  const contextValue = {
+    ...ambient,
+    message,
+    context: {
+      ...ambient.context ?? {},
+      teams: ambient.teams
+    }
+  };
+  const iterator = await runWithM365TurnContext(
+    contextValue,
+    async () => source.chat(sessionId, message, options)[Symbol.asyncIterator]()
+  );
+  let completed = false;
+  try {
+    while (true) {
+      const result = await runWithM365TurnContext(
+        contextValue,
+        () => iterator.next()
+      );
+      if (result.done) {
+        completed = true;
+        return result.value;
+      }
+      yield result.value;
+    }
+  } finally {
+    if (!completed && iterator.return) {
+      await runWithM365TurnContext(
+        contextValue,
+        () => iterator.return(void 0)
+      );
+    }
+  }
+}
+
+// src/context.ts
+import {
+  currentM365TurnContext,
+  runWithM365TurnContext as runWithM365TurnContext2
+} from "@cuylabs/channel-m365-agent-core";
+function readTeamsContext(context) {
+  const payload = context?.context;
+  if (!payload || typeof payload !== "object") return void 0;
+  const teams = payload.teams;
+  return teams && typeof teams === "object" ? teams : void 0;
+}
+function currentTeamsTurnContext() {
+  const current = currentM365TurnContext();
+  const teams = readTeamsContext(current);
+  if (!current || !teams) return void 0;
+  return {
+    ...current,
+    teams
+  };
+}
+function runWithTeamsTurnContext(value, fn) {
+  return runWithM365TurnContext2(
+    {
+      ...value,
+      context: {
+        ...value.context ?? {},
+        teams: value.teams
+      }
+    },
+    fn
+  );
+}
+
+// src/express.ts
+import {
+  adaptJwtMiddleware,
+  processWithAdapter
+} from "@cuylabs/channel-m365-agent-core/express-compat";
+async function mountTeamsAgent(source, options = {}) {
+  const expressModule = await import("express");
+  const hostingModule = await import("@microsoft/agents-hosting");
+  const {
+    path: routePath = "/api/messages",
+    authConfig: providedAuthConfig,
+    port: portOption,
+    host,
+    adapter: providedAdapter,
+    app: providedApp,
+    ...adapterOptions
+  } = options;
+  const authConfig = hostingModule.getAuthConfigWithDefaults(providedAuthConfig);
+  const cloudAdapter = providedAdapter ?? new hostingModule.CloudAdapter(authConfig);
+  const expressApp = providedApp ?? expressModule.default();
+  const channelAdapter = createTeamsChannelAdapter({
+    source,
+    ...adapterOptions
+  });
+  const jsonParser = expressModule.json();
+  const jwtAuthorizer = adaptJwtMiddleware(hostingModule, authConfig);
+  expressApp.post(
+    routePath,
+    jsonParser,
+    jwtAuthorizer,
+    (req, res) => processWithAdapter(
+      cloudAdapter,
+      req,
+      res,
+      (context) => channelAdapter.handler(context)
+    )
+  );
+  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
+  let server;
+  if (port !== null) {
+    const onListen = () => {
+      process.stdout.write(
+        `Teams agent listening on port ${port} \u2014 appId: ${authConfig.clientId ?? "(not set)"}
+`
+      );
+    };
+    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
+  }
+  return {
+    app: expressApp,
+    channelAdapter,
+    cloudAdapter,
+    server
+  };
+}
+function resolvePort(port) {
+  if (!port) return 3978;
+  const parsed = Number(port);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`Invalid PORT value: ${port}`);
+  }
+  return parsed;
+}
+
+// src/interactive-requests.ts
+var TEAMS_INPUT_REQUEST_APPROVAL_VERB = "cuylabs.agent.input.approval";
+var TEAMS_INPUT_REQUEST_HUMAN_VERB = "cuylabs.agent.input.human";
+var ADAPTIVE_CARD_CONTENT_TYPE = "application/vnd.microsoft.card.adaptive";
+var DEFAULT_MAX_ARGUMENT_CHARS = 1200;
+function createTeamsApprovalRequestCard(input, options = {}) {
+  const { request, sessionId, turnId } = normalizeInputRequest(input);
+  const body = [
+    {
+      type: "TextBlock",
+      size: "Medium",
+      weight: "Bolder",
+      text: options.title ?? "Approval required",
+      wrap: true
+    },
+    {
+      type: "FactSet",
+      facts: [
+        { title: "Tool", value: request.tool },
+        { title: "Risk", value: request.risk }
+      ]
+    },
+    {
+      type: "TextBlock",
+      text: request.description,
+      wrap: true
+    }
+  ];
+  if (options.includeArguments ?? true) {
+    const formattedArgs = formatToolArguments(
+      request.args,
+      options.maxArgumentChars ?? DEFAULT_MAX_ARGUMENT_CHARS
+    );
+    if (formattedArgs) {
+      body.push({
+        type: "TextBlock",
+        text: formattedArgs,
+        wrap: true,
+        fontType: "Monospace",
+        isSubtle: true
+      });
+    }
+  }
+  const rememberScopes = normalizeRememberScopes(request);
+  if (rememberScopes.length > 0) {
+    body.push({
+      type: "Input.ChoiceSet",
+      id: "rememberScope",
+      label: "Remember scope",
+      style: "compact",
+      value: request.defaultRememberScope ?? rememberScopes[0],
+      choices: rememberScopes.map((scope) => ({
+        title: labelRememberScope(scope),
+        value: scope
+      }))
+    });
+  }
+  body.push({
+    type: "Input.Text",
+    id: "feedback",
+    label: "Feedback",
+    isMultiline: true,
+    isRequired: false,
+    placeholder: "Optional"
+  });
+  const baseData = {
+    requestId: request.id,
+    sessionId,
+    ...turnId ? { turnId } : {}
+  };
+  const actions = [
+    {
+      type: "Action.Submit",
+      title: "Approve",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_APPROVAL_VERB,
+        action: "allow"
+      }
+    },
+    {
+      type: "Action.Submit",
+      title: "Deny",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_APPROVAL_VERB,
+        action: "deny"
+      }
+    }
+  ];
+  if (rememberScopes.length > 0) {
+    actions.push({
+      type: "Action.Submit",
+      title: "Remember",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_APPROVAL_VERB,
+        action: "remember"
+      }
+    });
+  }
+  return createAdaptiveCardAttachment(body, actions);
+}
+function createTeamsHumanInputRequestCard(input, options = {}) {
+  const { request, sessionId, turnId } = normalizeInputRequest(input);
+  const body = [
+    {
+      type: "TextBlock",
+      size: "Medium",
+      weight: "Bolder",
+      text: options.title ?? request.title,
+      wrap: true
+    },
+    {
+      type: "TextBlock",
+      text: request.question,
+      wrap: true
+    }
+  ];
+  const baseData = {
+    requestId: request.id,
+    sessionId,
+    ...turnId ? { turnId } : {}
+  };
+  if (request.kind === "choice") {
+    body.push({
+      type: "Input.ChoiceSet",
+      id: "selected",
+      label: request.title,
+      style: request.allowMultiple ? "expanded" : "compact",
+      isMultiSelect: request.allowMultiple ?? false,
+      choices: (request.options ?? []).map((option) => ({
+        title: option.label,
+        value: option.value ?? option.label
+      }))
+    });
+  } else if (request.kind === "text") {
+    body.push({
+      type: "Input.Text",
+      id: "text",
+      label: request.title,
+      isMultiline: true,
+      placeholder: request.placeholder ?? "Type a response"
+    });
+  } else {
+    body.push({
+      type: "Input.Text",
+      id: "text",
+      label: "Details",
+      isMultiline: true,
+      isRequired: false,
+      placeholder: request.placeholder ?? "Optional"
+    });
+  }
+  const actions = request.kind === "confirm" ? [
+    {
+      type: "Action.Submit",
+      title: request.confirmLabel ?? "Confirm",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_HUMAN_VERB,
+        responseKind: "confirm",
+        confirmed: true
+      }
+    },
+    {
+      type: "Action.Submit",
+      title: request.denyLabel ?? "Cancel",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_HUMAN_VERB,
+        responseKind: "confirm",
+        confirmed: false
+      }
+    }
+  ] : [
+    {
+      type: "Action.Submit",
+      title: request.confirmLabel ?? "Submit",
+      data: {
+        ...baseData,
+        verb: TEAMS_INPUT_REQUEST_HUMAN_VERB,
+        responseKind: request.kind
+      }
+    }
+  ];
+  return createAdaptiveCardAttachment(body, actions);
+}
+function parseTeamsInputRequestSubmit(value) {
+  const data = readSubmitData(value);
+  const verb = readString(data, "verb");
+  const requestId = readString(data, "requestId");
+  if (!requestId || verb !== TEAMS_INPUT_REQUEST_APPROVAL_VERB && verb !== TEAMS_INPUT_REQUEST_HUMAN_VERB) {
+    return void 0;
+  }
+  const sessionId = readString(data, "sessionId");
+  const turnId = readString(data, "turnId");
+  if (verb === TEAMS_INPUT_REQUEST_APPROVAL_VERB) {
+    const action = readApprovalAction(data);
+    if (!action) {
+      return void 0;
+    }
+    const feedback = readTrimmedString(data, "feedback");
+    const rememberScope = action === "remember" ? readRememberScope(data) : void 0;
+    return {
+      verb,
+      requestId,
+      ...sessionId ? { sessionId } : {},
+      ...turnId ? { turnId } : {},
+      payload: {
+        kind: "approval",
+        action,
+        ...feedback ? { feedback } : {},
+        ...rememberScope ? { rememberScope } : {}
+      }
+    };
+  }
+  const response = readHumanInputResponse(data);
+  if (!response) {
+    return void 0;
+  }
+  return {
+    verb,
+    requestId,
+    ...sessionId ? { sessionId } : {},
+    ...turnId ? { turnId } : {},
+    payload: {
+      kind: "human",
+      response
+    }
+  };
+}
+function createAdaptiveCardAttachment(body, actions) {
+  return {
+    contentType: ADAPTIVE_CARD_CONTENT_TYPE,
+    content: {
+      type: "AdaptiveCard",
+      version: "1.5",
+      body,
+      actions
+    }
+  };
+}
+function normalizeInputRequest(input) {
+  if ("request" in input) {
+    return {
+      request: input.request,
+      sessionId: input.sessionId ?? input.request.sessionId,
+      ...input.turnId ? { turnId: input.turnId } : {}
+    };
+  }
+  return {
+    request: input,
+    sessionId: input.sessionId
+  };
+}
+function formatToolArguments(args, maxChars) {
+  let formatted;
+  try {
+    formatted = JSON.stringify(args, null, 2);
+  } catch {
+    return "";
+  }
+  if (!formatted || formatted === "undefined") {
+    return "";
+  }
+  if (formatted.length <= maxChars) {
+    return formatted;
+  }
+  return `${formatted.slice(0, Math.max(0, maxChars - 1))}...`;
+}
+function normalizeRememberScopes(request) {
+  const allowed = /* @__PURE__ */ new Set([
+    "session",
+    "project",
+    "user"
+  ]);
+  return (request.rememberScopes ?? []).filter((scope) => allowed.has(scope));
+}
+function labelRememberScope(scope) {
+  switch (scope) {
+    case "session":
+      return "This session";
+    case "project":
+      return "This project";
+    case "user":
+      return "My user";
+  }
+}
+function readSubmitData(value) {
+  const record = asRecord(value);
+  const nested = asRecord(record?.data);
+  return {
+    ...nested ?? {},
+    ...record ?? {}
+  };
+}
+function readHumanInputResponse(data) {
+  const responseKind = readString(data, "responseKind");
+  switch (responseKind) {
+    case "text": {
+      const text = readString(data, "text") ?? "";
+      return { kind: "text", text };
+    }
+    case "confirm": {
+      const confirmed = readBoolean(data, "confirmed");
+      if (confirmed === void 0) {
+        return void 0;
+      }
+      const text = readString(data, "text") ?? (confirmed ? "confirmed" : "denied");
+      return { kind: "confirm", confirmed, text };
+    }
+    case "choice": {
+      const selected = readSelectedValues(data, "selected");
+      return { kind: "choice", selected, text: selected.join(", ") };
+    }
+    default:
+      return void 0;
+  }
+}
+function readApprovalAction(data) {
+  const action = readString(data, "action");
+  return action === "allow" || action === "deny" || action === "remember" ? action : void 0;
+}
+function readRememberScope(data) {
+  const scope = readString(data, "rememberScope");
+  return scope === "session" || scope === "project" || scope === "user" ? scope : void 0;
+}
+function readSelectedValues(data, key) {
+  const value = data[key];
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}
+function readTrimmedString(data, key) {
+  return readString(data, key)?.trim() || void 0;
+}
+function readString(data, key) {
+  const value = data?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readBoolean(data, key) {
+  const value = data[key];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+export {
+  Conversation,
+  ConversationBuilder,
+  ConversationReferenceBuilder,
+  CreateConversationOptionsBuilder,
+  TEAMS_INPUT_REQUEST_APPROVAL_VERB,
+  TEAMS_INPUT_REQUEST_HUMAN_VERB,
+  captureM365ConversationReference,
+  captureTeamsConversationReference,
+  continueM365Conversation,
+  createTeamsApprovalRequestCard,
+  createTeamsChannelAdapter,
+  createTeamsHumanInputRequestCard,
+  currentTeamsTurnContext,
+  mountTeamsAgent,
+  parseTeamsInputRequestSubmit,
+  restoreM365ConversationReference,
+  runWithTeamsTurnContext
+};