@contractspec/integration.runtime 2.10.0 → 3.0.0

package/dist/node/channel/memory-store.js

@@ -0,0 +1,222 @@
+// src/channel/memory-store.ts
+import { randomUUID } from "node: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/node/channel/policy.js

@@ -0,0 +1,109 @@
+// 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/node/channel/postgres-queries.js

@@ -0,0 +1,221 @@
+// 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/node/channel/postgres-schema.js

@@ -0,0 +1,93 @@
+// src/channel/postgres-schema.ts
+var CHANNEL_RUNTIME_SCHEMA_STATEMENTS = [
+  `
+create table if not exists channel_event_receipts (
+  id uuid primary key,
+  workspace_id text not null,
+  provider_key text not null,
+  external_event_id text not null,
+  event_type text not null,
+  status text not null,
+  signature_valid boolean not null default false,
+  payload_hash text,
+  trace_id text,
+  first_seen_at timestamptz not null default now(),
+  last_seen_at timestamptz not null default now(),
+  processed_at timestamptz,
+  error_code text,
+  error_message text,
+  unique (workspace_id, provider_key, external_event_id)
+)
+`,
+  `
+create table if not exists channel_threads (
+  id uuid primary key,
+  workspace_id text not null,
+  provider_key text not null,
+  external_thread_id text not null,
+  external_channel_id text,
+  external_user_id text,
+  state jsonb not null default '{}'::jsonb,
+  last_provider_event_ts timestamptz,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  unique (workspace_id, provider_key, external_thread_id)
+)
+`,
+  `
+create table if not exists channel_ai_decisions (
+  id uuid primary key,
+  receipt_id uuid not null references channel_event_receipts (id),
+  thread_id uuid not null references channel_threads (id),
+  policy_mode text not null,
+  risk_tier text not null,
+  confidence numeric(5,4) not null,
+  model_name text not null,
+  prompt_version text not null,
+  policy_version text not null,
+  tool_trace jsonb not null default '[]'::jsonb,
+  action_plan jsonb not null,
+  requires_approval boolean not null default false,
+  approved_by text,
+  approved_at timestamptz,
+  created_at timestamptz not null default now()
+)
+`,
+  `
+create table if not exists channel_outbox_actions (
+  id uuid primary key,
+  workspace_id text not null,
+  provider_key text not null,
+  decision_id uuid not null references channel_ai_decisions (id),
+  thread_id uuid not null references channel_threads (id),
+  action_type text not null,
+  idempotency_key text not null unique,
+  target jsonb not null,
+  payload jsonb not null,
+  status text not null,
+  attempt_count integer not null default 0,
+  next_attempt_at timestamptz not null default now(),
+  provider_message_id text,
+  last_error_code text,
+  last_error_message text,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  sent_at timestamptz
+)
+`,
+  `
+create table if not exists channel_delivery_attempts (
+  id bigserial primary key,
+  action_id uuid not null references channel_outbox_actions (id),
+  attempt integer not null,
+  response_status integer,
+  response_body text,
+  latency_ms integer,
+  created_at timestamptz not null default now(),
+  unique (action_id, attempt)
+)
+`
+];
+export {
+  CHANNEL_RUNTIME_SCHEMA_STATEMENTS
+};