@contractspec/integration.runtime 2.10.0 → 3.0.0

package/dist/channel/memory-store.d.ts

@@ -0,0 +1,28 @@
+import type { ChannelDecisionRecord, ChannelDeliveryAttemptRecord, ChannelEventReceiptRecord, ChannelOutboxActionRecord, ChannelThreadRecord } from './types';
+import type { ChannelRuntimeStore, ClaimEventReceiptInput, ClaimEventReceiptResult, EnqueueOutboxActionInput, EnqueueOutboxActionResult, MarkOutboxDeadLetterInput, MarkOutboxRetryInput, RecordDeliveryAttemptInput, SaveDecisionInput, UpsertThreadInput } from './store';
+export declare class InMemoryChannelRuntimeStore implements ChannelRuntimeStore {
+    readonly receipts: Map<string, ChannelEventReceiptRecord>;
+    readonly threads: Map<string, ChannelThreadRecord>;
+    readonly decisions: Map<string, ChannelDecisionRecord>;
+    readonly outbox: Map<string, ChannelOutboxActionRecord>;
+    readonly deliveryAttempts: Map<string, ChannelDeliveryAttemptRecord>;
+    private readonly receiptKeyToId;
+    private readonly threadKeyToId;
+    private readonly outboxKeyToId;
+    private deliveryAttemptSequence;
+    claimEventReceipt(input: ClaimEventReceiptInput): Promise<ClaimEventReceiptResult>;
+    updateReceiptStatus(receiptId: string, status: ChannelEventReceiptRecord['status'], error?: {
+        code: string;
+        message: string;
+    }): Promise<void>;
+    upsertThread(input: UpsertThreadInput): Promise<ChannelThreadRecord>;
+    saveDecision(input: SaveDecisionInput): Promise<ChannelDecisionRecord>;
+    enqueueOutboxAction(input: EnqueueOutboxActionInput): Promise<EnqueueOutboxActionResult>;
+    claimPendingOutboxActions(limit: number, now?: Date): Promise<ChannelOutboxActionRecord[]>;
+    recordDeliveryAttempt(input: RecordDeliveryAttemptInput): Promise<ChannelDeliveryAttemptRecord>;
+    markOutboxSent(actionId: string, providerMessageId?: string): Promise<void>;
+    markOutboxRetry(input: MarkOutboxRetryInput): Promise<void>;
+    markOutboxDeadLetter(input: MarkOutboxDeadLetterInput): Promise<void>;
+    private receiptKey;
+    private threadKey;
+}

package/dist/channel/memory-store.js

@@ -0,0 +1,223 @@
+// @bun
+// src/channel/memory-store.ts
+import { randomUUID } from "crypto";
+
+class InMemoryChannelRuntimeStore {
+  receipts = new Map;
+  threads = new Map;
+  decisions = new Map;
+  outbox = new Map;
+  deliveryAttempts = new Map;
+  receiptKeyToId = new Map;
+  threadKeyToId = new Map;
+  outboxKeyToId = new Map;
+  deliveryAttemptSequence = 0;
+  async claimEventReceipt(input) {
+    const key = this.receiptKey(input);
+    const existingId = this.receiptKeyToId.get(key);
+    if (existingId) {
+      const existing = this.receipts.get(existingId);
+      if (existing) {
+        existing.lastSeenAt = new Date;
+        this.receipts.set(existing.id, existing);
+      }
+      return {
+        receiptId: existingId,
+        duplicate: true
+      };
+    }
+    const id = randomUUID();
+    const now = new Date;
+    this.receipts.set(id, {
+      id,
+      workspaceId: input.workspaceId,
+      providerKey: input.providerKey,
+      externalEventId: input.externalEventId,
+      eventType: input.eventType,
+      status: "accepted",
+      signatureValid: input.signatureValid,
+      payloadHash: input.payloadHash,
+      traceId: input.traceId,
+      firstSeenAt: now,
+      lastSeenAt: now
+    });
+    this.receiptKeyToId.set(key, id);
+    return { receiptId: id, duplicate: false };
+  }
+  async updateReceiptStatus(receiptId, status, error) {
+    const receipt = this.receipts.get(receiptId);
+    if (!receipt) {
+      return;
+    }
+    receipt.status = status;
+    receipt.lastSeenAt = new Date;
+    if (status === "processed") {
+      receipt.processedAt = new Date;
+    }
+    receipt.errorCode = error?.code;
+    receipt.errorMessage = error?.message;
+    this.receipts.set(receiptId, receipt);
+  }
+  async upsertThread(input) {
+    const key = this.threadKey(input);
+    const existingId = this.threadKeyToId.get(key);
+    if (existingId) {
+      const existing = this.threads.get(existingId);
+      if (!existing) {
+        throw new Error("Corrupted thread state");
+      }
+      existing.externalChannelId = input.externalChannelId ?? existing.externalChannelId;
+      existing.externalUserId = input.externalUserId ?? existing.externalUserId;
+      existing.lastProviderEventAt = input.occurredAt ?? existing.lastProviderEventAt;
+      existing.updatedAt = new Date;
+      if (input.state) {
+        existing.state = {
+          ...existing.state,
+          ...input.state
+        };
+      }
+      this.threads.set(existing.id, existing);
+      return existing;
+    }
+    const id = randomUUID();
+    const now = new Date;
+    const record = {
+      id,
+      workspaceId: input.workspaceId,
+      providerKey: input.providerKey,
+      externalThreadId: input.externalThreadId,
+      externalChannelId: input.externalChannelId,
+      externalUserId: input.externalUserId,
+      state: input.state ?? {},
+      lastProviderEventAt: input.occurredAt,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.threads.set(id, record);
+    this.threadKeyToId.set(key, id);
+    return record;
+  }
+  async saveDecision(input) {
+    const id = randomUUID();
+    const record = {
+      id,
+      receiptId: input.receiptId,
+      threadId: input.threadId,
+      policyMode: input.policyMode,
+      riskTier: input.riskTier,
+      confidence: input.confidence,
+      modelName: input.modelName,
+      promptVersion: input.promptVersion,
+      policyVersion: input.policyVersion,
+      toolTrace: input.toolTrace ?? [],
+      actionPlan: input.actionPlan,
+      requiresApproval: input.requiresApproval,
+      createdAt: new Date
+    };
+    this.decisions.set(id, record);
+    return record;
+  }
+  async enqueueOutboxAction(input) {
+    const existingId = this.outboxKeyToId.get(input.idempotencyKey);
+    if (existingId) {
+      return {
+        actionId: existingId,
+        duplicate: true
+      };
+    }
+    const id = randomUUID();
+    const now = new Date;
+    this.outbox.set(id, {
+      id,
+      workspaceId: input.workspaceId,
+      providerKey: input.providerKey,
+      decisionId: input.decisionId,
+      threadId: input.threadId,
+      actionType: input.actionType,
+      idempotencyKey: input.idempotencyKey,
+      target: input.target,
+      payload: input.payload,
+      status: "pending",
+      attemptCount: 0,
+      nextAttemptAt: now,
+      createdAt: now,
+      updatedAt: now
+    });
+    this.outboxKeyToId.set(input.idempotencyKey, id);
+    return {
+      actionId: id,
+      duplicate: false
+    };
+  }
+  async claimPendingOutboxActions(limit, now = new Date) {
+    const items = Array.from(this.outbox.values()).filter((item) => (item.status === "pending" || item.status === "retryable") && item.nextAttemptAt.getTime() <= now.getTime()).sort((a, b) => a.nextAttemptAt.getTime() - b.nextAttemptAt.getTime()).slice(0, Math.max(1, limit));
+    const claimed = [];
+    for (const item of items) {
+      const updated = {
+        ...item,
+        status: "sending",
+        attemptCount: item.attemptCount + 1,
+        updatedAt: new Date
+      };
+      this.outbox.set(updated.id, updated);
+      claimed.push(updated);
+    }
+    return claimed;
+  }
+  async recordDeliveryAttempt(input) {
+    this.deliveryAttemptSequence += 1;
+    const record = {
+      id: this.deliveryAttemptSequence,
+      actionId: input.actionId,
+      attempt: input.attempt,
+      responseStatus: input.responseStatus,
+      responseBody: input.responseBody,
+      latencyMs: input.latencyMs,
+      createdAt: new Date
+    };
+    this.deliveryAttempts.set(`${input.actionId}:${input.attempt}`, record);
+    return record;
+  }
+  async markOutboxSent(actionId, providerMessageId) {
+    const item = this.outbox.get(actionId);
+    if (!item)
+      return;
+    item.status = "sent";
+    item.providerMessageId = providerMessageId;
+    item.sentAt = new Date;
+    item.lastErrorCode = undefined;
+    item.lastErrorMessage = undefined;
+    item.updatedAt = new Date;
+    this.outbox.set(actionId, item);
+  }
+  async markOutboxRetry(input) {
+    const item = this.outbox.get(input.actionId);
+    if (!item)
+      return;
+    item.status = "retryable";
+    item.nextAttemptAt = input.nextAttemptAt;
+    item.lastErrorCode = input.lastErrorCode;
+    item.lastErrorMessage = input.lastErrorMessage;
+    item.updatedAt = new Date;
+    this.outbox.set(input.actionId, item);
+  }
+  async markOutboxDeadLetter(input) {
+    const item = this.outbox.get(input.actionId);
+    if (!item)
+      return;
+    item.status = "dead_letter";
+    item.lastErrorCode = input.lastErrorCode;
+    item.lastErrorMessage = input.lastErrorMessage;
+    item.updatedAt = new Date;
+    this.outbox.set(input.actionId, item);
+  }
+  receiptKey(input) {
+    return `${input.workspaceId}:${input.providerKey}:${input.externalEventId}`;
+  }
+  threadKey(input) {
+    return `${input.workspaceId}:${input.providerKey}:${input.externalThreadId}`;
+  }
+}
+export {
+  InMemoryChannelRuntimeStore
+};

package/dist/channel/policy.d.ts

@@ -0,0 +1,19 @@
+import type { ChannelInboundEvent, ChannelPolicyDecision } from './types';
+export interface MessagingPolicyConfig {
+    autoResolveMinConfidence: number;
+    assistMinConfidence: number;
+    blockedSignals: string[];
+    highRiskSignals: string[];
+    mediumRiskSignals: string[];
+    safeAckTemplate: string;
+}
+export declare const DEFAULT_MESSAGING_POLICY_CONFIG: MessagingPolicyConfig;
+export interface PolicyEvaluationInput {
+    event: ChannelInboundEvent;
+}
+export declare class MessagingPolicyEngine {
+    private readonly config;
+    constructor(config?: Partial<MessagingPolicyConfig>);
+    evaluate(input: PolicyEvaluationInput): ChannelPolicyDecision;
+    private defaultResponseText;
+}

package/dist/channel/policy.js

@@ -0,0 +1,110 @@
+// @bun
+// src/channel/policy.ts
+var DEFAULT_MESSAGING_POLICY_CONFIG = {
+  autoResolveMinConfidence: 0.85,
+  assistMinConfidence: 0.65,
+  blockedSignals: [
+    "ignore previous instructions",
+    "reveal secret",
+    "api key",
+    "password",
+    "token",
+    "drop table",
+    "delete repository"
+  ],
+  highRiskSignals: [
+    "refund",
+    "delete account",
+    "cancel subscription",
+    "permission",
+    "admin access",
+    "wire transfer",
+    "bank account"
+  ],
+  mediumRiskSignals: [
+    "urgent",
+    "legal",
+    "compliance",
+    "frustrated",
+    "escalate",
+    "outage"
+  ],
+  safeAckTemplate: "Thanks for your message. We received it and are preparing the next step."
+};
+
+class MessagingPolicyEngine {
+  config;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_MESSAGING_POLICY_CONFIG,
+      ...config ?? {}
+    };
+  }
+  evaluate(input) {
+    const text = (input.event.message?.text ?? "").toLowerCase();
+    if (containsAny(text, this.config.blockedSignals)) {
+      return {
+        confidence: 0.2,
+        riskTier: "blocked",
+        verdict: "blocked",
+        reasons: ["blocked_signal_detected"],
+        responseText: this.config.safeAckTemplate,
+        requiresApproval: true
+      };
+    }
+    if (containsAny(text, this.config.highRiskSignals)) {
+      return {
+        confidence: 0.55,
+        riskTier: "high",
+        verdict: "assist",
+        reasons: ["high_risk_topic_detected"],
+        responseText: this.config.safeAckTemplate,
+        requiresApproval: true
+      };
+    }
+    const mediumRiskDetected = containsAny(text, this.config.mediumRiskSignals);
+    const confidence = mediumRiskDetected ? 0.74 : 0.92;
+    const riskTier = mediumRiskDetected ? "medium" : "low";
+    if (confidence >= this.config.autoResolveMinConfidence && riskTier === "low") {
+      return {
+        confidence,
+        riskTier,
+        verdict: "autonomous",
+        reasons: ["low_risk_high_confidence"],
+        responseText: this.defaultResponseText(input.event),
+        requiresApproval: false
+      };
+    }
+    if (confidence >= this.config.assistMinConfidence) {
+      return {
+        confidence,
+        riskTier,
+        verdict: "assist",
+        reasons: ["needs_human_review"],
+        responseText: this.config.safeAckTemplate,
+        requiresApproval: true
+      };
+    }
+    return {
+      confidence,
+      riskTier: "blocked",
+      verdict: "blocked",
+      reasons: ["low_confidence"],
+      responseText: this.config.safeAckTemplate,
+      requiresApproval: true
+    };
+  }
+  defaultResponseText(event) {
+    if (!event.message?.text) {
+      return this.config.safeAckTemplate;
+    }
+    return `Acknowledged: ${event.message.text.slice(0, 240)}`;
+  }
+}
+function containsAny(text, candidates) {
+  return candidates.some((candidate) => text.includes(candidate));
+}
+export {
+  MessagingPolicyEngine,
+  DEFAULT_MESSAGING_POLICY_CONFIG
+};

package/dist/channel/policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/channel/postgres-queries.d.ts

@@ -0,0 +1,11 @@
+export declare const CLAIM_EVENT_RECEIPT_SQL = "\nwith inserted as (\n  insert into channel_event_receipts (\n    id,\n    workspace_id,\n    provider_key,\n    external_event_id,\n    event_type,\n    status,\n    signature_valid,\n    payload_hash,\n    trace_id\n  )\n  values ($1, $2, $3, $4, $5, 'accepted', $6, $7, $8)\n  on conflict (workspace_id, provider_key, external_event_id)\n  do nothing\n  returning id\n)\nselect id, true as inserted from inserted\nunion all\nselect id, false as inserted\nfrom channel_event_receipts\nwhere workspace_id = $2\n  and provider_key = $3\n  and external_event_id = $4\nlimit 1\n";
+export declare const MARK_RECEIPT_DUPLICATE_SQL = "\nupdate channel_event_receipts\nset last_seen_at = now(), status = 'duplicate'\nwhere id = $1\n";
+export declare const UPDATE_RECEIPT_STATUS_SQL = "\nupdate channel_event_receipts\nset\n  status = $2,\n  error_code = $3,\n  error_message = $4,\n  last_seen_at = now(),\n  processed_at = case when $2 = 'processed' then now() else processed_at end\nwhere id = $1\n";
+export declare const UPSERT_THREAD_SQL = "\ninsert into channel_threads (\n  id,\n  workspace_id,\n  provider_key,\n  external_thread_id,\n  external_channel_id,\n  external_user_id,\n  state,\n  last_provider_event_ts\n)\nvalues ($1, $2, $3, $4, $5, $6, $7::jsonb, $8)\non conflict (workspace_id, provider_key, external_thread_id)\ndo update set\n  external_channel_id = coalesce(excluded.external_channel_id, channel_threads.external_channel_id),\n  external_user_id = coalesce(excluded.external_user_id, channel_threads.external_user_id),\n  state = channel_threads.state || excluded.state,\n  last_provider_event_ts = coalesce(excluded.last_provider_event_ts, channel_threads.last_provider_event_ts),\n  updated_at = now()\nreturning\n  id,\n  workspace_id,\n  provider_key,\n  external_thread_id,\n  external_channel_id,\n  external_user_id,\n  state,\n  last_provider_event_ts,\n  created_at,\n  updated_at\n";
+export declare const INSERT_DECISION_SQL = "\ninsert into channel_ai_decisions (\n  id,\n  receipt_id,\n  thread_id,\n  policy_mode,\n  risk_tier,\n  confidence,\n  model_name,\n  prompt_version,\n  policy_version,\n  tool_trace,\n  action_plan,\n  requires_approval\n)\nvalues ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb, $12)\n";
+export declare const ENQUEUE_OUTBOX_SQL = "\nwith inserted as (\n  insert into channel_outbox_actions (\n    id,\n    workspace_id,\n    provider_key,\n    decision_id,\n    thread_id,\n    action_type,\n    idempotency_key,\n    target,\n    payload,\n    status\n  )\n  values ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9::jsonb, 'pending')\n  on conflict (idempotency_key)\n  do nothing\n  returning id\n)\nselect id, true as inserted from inserted\nunion all\nselect id, false as inserted\nfrom channel_outbox_actions\nwhere idempotency_key = $7\nlimit 1\n";
+export declare const CLAIM_PENDING_OUTBOX_SQL = "\nwith candidates as (\n  select id\n  from channel_outbox_actions\n  where status in ('pending', 'retryable')\n    and next_attempt_at <= $2\n  order by next_attempt_at asc\n  limit $1\n  for update skip locked\n)\nupdate channel_outbox_actions as actions\nset\n  status = 'sending',\n  attempt_count = actions.attempt_count + 1,\n  updated_at = now()\nfrom candidates\nwhere actions.id = candidates.id\nreturning\n  actions.id,\n  actions.workspace_id,\n  actions.provider_key,\n  actions.decision_id,\n  actions.thread_id,\n  actions.action_type,\n  actions.idempotency_key,\n  actions.target,\n  actions.payload,\n  actions.status,\n  actions.attempt_count,\n  actions.next_attempt_at,\n  actions.provider_message_id,\n  actions.last_error_code,\n  actions.last_error_message,\n  actions.created_at,\n  actions.updated_at,\n  actions.sent_at\n";
+export declare const INSERT_DELIVERY_ATTEMPT_SQL = "\ninsert into channel_delivery_attempts (\n  action_id,\n  attempt,\n  response_status,\n  response_body,\n  latency_ms\n)\nvalues ($1, $2, $3, $4, $5)\non conflict (action_id, attempt)\ndo update set\n  response_status = excluded.response_status,\n  response_body = excluded.response_body,\n  latency_ms = excluded.latency_ms,\n  created_at = now()\nreturning\n  id,\n  action_id,\n  attempt,\n  response_status,\n  response_body,\n  latency_ms,\n  created_at\n";
+export declare const MARK_OUTBOX_SENT_SQL = "\nupdate channel_outbox_actions\nset\n  status = 'sent',\n  provider_message_id = $2,\n  sent_at = now(),\n  updated_at = now(),\n  last_error_code = null,\n  last_error_message = null\nwhere id = $1\n";
+export declare const MARK_OUTBOX_RETRY_SQL = "\nupdate channel_outbox_actions\nset\n  status = 'retryable',\n  next_attempt_at = $2,\n  last_error_code = $3,\n  last_error_message = $4,\n  updated_at = now()\nwhere id = $1\n";
+export declare const MARK_OUTBOX_DEAD_LETTER_SQL = "\nupdate channel_outbox_actions\nset\n  status = 'dead_letter',\n  last_error_code = $2,\n  last_error_message = $3,\n  updated_at = now()\nwhere id = $1\n";

package/dist/channel/postgres-queries.js

@@ -0,0 +1,222 @@
+// @bun
+// src/channel/postgres-queries.ts
+var CLAIM_EVENT_RECEIPT_SQL = `
+with inserted as (
+  insert into channel_event_receipts (
+    id,
+    workspace_id,
+    provider_key,
+    external_event_id,
+    event_type,
+    status,
+    signature_valid,
+    payload_hash,
+    trace_id
+  )
+  values ($1, $2, $3, $4, $5, 'accepted', $6, $7, $8)
+  on conflict (workspace_id, provider_key, external_event_id)
+  do nothing
+  returning id
+)
+select id, true as inserted from inserted
+union all
+select id, false as inserted
+from channel_event_receipts
+where workspace_id = $2
+  and provider_key = $3
+  and external_event_id = $4
+limit 1
+`;
+var MARK_RECEIPT_DUPLICATE_SQL = `
+update channel_event_receipts
+set last_seen_at = now(), status = 'duplicate'
+where id = $1
+`;
+var UPDATE_RECEIPT_STATUS_SQL = `
+update channel_event_receipts
+set
+  status = $2,
+  error_code = $3,
+  error_message = $4,
+  last_seen_at = now(),
+  processed_at = case when $2 = 'processed' then now() else processed_at end
+where id = $1
+`;
+var UPSERT_THREAD_SQL = `
+insert into channel_threads (
+  id,
+  workspace_id,
+  provider_key,
+  external_thread_id,
+  external_channel_id,
+  external_user_id,
+  state,
+  last_provider_event_ts
+)
+values ($1, $2, $3, $4, $5, $6, $7::jsonb, $8)
+on conflict (workspace_id, provider_key, external_thread_id)
+do update set
+  external_channel_id = coalesce(excluded.external_channel_id, channel_threads.external_channel_id),
+  external_user_id = coalesce(excluded.external_user_id, channel_threads.external_user_id),
+  state = channel_threads.state || excluded.state,
+  last_provider_event_ts = coalesce(excluded.last_provider_event_ts, channel_threads.last_provider_event_ts),
+  updated_at = now()
+returning
+  id,
+  workspace_id,
+  provider_key,
+  external_thread_id,
+  external_channel_id,
+  external_user_id,
+  state,
+  last_provider_event_ts,
+  created_at,
+  updated_at
+`;
+var INSERT_DECISION_SQL = `
+insert into channel_ai_decisions (
+  id,
+  receipt_id,
+  thread_id,
+  policy_mode,
+  risk_tier,
+  confidence,
+  model_name,
+  prompt_version,
+  policy_version,
+  tool_trace,
+  action_plan,
+  requires_approval
+)
+values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb, $12)
+`;
+var ENQUEUE_OUTBOX_SQL = `
+with inserted as (
+  insert into channel_outbox_actions (
+    id,
+    workspace_id,
+    provider_key,
+    decision_id,
+    thread_id,
+    action_type,
+    idempotency_key,
+    target,
+    payload,
+    status
+  )
+  values ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9::jsonb, 'pending')
+  on conflict (idempotency_key)
+  do nothing
+  returning id
+)
+select id, true as inserted from inserted
+union all
+select id, false as inserted
+from channel_outbox_actions
+where idempotency_key = $7
+limit 1
+`;
+var CLAIM_PENDING_OUTBOX_SQL = `
+with candidates as (
+  select id
+  from channel_outbox_actions
+  where status in ('pending', 'retryable')
+    and next_attempt_at <= $2
+  order by next_attempt_at asc
+  limit $1
+  for update skip locked
+)
+update channel_outbox_actions as actions
+set
+  status = 'sending',
+  attempt_count = actions.attempt_count + 1,
+  updated_at = now()
+from candidates
+where actions.id = candidates.id
+returning
+  actions.id,
+  actions.workspace_id,
+  actions.provider_key,
+  actions.decision_id,
+  actions.thread_id,
+  actions.action_type,
+  actions.idempotency_key,
+  actions.target,
+  actions.payload,
+  actions.status,
+  actions.attempt_count,
+  actions.next_attempt_at,
+  actions.provider_message_id,
+  actions.last_error_code,
+  actions.last_error_message,
+  actions.created_at,
+  actions.updated_at,
+  actions.sent_at
+`;
+var INSERT_DELIVERY_ATTEMPT_SQL = `
+insert into channel_delivery_attempts (
+  action_id,
+  attempt,
+  response_status,
+  response_body,
+  latency_ms
+)
+values ($1, $2, $3, $4, $5)
+on conflict (action_id, attempt)
+do update set
+  response_status = excluded.response_status,
+  response_body = excluded.response_body,
+  latency_ms = excluded.latency_ms,
+  created_at = now()
+returning
+  id,
+  action_id,
+  attempt,
+  response_status,
+  response_body,
+  latency_ms,
+  created_at
+`;
+var MARK_OUTBOX_SENT_SQL = `
+update channel_outbox_actions
+set
+  status = 'sent',
+  provider_message_id = $2,
+  sent_at = now(),
+  updated_at = now(),
+  last_error_code = null,
+  last_error_message = null
+where id = $1
+`;
+var MARK_OUTBOX_RETRY_SQL = `
+update channel_outbox_actions
+set
+  status = 'retryable',
+  next_attempt_at = $2,
+  last_error_code = $3,
+  last_error_message = $4,
+  updated_at = now()
+where id = $1
+`;
+var MARK_OUTBOX_DEAD_LETTER_SQL = `
+update channel_outbox_actions
+set
+  status = 'dead_letter',
+  last_error_code = $2,
+  last_error_message = $3,
+  updated_at = now()
+where id = $1
+`;
+export {
+  UPSERT_THREAD_SQL,
+  UPDATE_RECEIPT_STATUS_SQL,
+  MARK_RECEIPT_DUPLICATE_SQL,
+  MARK_OUTBOX_SENT_SQL,
+  MARK_OUTBOX_RETRY_SQL,
+  MARK_OUTBOX_DEAD_LETTER_SQL,
+  INSERT_DELIVERY_ATTEMPT_SQL,
+  INSERT_DECISION_SQL,
+  ENQUEUE_OUTBOX_SQL,
+  CLAIM_PENDING_OUTBOX_SQL,
+  CLAIM_EVENT_RECEIPT_SQL
+};

package/dist/channel/postgres-schema.d.ts

@@ -0,0 +1 @@
+export declare const CHANNEL_RUNTIME_SCHEMA_STATEMENTS: readonly string[];