@vellumai/assistant 0.8.7 → 0.8.8

package/src/daemon/conversation-surfaces.ts

@@ -38,10 +38,13 @@ import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import type { HostCuProxy } from "./host-cu-proxy.js";
 import type {
   CardSurfaceData,
+  ChoiceSurfaceData,
   ConfirmationSurfaceData,
+  CopyBlockSurfaceData,
   DynamicPageSurfaceData,
   FormSurfaceData,
   ListSurfaceData,
+  OAuthConnectSurfaceData,
   ServerMessage,
   SurfaceData,
   SurfaceType,
@@ -395,6 +398,107 @@ function normalizeTaskProgressCardPatch(
   return normalizedPatch;
 }
 
+function normalizeChoiceShowData(
+  rawData: Record<string, unknown>,
+): ChoiceSurfaceData {
+  const options = Array.isArray(rawData.options)
+    ? rawData.options
+        .filter((option): option is Record<string, unknown> =>
+          isPlainObject(option),
+        )
+        .map((option) => {
+          const id = typeof option.id === "string" ? option.id.trim() : "";
+          const title =
+            typeof option.title === "string"
+              ? option.title.trim()
+              : typeof option.label === "string"
+                ? option.label.trim()
+                : "";
+          if (!id || !title) return null;
+          return {
+            id,
+            title,
+            ...(typeof option.description === "string"
+              ? { description: option.description }
+              : {}),
+            ...(option.recommended === true ? { recommended: true } : {}),
+            ...(isPlainObject(option.data)
+              ? { data: option.data as Record<string, unknown> }
+              : {}),
+          };
+        })
+        .filter(
+          (option): option is NonNullable<typeof option> => option !== null,
+        )
+    : [];
+
+  return {
+    ...(typeof rawData.description === "string"
+      ? { description: rawData.description }
+      : {}),
+    options,
+    selectionMode: rawData.selectionMode === "multiple" ? "multiple" : "single",
+    ...(typeof rawData.submitLabel === "string"
+      ? { submitLabel: rawData.submitLabel }
+      : {}),
+    ...(typeof rawData.commitOnSelect === "boolean"
+      ? { commitOnSelect: rawData.commitOnSelect }
+      : {}),
+  };
+}
+
+function normalizeCopyBlockShowData(
+  rawData: Record<string, unknown>,
+): CopyBlockSurfaceData {
+  return {
+    text: typeof rawData.text === "string" ? rawData.text : "",
+    ...(typeof rawData.label === "string" ? { label: rawData.label } : {}),
+    ...(typeof rawData.language === "string"
+      ? { language: rawData.language }
+      : {}),
+  };
+}
+
+function normalizeOAuthConnectShowData(
+  rawData: Record<string, unknown>,
+): OAuthConnectSurfaceData {
+  return {
+    providerKey:
+      typeof rawData.providerKey === "string" ? rawData.providerKey.trim() : "",
+    ...(typeof rawData.displayName === "string"
+      ? { displayName: rawData.displayName }
+      : {}),
+    ...(typeof rawData.description === "string"
+      ? { description: rawData.description }
+      : {}),
+    ...(typeof rawData.logoUrl === "string" || rawData.logoUrl === null
+      ? { logoUrl: rawData.logoUrl }
+      : {}),
+  };
+}
+
+function buildChoiceActions(data: ChoiceSurfaceData): Array<{
+  id: string;
+  label: string;
+  style?: string;
+  data?: Record<string, unknown>;
+}> {
+  return data.options.map((option) => ({
+    id: option.id,
+    label: option.title,
+    style: option.recommended ? "primary" : "secondary",
+    data: {
+      choiceId: option.id,
+      choiceTitle: option.title,
+      selectedIds: [option.id],
+      selectedTitles: [option.title],
+      ...(option.description ? { choiceDescription: option.description } : {}),
+      ...(option.recommended ? { recommended: true } : {}),
+      ...(option.data ?? {}),
+    },
+  }));
+}
+
 function isTaskProgressCardData(data: SurfaceData | Record<string, unknown>) {
   return (data as Record<string, unknown>).template === "task_progress";
 }
@@ -1699,6 +1803,8 @@ export async function handleSurfaceAction(
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
   const ONE_SHOT_SURFACE_TYPES = [
+    "choice",
+    "oauth_connect",
     "form",
     "confirmation",
     "file_upload",
@@ -1860,6 +1966,12 @@ export function buildCompletionSummary(
   data?: Record<string, unknown>,
   surfaceData?: Record<string, unknown>,
 ): string {
+  const selectedTitles = Array.isArray(data?.selectedTitles)
+    ? data.selectedTitles.filter(
+        (title): title is string => typeof title === "string",
+      )
+    : [];
+
   if (surfaceType === "confirmation") {
     if (actionId === "cancel") {
       const cancelLabel =
@@ -1892,6 +2004,43 @@ export function buildCompletionSummary(
   if (surfaceType === "form") {
     return "Submitted";
   }
+  if (surfaceType === "choice" && data) {
+    const choiceTitle =
+      typeof data.choiceTitle === "string" ? data.choiceTitle : undefined;
+    if (choiceTitle) return `User chose: "${choiceTitle}"`;
+    if (selectedTitles.length === 1)
+      return `User chose: "${selectedTitles[0]}"`;
+    if (selectedTitles.length > 1) {
+      return `User chose ${selectedTitles.length} options: ${selectedTitles
+        .map((title) => `"${title}"`)
+        .join(", ")}`;
+    }
+    return `User chose: ${actionId}`;
+  }
+  if (surfaceType === "oauth_connect") {
+    const providerLabel =
+      typeof data?.providerLabel === "string"
+        ? data.providerLabel
+        : typeof data?.displayName === "string"
+          ? data.displayName
+          : typeof data?.providerKey === "string"
+            ? data.providerKey
+            : "OAuth";
+    const accountLabel =
+      typeof data?.accountLabel === "string" ? data.accountLabel : undefined;
+    if (actionId === "connect" || data?.status === "connected") {
+      return accountLabel
+        ? `Connected ${providerLabel}: ${accountLabel}`
+        : `Connected ${providerLabel}`;
+    }
+    if (actionId === "cancel" || data?.status === "cancelled") {
+      return `Cancelled ${providerLabel} connection`;
+    }
+    if (data?.status === "error") {
+      return `${providerLabel} connection failed`;
+    }
+    return `${providerLabel} connection ${actionId}`;
+  }
   if (surfaceType === "list" && data) {
     const selectedIds = data.selectedIds as string[] | undefined;
     const actionSuffix = actionId ? ` (action: ${actionId})` : "";
@@ -1922,6 +2071,11 @@ function buildUserFacingLabel(
   surfaceData?: Record<string, unknown>,
 ): string {
   const count = (data?.selectedIds as string[] | undefined)?.length;
+  const selectedTitles = Array.isArray(data?.selectedTitles)
+    ? data.selectedTitles.filter(
+        (title): title is string => typeof title === "string",
+      )
+    : [];
 
   if (surfaceType === "confirmation") {
     if (actionId === "cancel") {
@@ -1948,6 +2102,39 @@ function buildUserFacingLabel(
     return `Selected: ${actionId}`;
   }
   if (surfaceType === "form") return "Submitted";
+  if (surfaceType === "choice") {
+    const choiceTitle =
+      typeof data?.choiceTitle === "string" ? data.choiceTitle : undefined;
+    if (choiceTitle) return choiceTitle;
+    if (selectedTitles.length === 1) return selectedTitles[0];
+    if (selectedTitles.length > 1)
+      return `Selected ${selectedTitles.length} options`;
+    return "Selected";
+  }
+  if (surfaceType === "oauth_connect") {
+    const providerLabel =
+      typeof data?.providerLabel === "string"
+        ? data.providerLabel
+        : typeof data?.displayName === "string"
+          ? data.displayName
+          : typeof data?.providerKey === "string"
+            ? data.providerKey
+            : "OAuth";
+    const accountLabel =
+      typeof data?.accountLabel === "string" ? data.accountLabel : undefined;
+    if (actionId === "connect" || data?.status === "connected") {
+      return accountLabel
+        ? `Connected ${providerLabel}: ${accountLabel}`
+        : `Connected ${providerLabel}`;
+    }
+    if (actionId === "cancel" || data?.status === "cancelled") {
+      return "Cancelled";
+    }
+    if (data?.status === "error") {
+      return `${providerLabel} connection failed`;
+    }
+    return `Selected: ${actionId}`;
+  }
 
   // Table / list selection actions
   if (count) {
@@ -2213,11 +2400,17 @@ export async function surfaceProxyResolver(
     const data = (
       surfaceType === "card"
         ? normalizeCardShowData(input, rawData)
-        : surfaceType === "dynamic_page"
-          ? normalizeDynamicPageShowData(input, rawData)
-          : rawData
+        : surfaceType === "choice"
+          ? normalizeChoiceShowData(rawData)
+          : surfaceType === "copy_block"
+            ? normalizeCopyBlockShowData(rawData)
+            : surfaceType === "oauth_connect"
+              ? normalizeOAuthConnectShowData(rawData)
+              : surfaceType === "dynamic_page"
+                ? normalizeDynamicPageShowData(input, rawData)
+                : rawData
     ) as SurfaceData;
-    const actions = input.actions as
+    const inputActions = input.actions as
       | Array<{
           id: string;
           label: string;
@@ -2225,8 +2418,33 @@ export async function surfaceProxyResolver(
           data?: Record<string, unknown>;
         }>
       | undefined;
+    const actions =
+      surfaceType === "choice"
+        ? buildChoiceActions(data as ChoiceSurfaceData)
+        : inputActions;
     // Interactive surfaces default to awaiting user action.
     const hasActions = Array.isArray(actions) && actions.length > 0;
+    if (surfaceType === "choice" && !hasActions) {
+      return {
+        content:
+          "choice surfaces require at least one option with both id and title.",
+        isError: true,
+      };
+    }
+    const oauthProviderKey =
+      surfaceType === "oauth_connect"
+        ? (data as unknown as Record<string, unknown>).providerKey
+        : undefined;
+    if (
+      surfaceType === "oauth_connect" &&
+      (typeof oauthProviderKey !== "string" ||
+        oauthProviderKey.trim().length === 0)
+    ) {
+      return {
+        content: "oauth_connect surfaces require data.providerKey.",
+        isError: true,
+      };
+    }
     const isInteractive =
       surfaceType === "card"
         ? hasActions

package/src/daemon/conversation-tool-setup.ts

@@ -11,14 +11,12 @@ import {
   type InterfaceId,
   supportsHostProxy,
 } from "../channels/types.js";
-import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
-import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -48,27 +46,10 @@ import {
 } from "./doordash-steps.js";
 import type { ServerMessage, UiSurfaceShow } from "./message-protocol.js";
 import { runPostExecutionSideEffects } from "./tool-side-effects.js";
-import type { TrustContext } from "./trust-context.js";
+import { resolveTrustClass } from "./trust-context.js";
 
 const log = getLogger("conversation-tool-setup");
 
-/**
- * Resolve the effective trust class for tool execution.
- *
- * When HTTP auth is disabled (dev bypass), always returns `'guardian'`
- * so that control-plane gates don't block local development.
- *
- * When no trust context is available (e.g. desktop-only conversations that
- * don't go through channel trust resolution), defaults to `'unknown'`
- * to fail-closed.
- */
-export function resolveTrustClass(
-  trustContext: TrustContext | undefined,
-): TrustClass {
-  if (isHttpAuthDisabled()) return "guardian";
-  return trustContext?.trustClass ?? "unknown";
-}
-
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
 import {
@@ -97,7 +78,6 @@ export function createToolExecutor(
   input: Record<string, unknown>,
   onOutput?: (chunk: string) => void,
   toolUseId?: string,
-  turnContext?: import("../plugins/types.js").TurnContext,
 ) => Promise<ToolExecutionResult> {
   // Register the conversation's sendToClient for browser screencast surface messages
   registerConversationSender(ctx.conversationId, (msg) =>
@@ -109,7 +89,6 @@ export function createToolExecutor(
     input: Record<string, unknown>,
     onOutput?: (chunk: string) => void,
     toolUseId?: string,
-    turnContext?: import("../plugins/types.js").TurnContext,
   ) => {
     const { name: executionName, input: executionInput } =
       resolveToolInvocationAlias(name, input, ctx.allowedToolNames);
@@ -257,12 +236,7 @@ export function createToolExecutor(
         };
       }
 
-      const result = await executor.execute(
-        toolName,
-        toolInput,
-        toolContext,
-        turnContext,
-      );
+      const result = await executor.execute(toolName, toolInput, toolContext);
       if (toolContext.approvedViaPrompt) {
         ctx.approvedViaPromptThisTurn = true;
       }
@@ -276,7 +250,6 @@ export function createToolExecutor(
       executionName,
       executionInput,
       toolContext,
-      turnContext,
     );
     if (toolContext.approvedViaPrompt) {
       ctx.approvedViaPromptThisTurn = true;

package/src/daemon/conversation.ts

@@ -52,7 +52,6 @@ import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
   getConversation,
-  getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
   setConversationHistoryStrippedAt,
 } from "../memory/conversation-crud.js";
@@ -68,6 +67,7 @@ import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
+import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { ToolExecutor } from "../tools/executor.js";
 import { getAllToolDefinitions } from "../tools/registry.js";
 import type { ToolLifecycleEvent } from "../tools/types.js";
@@ -127,7 +127,6 @@ import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import {
   createResolveToolsCallback,
   createToolExecutor,
-  resolveTrustClass,
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
 import { canonicalizeTimeZone } from "./date-context.js";
@@ -143,6 +142,7 @@ import type {
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import { isHostProxyTransport } from "./message-types/conversations.js";
 import type { ConfirmationStateChanged } from "./message-types/messages.js";
+import { conversationMetadataSyncTag } from "./message-types/sync.js";
 import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
@@ -159,7 +159,7 @@ export type {
   QueueDrainReason,
   QueuePolicy,
 } from "./conversation-queue-manager.js";
-import type { TrustContext } from "./trust-context.js";
+import { resolveTrustClass, type TrustContext } from "./trust-context.js";
 
 export interface ConversationConstructorOptions {
   maxTokens?: number;
@@ -174,7 +174,7 @@ export class Conversation {
   /** @internal */ provider: Provider;
   /** @internal */ messages: Message[] = [];
   /** @internal */ agentLoop: AgentLoop;
-  /** @internal */ processing = false;
+  private _processing = false;
   private stale = false;
   /** @internal */ abortController: AbortController | null = null;
   /** @internal */ prompter: PermissionPrompter;
@@ -733,7 +733,30 @@ export class Conversation {
   }
 
   isProcessing(): boolean {
-    return this.processing;
+    return this._processing;
+  }
+
+  /**
+   * Mutate the server-authoritative `processing` flag. Web/Capacitor/CLI
+   * caches treat this flag as the source of truth for the avatar streaming
+   * ring and thinking indicator, so the `true → false` clear must announce
+   * itself: the daemon flips it in the agent-loop `finally` (after an awaited
+   * turn-boundary commit), which is later than the user-visible terminal SSE
+   * events, and a racing metadata refetch can otherwise re-read the
+   * not-yet-cleared `true` and clobber the client's optimistic `false`.
+   *
+   * Emitting a metadata invalidation on the clear lets every client GET the
+   * authoritative `false`, per the multi-client-sync contract in AGENTS.md
+   * ("emit the invalidation after the canonical state write succeeds").
+   */
+  setProcessing(value: boolean): void {
+    const wasProcessing = this._processing;
+    this._processing = value;
+    if (wasProcessing && !value) {
+      void publishSyncInvalidation([
+        conversationMetadataSyncTag(this.conversationId),
+      ]);
+    }
   }
 
   markStale(): void {
@@ -795,6 +818,7 @@ export class Conversation {
     this.cesClient = undefined;
     this.activeContextNodeIds = this.graphMemory.tracker.getActiveNodeIds();
     this.graphMemory.persistState();
+    this.graphMemory.dispose();
     disposeConversation(this);
   }
 
@@ -836,7 +860,7 @@ export class Conversation {
   }
 
   canHandoffAtCheckpoint(): boolean {
-    return this.processing && this.hasQueuedMessages();
+    return this._processing && this.hasQueuedMessages();
   }
 
   hasPendingConfirmation(requestId: string): boolean {
@@ -1020,9 +1044,7 @@ export class Conversation {
     }
   }
 
-  async forceCompact(options?: {
-    targetInputTokensOverride?: number;
-  }): Promise<ContextWindowResult> {
+  async forceCompact(): Promise<ContextWindowResult> {
     const conversationRow = getConversation(this.conversationId);
     const overrideProfile =
       getConversationOverrideProfileFromRow(conversationRow) ?? null;
@@ -1066,11 +1088,7 @@ export class Conversation {
       this.abortController?.signal ?? undefined,
       {
         force: true,
-        lastCompactedAt: this.contextCompactedAt ?? undefined,
-        conversationOriginChannel:
-          getConversationOriginChannel(this.conversationId) ?? undefined,
         overrideProfile,
-        targetInputTokensOverride: options?.targetInputTokensOverride,
         actorTrustClass: this.trustContext?.trustClass,
       },
     );
@@ -1251,7 +1269,7 @@ export class Conversation {
   async persistUserMessage(
     options: PersistMessageOptions,
   ): Promise<{ id: string; deduplicated: boolean }> {
-    if (!this.processing) {
+    if (!this._processing) {
       await this.ensureActorScopedHistory();
     }
     return persistUserMessageImpl(this, options);

package/src/daemon/external-plugins-bootstrap.ts

@@ -16,9 +16,8 @@
  *    the plugin is skipped wholesale — no `init()`, no tool/route/skill
  *    contributions, no entry in the shutdown hook, and the plugin is also
  *    dropped from the registry via {@link unregisterPlugin} so its middleware
- *    and injectors stop participating in pipeline runs and system-prompt
- *    assembly. This is the primary mechanism for shipping experimental
- *    plugins behind a feature flag.
+ *    stops participating in pipeline runs. This is the primary mechanism for
+ *    shipping experimental plugins behind a feature flag.
  * 4. Resolves the plugin's `manifest.requiresCredential` entries via the
  *    credential store helper ({@link getSecureKeyAsync}). In Docker mode
  *    that helper goes through the CES HTTP API transparently; in local mode
@@ -190,8 +189,8 @@ function getDisabledPluginFlag(
  * 1. Install the `globalThis.__vellumPluginRuntime` bridge so plugins can touch
  *    it from their module body (see `plugins/external-api.ts` — compiled-binary
  *    module identity).
- * 2. Register the first-party defaults so their middleware and injectors
- *    compose innermost, ahead of any user plugins.
+ * 2. Register the first-party defaults so their middleware composes innermost,
+ *    ahead of any user plugins.
  * 3. Load user plugins from `<workspaceDir>/plugins/*`. A failing user plugin is
  *    logged and skipped; `loadUserPlugins()` closes the registration window
  *    when it returns, so the defaults must already be registered by then.
@@ -228,7 +227,7 @@ export async function initializePlugins(): Promise<void> {
  */
 export async function bootstrapPlugins(): Promise<void> {
   // Register first-party default plugins. Each default wraps one of the
-  // assistant's canonical pipelines (`toolExecute`, `llmCall`, ...) with a
+  // assistant's canonical pipelines (`compaction`, `persistence`, ...) with a
   // passthrough so the pipeline shape is explicit at boot even when no
   // third-party plugins are loaded. Registration is idempotent via the
   // already-registered guard so repeated calls (e.g. during integration
@@ -237,8 +236,8 @@ export async function bootstrapPlugins(): Promise<void> {
 
   const plugins = getRegisteredPlugins();
   if (plugins.length === 0) {
-    // No-op fast path. The default injectors normally populate the registry,
-    // so this branch is primarily for tests that call
+    // No-op fast path. The default plugins normally populate the registry, so
+    // this branch is primarily for tests that call
     // `resetPluginRegistryForTests()` and stub the default registration.
     log.debug("bootstrapPlugins: registry empty — skipping");
     return;
@@ -263,8 +262,8 @@ export async function bootstrapPlugins(): Promise<void> {
   // two steps always move together on the bootstrap failure path: the former
   // clears tools/routes/skills (so they stop appearing to the model/HTTP
   // server), the latter drops the plugin's entry from the Map (so
-  // `getMiddlewaresFor` / `getInjectors` don't re-enter an uninitialized
-  // plugin on the next pipeline invocation).
+  // `getMiddlewaresFor` doesn't re-enter an uninitialized plugin on the next
+  // pipeline invocation).
   // Shutdown context is identical for every plugin in this boot — construct
   // once and reuse across the bootstrap-failure rollback and the normal
   // shutdown hook below. Only `assistantVersion` is exposed today; future

package/src/daemon/handlers/config-a2a.ts

@@ -10,6 +10,8 @@
  * - acceptA2AInvite()  — self-hosted broker: orchestrate complete + redeem across daemons
  */
 
+import { z } from "zod";
+
 import {
   getConfig,
   invalidateConfigCache,
@@ -38,42 +40,55 @@ const log = getLogger("config-a2a");
 
 // ── Result types ────────────────────────────────────────────────────
 
-export interface A2AConfigResult {
-  success: boolean;
-  enabled: boolean;
-  activeConnections: number;
-  error?: string;
-}
-
-export interface CreateA2AInviteResult {
-  success: boolean;
-  inviteId?: string;
-  token?: string;
-  expiresAt?: number;
-  senderGatewayUrl?: string;
-  error?: string;
-}
-
-export interface CompleteA2AInviteResult {
-  success: boolean;
-  sender?: { assistantId: string; displayName: string; gatewayUrl: string };
-  error?: string;
-}
-
-export interface RedeemA2AInviteResult {
-  success: boolean;
-  contactId?: string;
-  alreadyConnected?: boolean;
-  error?: string;
-}
-
-export interface AcceptA2AInviteResult {
-  success: boolean;
-  contactId?: string;
-  alreadyConnected?: boolean;
-  error?: string;
-  errorCode?: string;
-}
+export const A2AConfigResultSchema = z.object({
+  success: z.boolean(),
+  enabled: z.boolean(),
+  activeConnections: z.number(),
+  error: z.string().optional(),
+});
+export type A2AConfigResult = z.infer<typeof A2AConfigResultSchema>;
+
+export const CreateA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  inviteId: z.string().optional(),
+  token: z.string().optional(),
+  expiresAt: z.number().optional(),
+  senderGatewayUrl: z.string().optional(),
+  error: z.string().optional(),
+});
+export type CreateA2AInviteResult = z.infer<typeof CreateA2AInviteResultSchema>;
+
+export const CompleteA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  sender: z
+    .object({
+      assistantId: z.string(),
+      displayName: z.string(),
+      gatewayUrl: z.string(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+export type CompleteA2AInviteResult = z.infer<
+  typeof CompleteA2AInviteResultSchema
+>;
+
+export const RedeemA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  contactId: z.string().optional(),
+  alreadyConnected: z.boolean().optional(),
+  error: z.string().optional(),
+});
+export type RedeemA2AInviteResult = z.infer<typeof RedeemA2AInviteResultSchema>;
+
+export const AcceptA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  contactId: z.string().optional(),
+  alreadyConnected: z.boolean().optional(),
+  error: z.string().optional(),
+  errorCode: z.string().optional(),
+});
+export type AcceptA2AInviteResult = z.infer<typeof AcceptA2AInviteResultSchema>;
 
 // ── Config operations ───────────────────────────────────────────────