@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/live-voice/live-voice-session.ts

@@ -1323,6 +1323,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // older one is simply out of date. Consumed (and cleared) when a turn
   // launches, handed back if that turn is rolled back, and cleared on close.
   private pendingTurnAttachmentId: string | null = null;
+  // When `speech_started` last went to the client, for the sight-frame log:
+  // the distance from it to a keep arriving is the client leg of the frame the
+  // onset asked for, measured from the daemon's own clock.
+  private lastSpeechStartedAtMs: number | null = null;
   private readonly maxPendingAudioBytes: number;
   // Set on VAD speech onset; consumed when the first speech chunk is routed
   // to an utterance so the metric lands on the right turn.
@@ -1719,11 +1723,32 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * same fact.
    */
   private persistSightFrame(frame: LiveVoiceClientSightFrameFrame): void {
+    const receivedAtMs = Date.now();
+    // One line per keep, written when the row lands, carrying the whole
+    // timeline: the client leg the frame reported, the daemon leg the persist
+    // measured, and the distance from the speech onset the frame may have
+    // been asked for. Together with the turn's own "Voice turn dispatch
+    // timing" line this says whether a frame missed its turn and where.
+    const sinceSpeechStartedMs =
+      this.lastSpeechStartedAtMs === null
+        ? null
+        : receivedAtMs - this.lastSpeechStartedAtMs;
     void persistAmbientSightFrame(
       this.conversationId,
       frame.attachmentId,
       "voice",
     ).then((result) => {
+      log.info(
+        {
+          attachmentId: frame.attachmentId,
+          persisted: result.ok,
+          sinceSpeechStartedMs,
+          client: frame.timing ?? null,
+          daemon: result.timing ?? null,
+          daemonTotalMs: Date.now() - receivedAtMs,
+        },
+        "Sight frame timing",
+      );
       if (!result.ok && !this.isClosed) {
         void this.sendFrame({
           type: "error",
@@ -2790,12 +2815,21 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     this.pendingBargeIn = null;
     this.assistantPlaybackTailUntilMs = 0;
-    void this.sendFrame({ type: "speech_started" });
+    this.sendSpeechStarted();
     if (bargeableTurn) {
       this.bargeIn(bargeableTurn);
     }
   }
 
+  /**
+   * Tell the client the caller started speaking, and remember when, so a
+   * camera frame that follows can be logged against the onset it answers.
+   */
+  private sendSpeechStarted(): void {
+    this.lastSpeechStartedAtMs = Date.now();
+    void this.sendFrame({ type: "speech_started" });
+  }
+
   // Advance the sustained-speech barge-in guard by one server-VAD chunk.
   // Speech accumulates toward bargeInMinSpeechMs, short true-silence gaps are
   // tolerated, and classified playback echo resets the run immediately.
@@ -2841,7 +2875,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
     this.pendingBargeIn = null;
     this.assistantPlaybackTailUntilMs = 0;
-    void this.sendFrame({ type: "speech_started" });
+    this.sendSpeechStarted();
     const { turn } = guard;
     if (turn && turn === this.activeAssistantTurn && !turn.finalized) {
       this.bargeIn(turn);

package/src/live-voice/protocol.ts

@@ -312,6 +312,44 @@ export interface LiveVoiceClientAttachFrameFrame {
 export interface LiveVoiceClientSightFrameFrame {
   readonly type: "sight_frame";
   readonly attachmentId: string;
+  /**
+   * How long the client's half of the frame took, for the daemon's log. The
+   * daemon adds its own half and the distance from the speech onset it
+   * announced, which is what makes a frame that answered the wrong question
+   * legible after the fact. Optional: an older client sends none.
+   */
+  readonly timing?: LiveVoiceSightFrameTiming;
+}
+
+/**
+ * The client leg of one kept frame, as durations between its own marks.
+ *
+ * Durations rather than timestamps because the two clocks are not the same
+ * clock: the client stamps from `performance.now` and the daemon from wall
+ * time, and only the client can say how long its encode and upload took.
+ * Every field is a non-negative whole number of milliseconds.
+ */
+export interface LiveVoiceSightFrameTiming {
+  /**
+   * Why the gate kept the frame: `forced` is the keep a speech onset asked
+   * for, everything else is the ambient cadence. Free-form so a new gate
+   * reason needs no daemon change to be logged.
+   */
+  readonly reason: string;
+  /**
+   * From the arm that asked for this keep to the keep itself. Present only on
+   * a forced keep, where it is the distance from the client hearing
+   * `speech_started` to a frame that postdates it.
+   */
+  readonly armToKeepMs?: number;
+  /** From the keep to a JPEG in hand, sized for upload. */
+  readonly keepToEncodedMs: number;
+  /** From the JPEG to the attachment id, which is the HTTP upload. */
+  readonly encodedToUploadedMs: number;
+  /** From the id to the send, which is the wait for older keeps to go first. */
+  readonly uploadedToSentMs: number;
+  /** The JPEG that was uploaded, in bytes. */
+  readonly bytes: number;
 }
 
 /**
@@ -932,9 +970,68 @@ function validateSightFrameFrame(
     );
   }
 
+  if (!("timing" in value) || value.timing === undefined) {
+    return {
+      ok: true,
+      frame: { type: "sight_frame", attachmentId: value.attachmentId },
+    };
+  }
+
+  const timing = validateSightFrameTiming(value.timing);
+  if (timing === null) {
+    return protocolError(
+      "invalid_field",
+      "sight_frame frame field timing must carry non-negative integer durations and a reason",
+      "timing",
+      "sight_frame",
+    );
+  }
+
   return {
     ok: true,
-    frame: { type: "sight_frame", attachmentId: value.attachmentId },
+    frame: { type: "sight_frame", attachmentId: value.attachmentId, timing },
+  };
+}
+
+/**
+ * Parse a `sight_frame`'s `timing`. Null for anything off-shape: a timing is
+ * for the log, so nothing about it is coerced, but a malformed one still
+ * refuses the frame, since a client that sends one means to send a whole one.
+ */
+function validateSightFrameTiming(
+  value: unknown,
+): LiveVoiceSightFrameTiming | null {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  const isDuration = (duration: unknown): duration is number =>
+    isIntInRange(duration, 0, Number.MAX_SAFE_INTEGER);
+  const {
+    reason,
+    armToKeepMs,
+    keepToEncodedMs,
+    encodedToUploadedMs,
+    uploadedToSentMs,
+    bytes,
+  } = record;
+  if (
+    !isNonEmptyString(reason) ||
+    !isDuration(keepToEncodedMs) ||
+    !isDuration(encodedToUploadedMs) ||
+    !isDuration(uploadedToSentMs) ||
+    !isDuration(bytes) ||
+    (armToKeepMs !== undefined && !isDuration(armToKeepMs))
+  ) {
+    return null;
+  }
+  return {
+    reason,
+    ...(armToKeepMs !== undefined ? { armToKeepMs } : {}),
+    keepToEncodedMs,
+    encodedToUploadedMs,
+    uploadedToSentMs,
+    bytes,
   };
 }
 

package/src/mcp/__tests__/reload-signal-emission.test.ts

@@ -0,0 +1,54 @@
+/**
+ * The daemon's MCP reload is what announces itself to the other processes.
+ *
+ * Every path that changes the server set (a config edit, the reload route, an
+ * OAuth reauthentication, a plugin install) funnels through `reloadMcpServers`,
+ * so signalling there covers all of them. Signalling anywhere narrower would
+ * leave whichever path was missed silently stale in the schedule worker.
+ */
+
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
+
+mock.module("../manager.js", () => ({
+  getMcpServerManager: () => ({
+    start: jest.fn(async () => []),
+    stop: jest.fn(async () => {}),
+    callTool: jest.fn(),
+    getClient: () => undefined,
+  }),
+  stopMcpServerManager: jest.fn(async () => {}),
+}));
+
+mock.module("../mcp-header-store.js", () => ({
+  migrateLegacyMcpHeaders: async () => {},
+}));
+
+mock.module("../../plugins/mcp-servers.js", () => ({
+  readPluginMcpServers: () => ({ servers: [], issues: [] }),
+}));
+
+const { getSignalsDir } = await import("../../util/platform.js");
+const { MCP_RELOAD_SIGNAL_FILE } = await import("../reload-signal.js");
+const { reloadMcpServers } = await import("../../daemon/mcp-reload-service.js");
+
+const signalPath = () => join(getSignalsDir(), MCP_RELOAD_SIGNAL_FILE);
+
+beforeEach(() => {
+  rmSync(signalPath(), { force: true });
+});
+
+describe("reloadMcpServers", () => {
+  test("signals the reload so other processes rebuild their own set", async () => {
+    const result = await reloadMcpServers();
+
+    expect(result.success).toBe(true);
+    expect(
+      existsSync(signalPath()),
+      "Connections and the tools they register are per-process. A reload " +
+        "that only rebuilds the daemon's leaves the schedule worker calling " +
+        "servers the config no longer lists.",
+    ).toBe(true);
+  });
+});

package/src/mcp/__tests__/reload-signal.test.ts

@@ -0,0 +1,57 @@
+/**
+ * The MCP reload signal, the channel that tells the daemon's child processes
+ * their MCP server set moved.
+ *
+ * They hold their own connections to the same servers and have no config
+ * watcher of their own, so without this they keep serving the set as it stood
+ * when they started: a server the config has since disabled stays callable
+ * there long after the daemon dropped it.
+ */
+
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getSignalsDir } from "../../util/platform.js";
+import { MCP_RELOAD_SIGNAL_FILE, signalMcpReloaded } from "../reload-signal.js";
+
+const signalPath = () => join(getSignalsDir(), MCP_RELOAD_SIGNAL_FILE);
+
+beforeEach(() => {
+  rmSync(signalPath(), { force: true });
+});
+
+describe("signalMcpReloaded", () => {
+  test("writes the signal file", () => {
+    signalMcpReloaded();
+
+    expect(existsSync(signalPath())).toBe(true);
+    expect(Number(readFileSync(signalPath(), "utf8"))).toBeGreaterThan(0);
+  });
+
+  test("creates the signals directory when it is absent", () => {
+    rmSync(getSignalsDir(), { recursive: true, force: true });
+
+    signalMcpReloaded();
+
+    expect(existsSync(signalPath())).toBe(true);
+  });
+
+  test("rewrites in place, so a second reload is a fresh event", () => {
+    mkdirSync(getSignalsDir(), { recursive: true });
+    signalMcpReloaded();
+    const first = readFileSync(signalPath(), "utf8");
+
+    const until = Date.now() + 2;
+    while (Date.now() < until) {
+      /* let the clock move so the two writes differ */
+    }
+    signalMcpReloaded();
+
+    expect(
+      readFileSync(signalPath(), "utf8"),
+      "Readers react to the write rather than consuming the file, so the " +
+        "content has to change for a second reload to register.",
+    ).not.toBe(first);
+  });
+});

package/src/mcp/__tests__/startup.test.ts

@@ -0,0 +1,150 @@
+/**
+ * MCP tools reach a process's tool registry only by connecting to each server
+ * and listing what it offers. `initializeTools()` does not do that: it loads
+ * core built-ins and workspace tools from disk. So every process that hosts
+ * agent turns has to run this step for itself or its `mcp__*` calls fail as
+ * "Unknown tool" while `assistant tools list`, which reads the daemon's
+ * registry over IPC, reports the same tool as registered.
+ *
+ * These cover the shared step itself: that it registers what a server reports,
+ * that a server it cannot reach leaves the process running anyway, and that a
+ * restart rebuilds the set rather than adding to it. The guard that the
+ * schedule worker actually calls it lives in
+ * `src/schedule/__tests__/worker-mcp-tools.test.ts`, next to the worker.
+ */
+
+import { afterEach, describe, expect, jest, mock, test } from "bun:test";
+
+const start = jest.fn(async () => [] as unknown[]);
+
+mock.module("../manager.js", () => ({
+  getMcpServerManager: () => ({
+    start,
+    callTool: jest.fn(),
+    getClient: () => undefined,
+  }),
+  stopMcpServerManager: jest.fn(async () => {}),
+}));
+
+// Plugin-declared servers are read off disk, so leaving this real would make
+// "no servers configured" depend on which plugins the machine running the
+// tests happens to have installed.
+mock.module("../../plugins/mcp-servers.js", () => ({
+  readPluginMcpServers: () => ({ servers: [], issues: [] }),
+}));
+
+const { restartConfiguredMcpServers, startConfiguredMcpServers } =
+  await import("../startup.js");
+const { __resetRegistryForTesting, getTool } =
+  await import("../../tools/registry.js");
+
+/** One entry of `McpServerManager.start()`'s result: a server and its tools. */
+function serverReporting(serverId: string, toolName: string) {
+  return {
+    serverId,
+    serverConfig: {
+      transport: {
+        type: "streamable-http",
+        url: "https://example.invalid/mcp",
+      },
+      enabled: true,
+      defaultRiskLevel: "low",
+      maxTools: 20,
+      source: "workspace",
+    },
+    tools: [
+      {
+        name: toolName,
+        description: "Search email",
+        inputSchema: { type: "object", properties: {} },
+        annotations: { readOnlyHint: true },
+      },
+    ],
+  };
+}
+
+/** The `mcp` config block shape a workspace config carries for one server. */
+function workspaceConfigWith(serverId: string) {
+  return {
+    servers: {
+      [serverId]: {
+        transport: {
+          type: "streamable-http" as const,
+          url: "https://example.invalid/mcp",
+        },
+        enabled: true,
+        defaultRiskLevel: "low" as const,
+        maxTools: 20,
+      },
+    },
+    globalMaxTools: 50,
+  };
+}
+
+afterEach(() => {
+  start.mockClear();
+  __resetRegistryForTesting();
+});
+
+describe("startConfiguredMcpServers", () => {
+  test("registers the tools a server reports, namespaced by server id", async () => {
+    start.mockResolvedValueOnce([serverReporting("fastmail", "search_email")]);
+
+    const registered = await startConfiguredMcpServers(
+      workspaceConfigWith("fastmail") as never,
+    );
+
+    expect(registered).toBe(1);
+    expect(getTool("mcp__fastmail__search_email")).toBeDefined();
+  });
+
+  test("does nothing when no servers are configured", async () => {
+    const registered = await startConfiguredMcpServers(undefined);
+
+    expect(registered).toBe(0);
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  test("a server that cannot be started leaves the process running", async () => {
+    start.mockRejectedValueOnce(new Error("connection refused"));
+
+    const registered = await startConfiguredMcpServers(
+      workspaceConfigWith("fastmail") as never,
+    );
+
+    expect(registered).toBe(0);
+  });
+});
+
+describe("restartConfiguredMcpServers", () => {
+  test("drops tools the reconnected set no longer reports", async () => {
+    start.mockResolvedValueOnce([serverReporting("fastmail", "search_email")]);
+    await startConfiguredMcpServers(workspaceConfigWith("fastmail") as never);
+    expect(getTool("mcp__fastmail__search_email")).toBeDefined();
+
+    // The test workspace config declares no MCP servers, which is what a
+    // removed or disabled one looks like on the next connect.
+    await restartConfiguredMcpServers();
+
+    expect(
+      getTool("mcp__fastmail__search_email"),
+      "A server the config dropped has to stop being callable here. Leaving " +
+        "its tools registered is what lets a background schedule keep " +
+        "reaching a server the daemon has already disconnected.",
+    ).toBeUndefined();
+  });
+
+  test("reconnects from the config on disk rather than the previous set", async () => {
+    start.mockResolvedValueOnce([serverReporting("fastmail", "search_email")]);
+    await startConfiguredMcpServers(workspaceConfigWith("fastmail") as never);
+    start.mockClear();
+
+    await restartConfiguredMcpServers();
+
+    expect(
+      start,
+      "The previous effective config is not reusable: it is the thing that " +
+        "changed. A restart rereads it.",
+    ).not.toHaveBeenCalled();
+  });
+});

package/src/mcp/reload-signal.ts

@@ -0,0 +1,50 @@
+/**
+ * Cross-process notification that the MCP server set has been reloaded.
+ *
+ * MCP connections and the tools they register are per-process, and so is the
+ * reload that rebuilds them: `daemon/mcp-reload-service.ts` acts on the
+ * daemon's own manager and registry. Every other process that holds
+ * connections has to hear about it, or it keeps serving the server set as it
+ * stood when that process started, including servers the config has since
+ * disabled or removed.
+ *
+ * The channel is a file in the signals directory, written by the reloading
+ * process and watched by the others. A file rather than an IPC call because
+ * the listeners are the daemon's own children: a call would need the daemon to
+ * track who is listening and to stay up while it delivers, and the reload has
+ * no reason to wait for either.
+ *
+ * The file's content is a timestamp, and it is never deleted. Readers react to
+ * the write, so there is nothing to consume and no race over who consumes it.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+import { getSignalsDir } from "../util/platform.js";
+
+const log = getLogger("mcp-reload-signal");
+
+/** Name of the signal file within the signals directory. */
+export const MCP_RELOAD_SIGNAL_FILE = "mcp-reloaded";
+
+/**
+ * Announce that this process reloaded its MCP servers.
+ *
+ * Best-effort: a signals directory that cannot be written leaves other
+ * processes on their existing connections, which is where they already were,
+ * so it is logged rather than raised into the reload's result.
+ */
+export function signalMcpReloaded(): void {
+  const signalsDir = getSignalsDir();
+  try {
+    mkdirSync(signalsDir, { recursive: true });
+    writeFileSync(join(signalsDir, MCP_RELOAD_SIGNAL_FILE), String(Date.now()));
+  } catch (err) {
+    log.warn(
+      { err, signalsDir },
+      "Failed to write the MCP reload signal; other processes keep their current servers",
+    );
+  }
+}

package/src/mcp/startup.ts

@@ -0,0 +1,101 @@
+/**
+ * Connect the configured MCP servers and register their tools.
+ *
+ * MCP tools are not loaded from disk the way core and workspace tools are:
+ * something has to connect to each server, list its tools, and register the
+ * results into this process's registry. That registry is per-process, so every
+ * process that hosts agent turns has to run it for itself: the daemon at boot
+ * and the schedule worker at startup alike. A process that skips this step has
+ * the tools missing entirely rather than filtered out, and every `mcp__*` call
+ * made in it fails as "Unknown tool".
+ *
+ * One home for the step so the processes that run it cannot drift, and so a
+ * further process that starts hosting turns has one call to make.
+ */
+
+import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import type { McpConfig } from "../config/schemas/mcp.js";
+import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
+import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
+import { getLogger } from "../util/logger.js";
+import { buildEffectiveMcpConfig } from "./effective-config.js";
+import { getMcpServerManager, stopMcpServerManager } from "./manager.js";
+
+const log = getLogger("mcp-startup");
+
+/**
+ * Start every enabled server in the effective MCP config (workspace entries
+ * plus plugin-declared ones) and register the tools they report.
+ *
+ * Call after {@link initializeTools}, so core and workspace tools already own
+ * their names when MCP registrations resolve: `registerMcpTools` yields to an
+ * existing owner rather than displacing it.
+ *
+ * Never throws: a server that cannot be reached is logged and skipped, and a
+ * failure of the whole step leaves the process running without MCP tools. This
+ * is a startup step in processes whose other work must not be held hostage to
+ * a third-party server being up.
+ *
+ * @param workspaceMcpConfig The `mcp` block of the assistant config, if any.
+ * @returns The number of tools registered across all servers.
+ */
+export async function startConfiguredMcpServers(
+  workspaceMcpConfig?: McpConfig,
+): Promise<number> {
+  let registered = 0;
+  try {
+    const mcpConfig = buildEffectiveMcpConfig(workspaceMcpConfig);
+    if (Object.keys(mcpConfig.servers).length === 0) {
+      return 0;
+    }
+
+    const manager = getMcpServerManager();
+    const serverToolInfos = await manager.start(mcpConfig);
+    for (const { serverId, serverConfig, tools } of serverToolInfos) {
+      const mcpTools = createMcpToolsFromServer(
+        tools,
+        serverId,
+        serverConfig,
+        manager,
+      );
+      registered += registerMcpTools(serverId, mcpTools).length;
+    }
+  } catch (err) {
+    log.error(
+      { err },
+      "MCP server initialization failed, continuing without MCP tools",
+    );
+    return registered;
+  }
+
+  log.info({ toolCount: registered }, "MCP tools registered");
+  return registered;
+}
+
+/**
+ * Drop this process's MCP connections and tools and build them again from the
+ * config on disk.
+ *
+ * The server set is owned by the config, not by any one process, so a process
+ * that holds connections has to be told when it moves. The daemon learns from
+ * its own config watcher and reload route; a process without those (the
+ * schedule worker) calls this when the daemon signals that a reload happened,
+ * which is what keeps a disabled or removed server from staying callable there
+ * long after it stopped being callable in the daemon.
+ *
+ * Never throws, for the same reason {@link startConfiguredMcpServers} does not.
+ * The window between the teardown and the reconnect has no MCP tools
+ * registered, so an `mcp__*` call landing inside it fails as an unknown tool.
+ *
+ * @returns The number of tools registered after the reconnect.
+ */
+export async function restartConfiguredMcpServers(): Promise<number> {
+  try {
+    await stopMcpServerManager();
+  } catch (err) {
+    log.warn({ err }, "MCP server teardown failed, reconnecting anyway");
+  }
+  unregisterAllMcpTools();
+  invalidateConfigCache();
+  return startConfiguredMcpServers(getConfig().mcp);
+}

package/src/messaging/providers/outlook/adapter.ts

@@ -19,18 +19,7 @@ import type {
   SendResult,
 } from "../../provider-types.js";
 import * as outlook from "./client.js";
-import type { OutlookMessage, OutlookSendFileAttachment } from "./types.js";
-
-function toGraphAttachments(
-  attachments: NonNullable<SendOptions["attachments"]>,
-): OutlookSendFileAttachment[] {
-  return attachments.map((att) => ({
-    "@odata.type": "#microsoft.graph.fileAttachment",
-    name: att.filename,
-    contentType: att.mimeType,
-    contentBytes: att.data.toString("base64"),
-  }));
-}
+import type { OutlookMessage } from "./types.js";
 
 function requireConnection(
   connection: OAuthConnection | undefined,
@@ -155,7 +144,7 @@ export const outlookMessagingProvider: MessagingProvider = {
   ): Promise<SendResult> {
     const conn = requireConnection(connection);
     const attachments = options?.attachments?.length
-      ? toGraphAttachments(options.attachments)
+      ? outlook.toOutlookFileAttachments(options.attachments)
       : undefined;
 
     if (options?.inReplyTo) {

package/src/messaging/providers/outlook/client.ts

@@ -286,6 +286,18 @@ export async function markMessageRead(
   );
 }
 
+/** Map in-memory file parts to Graph fileAttachment objects. */
+export function toOutlookFileAttachments(
+  attachments: Array<{ filename: string; mimeType: string; data: Buffer }>,
+): OutlookSendFileAttachment[] {
+  return attachments.map((att) => ({
+    "@odata.type": "#microsoft.graph.fileAttachment",
+    name: att.filename,
+    contentType: att.mimeType,
+    contentBytes: att.data.toString("base64"),
+  }));
+}
+
 /** Create a draft message in the user's Drafts folder. */
 export async function createDraft(
   connection: OAuthConnection,
@@ -293,7 +305,7 @@ export async function createDraft(
 ): Promise<OutlookMessage> {
   return request<OutlookMessage>(connection, "/v1.0/me/messages", {
     method: "POST",
-    body: JSON.stringify(draft),
+    body: JSON.stringify({ ...draft, isDraft: true }),
   });
 }
 

package/src/messaging/providers/outlook/types.ts

@@ -53,6 +53,7 @@ export interface OutlookMessage {
     flagStatus: "notFlagged" | "flagged" | "complete";
   };
   internetMessageHeaders?: OutlookInternetMessageHeader[];
+  webLink?: string;
 }
 
 /** Outlook mail folder */
@@ -98,6 +99,8 @@ export interface OutlookDraftMessage {
   toRecipients?: OutlookRecipient[];
   ccRecipients?: OutlookRecipient[];
   bccRecipients?: OutlookRecipient[];
+  isDraft?: boolean;
+  attachments?: OutlookSendFileAttachment[];
 }
 
 /** Forward message payload (Graph API's /createForward returns a draft) */