@vellumai/assistant 0.3.4 → 0.3.5

package/src/daemon/handlers/dictation.ts

@@ -0,0 +1,182 @@
+import * as net from 'node:net';
+import { getConfig } from '../../config/loader.js';
+import { getFailoverProvider, listProviders } from '../../providers/registry.js';
+import type { DictationRequest } from '../ipc-protocol.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
+
+// Action verbs that signal the user wants a full agent session rather than inline text
+const ACTION_VERBS = ['slack', 'email', 'send', 'create', 'open', 'search', 'find'];
+
+const MAX_WINDOW_TITLE_LENGTH = 100;
+
+/** Sanitize window title to mitigate prompt injection from attacker-controlled titles (e.g. browser tabs, Slack conversations). */
+function sanitizeWindowTitle(title: string | undefined): string {
+  if (!title) return '';
+  return title
+    .replace(/[<>]/g, '') // strip angle brackets to prevent tag injection
+    .slice(0, MAX_WINDOW_TITLE_LENGTH);
+}
+
+/** Build a delimited app metadata block so the LLM treats it as contextual data, not instructions. */
+function buildAppMetadataBlock(msg: DictationRequest): string {
+  const windowTitle = sanitizeWindowTitle(msg.context.windowTitle);
+  return [
+    '<app_metadata>',
+    `App: ${msg.context.appName} (${msg.context.bundleIdentifier})`,
+    `Window: ${windowTitle}`,
+    '</app_metadata>',
+  ].join('\n');
+}
+
+type DictationMode = 'dictation' | 'command' | 'action';
+
+export function detectDictationMode(msg: DictationRequest): DictationMode {
+  // Command mode: selected text present — treat transcription as a transformation instruction
+  if (msg.context.selectedText && msg.context.selectedText.trim().length > 0) {
+    return 'command';
+  }
+
+  // Action mode: transcription starts with an action verb
+  const firstWord = msg.transcription.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
+  if (ACTION_VERBS.includes(firstWord)) {
+    return 'action';
+  }
+
+  // Dictation mode: cursor is in a text field with no selection — clean up for typing
+  if (msg.context.cursorInTextField) {
+    return 'dictation';
+  }
+
+  // AX focus-role detection in browser editors (for example Gmail compose)
+  // is occasionally incomplete. If we default to action here, normal dictation
+  // gets misrouted into a new chat task. Treat ambiguous context as dictation.
+  return 'dictation';
+}
+
+function buildDictationPrompt(msg: DictationRequest): string {
+  return [
+    'You are a dictation assistant. Clean up the following speech transcription for direct insertion into a text field.',
+    '',
+    '## Rules',
+    '- Fix grammar, punctuation, and capitalization',
+    '- Remove filler words (um, uh, like, you know)',
+    "- Maintain the speaker's intent and meaning",
+    '- Do NOT add explanations or commentary',
+    '- Return ONLY the cleaned text, nothing else',
+    '',
+    '## Tone Adaptation',
+    'Adapt your output tone based on the active application:',
+    '- Email apps (Gmail, Mail): Professional but warm. Use proper greetings and sign-offs if appropriate.',
+    '- Slack: Casual and conversational. Match typical chat style.',
+    '- Code editors (VS Code, Xcode): Technical and concise. Code comments style.',
+    '- Terminal: Command-like, terse.',
+    '- Messages/iMessage: Very casual, texting style. Short sentences.',
+    '- Notes/Docs: Neutral, clear writing.',
+    '- Default: Match the user\'s natural voice.',
+    '',
+    '## Context Clues',
+    '- Window title may contain recipient name (Slack DMs, email compose)',
+    '- If you can identify a recipient, adapt formality to the apparent relationship',
+    '- Maintain the user\'s natural voice — don\'t over-formalize casual speech',
+    '- The user\'s writing patterns and preferences may be available from memory context — follow those when present',
+    '',
+    buildAppMetadataBlock(msg),
+  ].join('\n');
+}
+
+function buildCommandPrompt(msg: DictationRequest): string {
+  return [
+    'You are a text transformation assistant. The user has selected text and given a voice command to transform it.',
+    '',
+    '## Rules',
+    '- Apply the instruction to the selected text',
+    '- Return ONLY the transformed text, nothing else',
+    '- Do NOT add explanations or commentary',
+    '',
+    '## Tone Adaptation',
+    'Match the tone to the active application context:',
+    '- Email apps (Gmail, Mail): Professional but warm.',
+    '- Slack: Casual and conversational.',
+    '- Code editors (VS Code, Xcode): Technical and concise.',
+    '- Terminal: Command-like, terse.',
+    '- Messages/iMessage: Very casual, texting style.',
+    '- Notes/Docs: Neutral, clear writing.',
+    '- Default: Match the user\'s natural voice.',
+    '',
+    '## Context Clues',
+    '- Window title may contain recipient name (Slack DMs, email compose)',
+    '- If you can identify a recipient, adapt formality to the apparent relationship',
+    '- Maintain the user\'s natural voice — don\'t over-formalize casual speech',
+    '- The user\'s writing patterns and preferences may be available from memory context — follow those when present',
+    '',
+    buildAppMetadataBlock(msg),
+    '',
+    'Selected text:',
+    msg.context.selectedText ?? '',
+    '',
+    `Instruction: ${msg.transcription}`,
+  ].join('\n');
+}
+
+export async function handleDictationRequest(
+  msg: DictationRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const mode = detectDictationMode(msg);
+  log.info({ mode, transcriptionLength: msg.transcription.length }, 'Dictation request received');
+
+  // Action mode: return immediately — the client will route to a full agent session
+  if (mode === 'action') {
+    ctx.send(socket, {
+      type: 'dictation_response',
+      text: msg.transcription,
+      mode: 'action',
+      actionPlan: `User wants to: ${msg.transcription}`,
+    });
+    return;
+  }
+
+  // Dictation / command mode: make a single-turn LLM call for text cleanup or transformation
+  const systemPrompt = mode === 'dictation'
+    ? buildDictationPrompt(msg)
+    : buildCommandPrompt(msg);
+
+  const userText = mode === 'dictation'
+    ? msg.transcription
+    : msg.transcription; // command prompt already embeds the selected text and instruction
+
+  try {
+    const config = getConfig();
+    if (!listProviders().includes(config.provider)) {
+      log.warn({ provider: config.provider }, 'Dictation: no provider available, returning raw transcription');
+      const fallbackText = mode === 'command' ? (msg.context.selectedText ?? msg.transcription) : msg.transcription;
+      ctx.send(socket, { type: 'dictation_response', text: fallbackText, mode });
+      return;
+    }
+
+    const provider = getFailoverProvider(config.provider, config.providerOrder);
+    const response = await provider.sendMessage(
+      [{ role: 'user', content: [{ type: 'text', text: userText }] }],
+      [], // no tools
+      systemPrompt,
+      { config: { max_tokens: 1024 } },
+    );
+
+    const textBlock = response.content.find((b) => b.type === 'text');
+    const inlineFallback = mode === 'command' ? (msg.context.selectedText ?? msg.transcription) : msg.transcription;
+    const cleanedText = textBlock && 'text' in textBlock ? textBlock.text.trim() : inlineFallback;
+
+    ctx.send(socket, { type: 'dictation_response', text: cleanedText, mode });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Dictation LLM call failed, returning raw transcription');
+    const fallbackText = mode === 'command' ? (msg.context.selectedText ?? msg.transcription) : msg.transcription;
+    ctx.send(socket, { type: 'dictation_response', text: fallbackText, mode });
+    ctx.send(socket, { type: 'error', message: `Dictation cleanup failed: ${message}` });
+  }
+}
+
+export const dictationHandlers = defineHandlers({
+  dictation_request: handleDictationRequest,
+});

package/src/daemon/handlers/identity.ts

@@ -2,7 +2,7 @@ import * as net from 'node:net';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { getWorkspacePromptPath } from '../../util/platform.js';
+import { getWorkspacePromptPath, readLockfile } from '../../util/platform.js';
 import { log, defineHandlers, type HandlerContext } from './shared.js';
 
 function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
@@ -68,28 +68,19 @@ function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
     let cloud: string | undefined;
     let originSystem: string | undefined;
     try {
-      const homedir = process.env.HOME ?? process.env.USERPROFILE ?? '';
-      const lockfilePaths = [
-        join(homedir, '.vellum.lock.json'),
-        join(homedir, '.vellum.lockfile.json'),
-      ];
-      for (const lockPath of lockfilePaths) {
-        if (!existsSync(lockPath)) continue;
-        const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
-        const assistants = lockData.assistants as Array<Record<string, unknown>> | undefined;
-        if (assistants && assistants.length > 0) {
-          // Use the most recently hatched assistant
-          const sorted = [...assistants].sort((a, b) => {
-            const dateA = new Date(a.hatchedAt as string || 0).getTime();
-            const dateB = new Date(b.hatchedAt as string || 0).getTime();
-            return dateB - dateA;
-          });
-          const latest = sorted[0];
-          assistantId = latest.assistantId as string | undefined;
-          cloud = latest.cloud as string | undefined;
-          originSystem = cloud === 'local' ? 'local' : cloud;
-        }
-        break;
+      const lockData = readLockfile();
+      const assistants = lockData?.assistants as Array<Record<string, unknown>> | undefined;
+      if (assistants && assistants.length > 0) {
+        // Use the most recently hatched assistant
+        const sorted = [...assistants].sort((a, b) => {
+          const dateA = new Date(a.hatchedAt as string || 0).getTime();
+          const dateB = new Date(b.hatchedAt as string || 0).getTime();
+          return dateB - dateA;
+        });
+        const latest = sorted[0];
+        assistantId = latest.assistantId as string | undefined;
+        cloud = latest.cloud as string | undefined;
+        originSystem = cloud === 'local' ? 'local' : cloud;
       }
     } catch {
       // ignore — lockfile may not exist

package/src/daemon/handlers/index.ts

@@ -22,6 +22,7 @@ import { signingHandlers } from './signing.js';
 import { twitterAuthHandlers } from './twitter-auth.js';
 import { workspaceFileHandlers } from './workspace-files.js';
 import { identityHandlers } from './identity.js';
+import { dictationHandlers } from './dictation.js';
 
 // Re-export types and utilities for backwards compatibility
 export type {
@@ -107,6 +108,7 @@ const handlers = {
   ...twitterAuthHandlers,
   ...workspaceFileHandlers,
   ...identityHandlers,
+  ...dictationHandlers,
   ...inlineHandlers,
 } satisfies DispatchMap;
 

package/src/daemon/handlers/sessions.ts

@@ -114,6 +114,8 @@ export async function handleUserMessage(
     }
 
     rlog.info('Processing user message');
+    session.setAssistantId('self');
+    session.setGuardianContext(null);
     // Fire-and-forget: don't block the IPC handler so the connection can
     // continue receiving messages (e.g. cancel, confirmations, or
     // additional user_message that will be queued by the session).

package/src/daemon/handlers/shared.ts

@@ -9,6 +9,7 @@ import type { ClientMessage, CuSessionCreate, ServerMessage, SessionTransportMet
 import type { SecretPromptResult } from '../../permissions/secret-prompter.js';
 import { getConfig } from '../../config/loader.js';
 import type { DebouncerMap } from '../../util/debounce.js';
+import type { GuardianRuntimeContext } from '../session-runtime-assembly.js';
 
 const log = getLogger('handlers');
 
@@ -99,6 +100,8 @@ export interface SessionCreateOptions {
   systemPromptOverride?: string;
   maxResponseTokens?: number;
   transport?: SessionTransportMetadata;
+  assistantId?: string;
+  guardianContext?: GuardianRuntimeContext;
   memoryScopeId?: string;
   isPrivateThread?: boolean;
   strictPrivateSideEffects?: boolean;

package/src/daemon/handlers/work-items.ts

@@ -148,15 +148,23 @@ function broadcastWorkItemStatus(ctx: HandlerContext, id: string): void {
   }
 }
 
-/** Extract plain text from a message content string (handles JSON content block arrays). */
-function extractTextFromContent(content: string): string {
+/**
+ * Extract only the latest assistant text block from stored content.
+ * Consolidation merges multiple assistant messages into one DB row; scanning
+ * from the end keeps task output focused on the final assistant response.
+ */
+function extractLatestTextFromContent(content: string): string {
   try {
     const parsed = JSON.parse(content);
     if (Array.isArray(parsed)) {
-      return parsed
-        .filter((b: { type: string }) => b.type === 'text')
-        .map((b: { text: string }) => b.text)
-        .join('\n');
+      for (let i = parsed.length - 1; i >= 0; i--) {
+        const block = parsed[i] as { type?: unknown; text?: unknown };
+        if (block.type !== 'text') continue;
+        if (typeof block.text !== 'string') continue;
+        if (!block.text.trim()) continue;
+        return block.text;
+      }
+      return '';
     }
   } catch {
     // Plain text content — use as-is
@@ -299,7 +307,7 @@ export function handleWorkItemOutput(
       const m = msgs[i];
       if (m.role !== 'assistant') continue;
 
-      const text = extractTextFromContent(m.content);
+      const text = extractLatestTextFromContent(m.content);
       if (!text.trim()) continue;
 
       summary = truncate(text, 2000, '');

package/src/daemon/ipc-contract-inventory.json

@@ -19,12 +19,14 @@
     "BrowserUserScroll",
     "BundleAppRequest",
     "CancelRequest",
+    "ChannelReadinessRequest",
     "ConfirmationResponse",
     "CuObservation",
     "CuSessionAbort",
     "CuSessionCreate",
     "DeleteQueuedMessage",
     "DiagnosticsExportRequest",
+    "DictationRequest",
     "DocumentListRequest",
     "DocumentLoadRequest",
     "DocumentSaveRequest",
@@ -137,6 +139,7 @@
     "BrowserHandoffRequest",
     "BrowserInteractiveModeChanged",
     "BundleAppResponse",
+    "ChannelReadinessResponse",
     "ConfirmationRequest",
     "ContextCompacted",
     "CuAction",
@@ -144,6 +147,7 @@
     "CuError",
     "DaemonStatusMessage",
     "DiagnosticsExportResponse",
+    "DictationResponse",
     "DocumentEditorShow",
     "DocumentEditorUpdate",
     "DocumentListResponse",
@@ -179,6 +183,7 @@
     "PublishPageResponse",
     "ReminderFired",
     "RemindersListResponse",
+    "RideShotgunProgress",
     "RideShotgunResult",
     "ScheduleComplete",
     "SchedulesListResponse",
@@ -268,12 +273,14 @@
     "browser_user_scroll",
     "bundle_app",
     "cancel",
+    "channel_readiness",
     "confirmation_response",
     "cu_observation",
     "cu_session_abort",
     "cu_session_create",
     "delete_queued_message",
     "diagnostics_export_request",
+    "dictation_request",
     "document_list",
     "document_load",
     "document_save",
@@ -386,6 +393,7 @@
     "browser_handoff_request",
     "browser_interactive_mode_changed",
     "bundle_app_response",
+    "channel_readiness_response",
     "confirmation_request",
     "context_compacted",
     "cu_action",
@@ -393,6 +401,7 @@
     "cu_error",
     "daemon_status",
     "diagnostics_export_response",
+    "dictation_response",
     "document_editor_show",
     "document_editor_update",
     "document_list_response",
@@ -428,6 +437,7 @@
     "publish_page_response",
     "reminder_fired",
     "reminders_list_response",
+    "ride_shotgun_progress",
     "ride_shotgun_result",
     "schedule_complete",
     "schedules_list_response",

package/src/daemon/ipc-contract.ts

@@ -23,6 +23,14 @@ export interface UsageStats {
   estimatedCost: number;
 }
 
+export interface DictationContext {
+  bundleIdentifier: string;
+  appName: string;
+  windowTitle: string;
+  selectedText?: string;
+  cursorInTextField: boolean;
+}
+
 // === Client → Server messages ===
 
 export interface UserMessage {
@@ -555,13 +563,31 @@ export interface TelegramConfigResponse {
 
 export interface TwilioConfigRequest {
   type: 'twilio_config';
-  action: 'get' | 'set_credentials' | 'clear_credentials' | 'provision_number' | 'assign_number' | 'list_numbers';
+  action: 'get' | 'set_credentials' | 'clear_credentials' | 'provision_number' | 'assign_number' | 'list_numbers'
+    | 'sms_compliance_status' | 'sms_submit_tollfree_verification' | 'sms_update_tollfree_verification'
+    | 'sms_delete_tollfree_verification' | 'release_number' | 'sms_send_test' | 'sms_doctor';
   accountSid?: string;        // Only for action: 'set_credentials'
   authToken?: string;         // Only for action: 'set_credentials'
-  phoneNumber?: string;       // Only for action: 'assign_number'
+  phoneNumber?: string;       // Only for action: 'assign_number' or 'sms_send_test'
   areaCode?: string;          // Only for action: 'provision_number'
   country?: string;           // Only for action: 'provision_number' (ISO 3166-1 alpha-2, default 'US')
   assistantId?: string;       // Scope number assignment/lookup to a specific assistant
+  verificationSid?: string;   // Only for update/delete verification actions
+  verificationParams?: {
+    tollfreePhoneNumberSid?: string;
+    businessName?: string;
+    businessWebsite?: string;
+    notificationEmail?: string;
+    useCaseCategories?: string[];
+    useCaseSummary?: string;
+    productionMessageSample?: string;
+    optInImageUrls?: string[];
+    optInType?: string;
+    messageVolume?: string;
+    businessType?: string;
+    customerProfileSid?: string;
+  };
+  text?: string;              // Only for action: 'sms_send_test' (default: "Test SMS from your Vellum assistant")
 }
 
 export interface TwilioConfigResponse {
@@ -573,6 +599,56 @@ export interface TwilioConfigResponse {
   error?: string;
   /** Non-fatal warning message (e.g. webhook sync failure that did not prevent the primary operation). */
   warning?: string;
+  compliance?: {
+    numberType?: string;
+    verificationSid?: string;
+    verificationStatus?: string;
+    rejectionReason?: string;
+    rejectionReasons?: string[];
+    errorCode?: string;
+    editAllowed?: boolean;
+    editExpiration?: string;
+  };
+  /** Present when action is 'sms_send_test'. */
+  testResult?: {
+    messageSid: string;
+    to: string;
+    initialStatus: string;
+    finalStatus: string;
+    errorCode?: string;
+    errorMessage?: string;
+  };
+  /** Present when action is 'sms_doctor'. */
+  diagnostics?: {
+    readiness: { ready: boolean; issues: string[] };
+    compliance: { status: string; detail?: string; remediation?: string };
+    lastSend?: { status: string; errorCode?: string; remediation?: string };
+    overallStatus: 'healthy' | 'degraded' | 'broken';
+    actionItems: string[];
+  };
+}
+
+export interface ChannelReadinessRequest {
+  type: 'channel_readiness';
+  action: 'get' | 'refresh';
+  channel?: string;
+  assistantId?: string;
+  includeRemote?: boolean;
+}
+
+export interface ChannelReadinessResponse {
+  type: 'channel_readiness_response';
+  success: boolean;
+  snapshots?: Array<{
+    channel: string;
+    ready: boolean;
+    checkedAt: number;
+    stale: boolean;
+    reasons: Array<{ code: string; text: string }>;
+    localChecks: Array<{ name: string; passed: boolean; message: string }>;
+    remoteChecks?: Array<{ name: string; passed: boolean; message: string }>;
+  }>;
+  error?: string;
 }
 
 export interface GuardianVerificationRequest {
@@ -597,6 +673,10 @@ export interface GuardianVerificationResponse {
   assistantId?: string;
   /** The delivery chat ID for the guardian (e.g. Telegram chat ID). Present when action is 'status' and bound is true. */
   guardianDeliveryChatId?: string;
+  /** Optional channel username/handle for the bound guardian (for UI display). */
+  guardianUsername?: string;
+  /** Optional display name for the bound guardian (for UI display). */
+  guardianDisplayName?: string;
   error?: string;
 }
 
@@ -659,6 +739,12 @@ export interface IpcBlobProbe {
   nonceSha256: string;
 }
 
+export interface DictationRequest {
+  type: 'dictation_request';
+  transcription: string;
+  context: DictationContext;
+}
+
 // === Surface types ===
 
 export type SurfaceType = 'card' | 'form' | 'list' | 'table' | 'confirmation' | 'dynamic_page' | 'file_upload' | 'browser_view' | 'document_preview';
@@ -1084,6 +1170,7 @@ export type ClientMessage =
   | TwitterIntegrationConfigRequest
   | TelegramConfigRequest
   | TwilioConfigRequest
+  | ChannelReadinessRequest
   | GuardianVerificationRequest
   | TwitterAuthStartRequest
   | TwitterAuthStatusRequest
@@ -1129,7 +1216,8 @@ export type ClientMessage =
   | WorkspaceFileReadRequest
   | IdentityGetRequest
   | ToolPermissionSimulateRequest
-  | ToolNamesListRequest;
+  | ToolNamesListRequest
+  | DictationRequest;
 
 export interface IntegrationListRequest {
   type: 'integration_list';
@@ -1528,6 +1616,12 @@ export interface TaskRouted {
   escalatedFrom?: string;
 }
 
+export interface RideShotgunProgress {
+  type: 'ride_shotgun_progress';
+  watchId: string;
+  message: string;
+}
+
 export interface RideShotgunResult {
   type: 'ride_shotgun_result';
   sessionId: string;
@@ -2366,6 +2460,13 @@ export interface ToolNamesListResponse {
   schemas?: Record<string, ToolInputSchema>;
 }
 
+export interface DictationResponse {
+  type: 'dictation_response';
+  text: string;
+  mode: 'dictation' | 'command' | 'action';
+  actionPlan?: string;
+}
+
 export type ServerMessage =
   | AuthResult
   | UserMessageEcho
@@ -2400,6 +2501,7 @@ export type ServerMessage =
   | CuError
   | SessionErrorMessage
   | TaskRouted
+  | RideShotgunProgress
   | RideShotgunResult
   | UiSurfaceShow
   | UiSurfaceUpdate
@@ -2452,6 +2554,7 @@ export type ServerMessage =
   | TwitterIntegrationConfigResponse
   | TelegramConfigResponse
   | TwilioConfigResponse
+  | ChannelReadinessResponse
   | GuardianVerificationResponse
   | TwitterAuthResult
   | TwitterAuthStatusResponse
@@ -2495,7 +2598,8 @@ export type ServerMessage =
   | WorkspaceFileReadResponse
   | IdentityGetResponse
   | ToolPermissionSimulateResponse
-  | ToolNamesListResponse;
+  | ToolNamesListResponse
+  | DictationResponse;
 
 // === Subagent IPC ─────────────────────────────────────────────────────
 

package/src/daemon/lifecycle.ts

@@ -42,6 +42,7 @@ import { registerMessagingProvider } from '../messaging/registry.js';
 import { slackProvider as slackMessagingProvider } from '../messaging/providers/slack/adapter.js';
 import { gmailMessagingProvider } from '../messaging/providers/gmail/adapter.js';
 import { telegramBotMessagingProvider } from '../messaging/providers/telegram-bot/adapter.js';
+import { smsMessagingProvider } from '../messaging/providers/sms/adapter.js';
 import { browserManager } from '../tools/browser/browser-manager.js';
 import { RuntimeHttpServer } from '../runtime/http-server.js';
 import { getHookManager } from '../hooks/manager.js';
@@ -386,6 +387,7 @@ export async function runDaemon(): Promise<void> {
   registerMessagingProvider(slackMessagingProvider);
   registerMessagingProvider(gmailMessagingProvider);
   registerMessagingProvider(telegramBotMessagingProvider);
+  registerMessagingProvider(smsMessagingProvider);
 
   const scheduler = startScheduler(
     async (conversationId, message) => {

package/src/daemon/ride-shotgun-handler.ts

@@ -177,7 +177,7 @@ export async function handleRideShotgunStart(
                   type: 'ride_shotgun_progress',
                   watchId,
                   message: `[${progress.pageNumber || '?'}] ${shortUrl}`,
-                } as any);
+                });
               }
             }).then(visited => {
               clearInterval(checkInterval);

package/src/daemon/server.ts

@@ -666,6 +666,8 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
+    session.setAssistantId(options?.assistantId ?? 'self');
+    session.setGuardianContext(options?.guardianContext ?? null);
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     const attachments = attachmentIds
@@ -720,6 +722,8 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
+    session.setAssistantId(options?.assistantId ?? 'self');
+    session.setGuardianContext(options?.guardianContext ?? null);
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     const attachments = attachmentIds
@@ -790,8 +794,8 @@ export class DaemonServer {
 
   createRunOrchestrator(): RunOrchestrator {
     return new RunOrchestrator({
-      getOrCreateSession: (conversationId) =>
-        this.getOrCreateSession(conversationId),
+      getOrCreateSession: (conversationId, transport) =>
+        this.getOrCreateSession(conversationId, undefined, true, transport ? { transport } : undefined),
       resolveAttachments: (attachmentIds) =>
         attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,