Correlate hosted SMS delivery failures

Author: dimavrem22

src/gateway/dispatch.ts

@@ -7,6 +7,7 @@ import type { ContactResolver } from "./contacts.js";
 import { normalizeAddress } from "./contacts.js";
 import type { NotifyOnce } from "./dedup.js";
 import { deliveryFailureKey, deliveryFailureRecovery } from "./delivery-policy.js";
+import { isSuccessfulHostedSmsMessage } from "./hosted-call-registry.js";
 import { downloadMedia, mediaDir } from "./media.js";
 import { SILENT } from "./prompts.js";
 import type {
@@ -425,6 +426,10 @@ async function handleDeliveryFailure(
   const r = resourceOf(event.body, isText ? "text_message" : "message");
   if (str(r?.direction)?.toLowerCase() === "inbound") return true;
   const messageId = str(r?.id);
+  if (isText && messageId && isSuccessfulHostedSmsMessage(messageId)) {
+    deps.logger.info("dispatch.hosted_sms_delivery_failed");
+    return true;
+  }
   const recipientRows = Array.isArray(r?.recipients) ? r.recipients : [];
   const failedRecipient = recipientRows
     .map((item) => record(item))

src/gateway/hosted-call-registry.ts

@@ -14,6 +14,7 @@ export interface HostedSmsAttempt {
   phase: "initial" | "correction";
   id: string;
   messageId?: string;
+  providerMessageId?: string;
   target?: string;
   targetMatches: boolean;
   state: "pending" | "success" | "failed";
@@ -386,6 +387,7 @@ export function settleHostedSmsAttempt(
   guard: HostedSmsGuard,
   state: "success" | "failed",
   errorKind?: HostedSmsErrorKind,
+  providerMessageId?: string,
 ): void {
   withRegistryMutation((registry) => {
     const entry = registry[hostedCallKey(guard.identityId, guard.callId)];
@@ -395,10 +397,21 @@ export function settleHostedSmsAttempt(
     }
     attempt.state = state;
     attempt.errorKind = errorKind;
+    if (state === "success") attempt.providerMessageId = bounded(providerMessageId, 256);
     entry.updatedAt = Date.now();
   });
 }
 
+export function isSuccessfulHostedSmsMessage(providerMessageId: string): boolean {
+  const id = providerMessageId.trim();
+  if (!id) return false;
+  return Object.values(read()).some((entry) =>
+    entry.smsAttempts.some(
+      (attempt) => attempt.state === "success" && attempt.providerMessageId === id,
+    ),
+  );
+}
+
 export function classifyHostedSmsError(error: unknown): HostedSmsErrorKind {
   const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
   if (

src/tools/send-sms.ts

@@ -166,7 +166,13 @@ export function sendSmsTools(deps: ToolDeps): RegisteredTool[] {
               };
               const msg = await identity.sendText(payload);
               providerAccepted = true;
-              if (hostedGuard) settleHostedSmsAttempt(hostedGuard, "success");
+              if (hostedGuard) {
+                const providerMessageId = String(msg.id ?? "").trim();
+                if (!providerMessageId) {
+                  throw new Error("SMS provider accepted the message without a message id.");
+                }
+                settleHostedSmsAttempt(hostedGuard, "success", undefined, providerMessageId);
+              }
               const target = formatTargetSummary(msg, args);
               const status = msg.deliveryStatus ?? "unknown";
               return {

tests/gateway/dispatch.test.ts

@@ -1,12 +1,21 @@
 // Event routing: channel selection, sender filtering (self/control/allowlist),
 // reactions, deduped delivery-failure captures, sender agent identities,
 // external events, and media.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { ResolvedConfig } from "../../src/config.js";
 import { defaultGatewayConfig } from "../../src/config.js";
 import { createNotifyOnce } from "../../src/gateway/dedup.js";
 import type { DispatchDeps } from "../../src/gateway/dispatch.js";
 import { dispatchEvent } from "../../src/gateway/dispatch.js";
+import {
+  activateHostedSmsCapture,
+  beginHostedSmsAttempt,
+  saveHostedCall,
+  settleHostedSmsAttempt,
+} from "../../src/gateway/hosted-call-registry.js";
 import { downloadMedia, mediaDir } from "../../src/gateway/media.js";
 import { frameInbound } from "../../src/gateway/prompts.js";
 import type { VerifiedEvent } from "../../src/gateway/types.js";
@@ -270,6 +279,73 @@ describe("dispatchEvent reactions", () => {
 });
 
 describe("dispatchEvent delivery failures", () => {
+  it("does not start generic recovery for a settled hosted SMS", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-hosted-delivery-"));
+    process.env.INKBOX_OPENCODE_HOME = dir;
+    try {
+      saveHostedCall({
+        identityId: "ident-1",
+        callId: "call-1",
+        eventId: "event-1",
+        state: "running",
+        event: {
+          id: "event-1",
+          event_type: "call.ended",
+          timestamp: "2026-08-01T00:00:00Z",
+          data: { call: { id: "call-1", mode: "hosted_agent" } },
+        } as never,
+      });
+      activateHostedSmsCapture({
+        identityId: "ident-1",
+        callId: "call-1",
+        sessionID: "session-1",
+        phase: "initial",
+        expectedTarget: "+15551112222",
+      });
+      const guard = beginHostedSmsAttempt({
+        sessionID: "session-1",
+        target: "+15551112222",
+        hasConversationId: false,
+      });
+      if (!guard) throw new Error("expected hosted SMS guard");
+      settleHostedSmsAttempt(guard, "success", undefined, "hosted-message-1");
+      saveHostedCall({
+        identityId: "ident-1",
+        callId: "call-1",
+        eventId: "event-1",
+        state: "completed",
+        outcome: "success",
+        retryable: false,
+        event: {
+          id: "event-1",
+          event_type: "call.ended",
+          timestamp: "2026-08-01T00:00:00Z",
+          data: { call: { id: "call-1", mode: "hosted_agent" } },
+        } as never,
+      });
+
+      const deps = makeDeps();
+      const ok = await dispatchEvent(
+        deps,
+        event("text.delivery_failed", {
+          text_message: {
+            id: "hosted-message-1",
+            remote_phone_number: "+15551112222",
+            error_detail: "handset unreachable",
+            error_code: "undelivered",
+          },
+        }),
+      );
+
+      expect(ok).toBe(true);
+      expect(deps.sessions.runCapture).not.toHaveBeenCalled();
+      expect(deps.contacts.resolve).not.toHaveBeenCalled();
+    } finally {
+      delete process.env.INKBOX_OPENCODE_HOME;
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("runs a capture on the first failure and dedupes a repeat with the same id", async () => {
     const deps = makeDeps();
     const failure = event("text.delivery_failed", {

tests/live/voice-proof.ts

@@ -26,3 +26,11 @@ export function hasSmsIntent(value: string): boolean {
     /\b(?:text|sms) (?:me|the caller|the user|them|him|her)\b/.test(normalized)
   );
 }
+
+export function wasAcceptedForDelivery(message: {
+  deliveryStatus?: unknown;
+  delivery_status?: unknown;
+}): boolean {
+  const status = String(message.deliveryStatus ?? message.delivery_status ?? "").toLowerCase();
+  return status !== "blocked_spam_filter";
+}

tests/live/voice.test.ts

@@ -24,7 +24,12 @@ import {
   waitDriverLocalSpeech,
   waitTwoWayCall,
 } from "./helpers.js";
-import { containsVoiceMarker, hasAfterCallSmsIntent, hasSmsIntent } from "./voice-proof.js";
+import {
+  containsVoiceMarker,
+  hasAfterCallSmsIntent,
+  hasSmsIntent,
+  wasAcceptedForDelivery,
+} from "./voice-proof.js";
 
 const SCENARIO = process.env.VOICE_SCENARIO ?? "";
 const STATE_FILE = process.env.VOICE_DRIVER_STATE || "/tmp/voice_driver_state.json";
@@ -490,9 +495,10 @@ describe.skipIf(!LIVE || !REAL_MODEL)("live voice", () => {
             );
           },
         );
-        matched = fresh.filter((message: any) =>
+        const markerRows = fresh.filter((message: any) =>
           containsVoiceMarker(String(message.text ?? ""), HOSTED_MARKER),
         );
+        matched = markerRows.filter(wasAcceptedForDelivery);
         try {
           const registry = JSON.parse(
             readFileSync(
@@ -504,13 +510,17 @@ describe.skipIf(!LIVE || !REAL_MODEL)("live voice", () => {
         } catch {
           registryEntry = undefined;
         }
-        progress.last = `marker_rows=${matched.length} registry_state=${registryEntry?.state ?? "missing"}`;
+        progress.last =
+          `accepted_marker_rows=${matched.length} ` +
+          `blocked_marker_rows=${markerRows.length - matched.length} ` +
+          `registry_state=${registryEntry?.state ?? "missing"}`;
         if (matched.length === 1 && registryEntry?.state === "completed") {
           await new Promise((resolve) => setTimeout(resolve, duplicateGraceMs));
           const afterGrace = (await outboundTextsTo(aut, autPhone.id, st.number)).filter(
             (message: any) =>
               !beforeSmsIds.has(message.id) &&
               (recordCreatedAt(message) ?? -1) >= scenarioStartedAt &&
+              wasAcceptedForDelivery(message) &&
               containsVoiceMarker(String(message.text ?? ""), HOSTED_MARKER),
           );
           expect(afterGrace.length).toBe(1);

tests/unit/hosted-send-sms.test.ts

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   activateHostedSmsCapture,
   getHostedCall,
+  isSuccessfulHostedSmsMessage,
   saveHostedCall,
 } from "../../src/gateway/hosted-call-registry.js";
 import { sendSmsTools } from "../../src/tools/send-sms.js";
@@ -88,7 +89,12 @@ describe("hosted send SMS boundary", () => {
     } as any;
     await tool.definition.execute({ to: "+14155550123", text: "bravo maple" }, ctx);
     expect(sendText).toHaveBeenCalledOnce();
-    expect(getHostedCall("ident-1", "call-1")?.smsAttempts[0].state).toBe("success");
+    expect(getHostedCall("ident-1", "call-1")?.smsAttempts[0]).toMatchObject({
+      state: "success",
+      providerMessageId: "sms-1",
+    });
+    expect(isSuccessfulHostedSmsMessage("sms-1")).toBe(true);
+    expect(isSuccessfulHostedSmsMessage("sms-other")).toBe(false);
   });
 
   it("does not rewrite a provider-accepted SMS as failed when success journaling fails", async () => {

tests/unit/voice-proof.test.ts

@@ -4,6 +4,7 @@ import {
   hasAfterCallSmsIntent,
   hasSmsIntent,
   normalizedVoiceTokens,
+  wasAcceptedForDelivery,
 } from "../live/voice-proof.js";
 
 describe("hosted live voice proof normalization", () => {
@@ -28,4 +29,14 @@ describe("hosted live voice proof normalization", () => {
     expect(hasSmsIntent("Send a text message containing the marker after the call.")).toBe(true);
     expect(hasSmsIntent("Review the text-message history.")).toBe(false);
   });
+
+  it("does not count a pre-delivery policy block as an accepted SMS", () => {
+    expect(wasAcceptedForDelivery({ deliveryStatus: "blocked_spam_filter" })).toBe(false);
+    expect(wasAcceptedForDelivery({ delivery_status: "blocked_spam_filter" })).toBe(false);
+    expect(wasAcceptedForDelivery({ deliveryStatus: "queued" })).toBe(true);
+    expect(wasAcceptedForDelivery({ deliveryStatus: "delivered" })).toBe(true);
+    expect(wasAcceptedForDelivery({ deliveryStatus: "delivery_failed" })).toBe(true);
+    expect(wasAcceptedForDelivery({ deliveryStatus: "sending_failed" })).toBe(true);
+    expect(wasAcceptedForDelivery({})).toBe(true);
+  });
 });