@topolo/sdk 0.7.0 → 0.8.1

package/src/modules/p2p.ts

@@ -1,448 +0,0 @@
-import type { TopoloClient } from '../client.js';
-
-export type P2PPricingModel = 'free' | 'fixed' | 'metered' | 'quote' | 'invoice';
-
-export interface P2PCapability {
-  capability_id: string;
-  publisher_org_id: string;
-  app_id: string;
-  name: string;
-  description: string;
-  category: string;
-  pricing_model: P2PPricingModel;
-  pricing_amount_minor: number | null;
-  currency: string | null;
-  requires_human_approval: boolean;
-  supported_contexts: string[];
-  trust_level: string;
-  source_revision: string;
-  synced_at: number;
-  input_schema?: Record<string, unknown>;
-  output_schema?: Record<string, unknown>;
-}
-
-export interface PublishCapabilityInput {
-  capability_id: string;
-  publisher_org_id: string;
-  app_id: string;
-  name: string;
-  description: string;
-  category: string;
-  pricing_model: P2PPricingModel;
-  pricing_amount_minor?: number | null;
-  currency?: string | null;
-  requires_human_approval?: boolean;
-  supported_contexts: string[];
-  trust_level?: string;
-  public_directory_visible: boolean;
-  source_revision: string;
-  input_schema?: Record<string, unknown>;
-  output_schema?: Record<string, unknown>;
-  /** Set when the caller is the platform P2P service publishing on behalf of another org. */
-  acting_for_org_id?: string;
-}
-
-export interface P2PActionRequestInput {
-  capability_id: string;
-  idempotency_key: string;
-  inputs?: Record<string, unknown>;
-}
-
-export interface P2PActionRow {
-  request_id: string;
-  buyer_org_id: string;
-  seller_org_id: string;
-  capability_id: string;
-  initiating_principal_id: string;
-  inputs: Record<string, unknown>;
-  pricing_snapshot: Record<string, unknown>;
-  state: string;
-  policy_decision_id: string | null;
-  idempotency_key: string;
-  created_at: number;
-  updated_at: number;
-  capability: {
-    name: string | null;
-    category: string | null;
-    pricing_model: string | null;
-    pricing_amount_minor: number | null;
-    currency: string | null;
-  };
-  run: P2PActionRun | null;
-}
-
-export interface P2PActionRun {
-  run_id: string;
-  state: string;
-  result: Record<string, unknown> | null;
-  error: string | null;
-  started_at: number | null;
-  completed_at: number | null;
-  updated_at: number;
-}
-
-export interface P2PActionRequestResult {
-  decision: string;
-  idempotent: boolean;
-  request: P2PActionRow;
-  run: P2PActionRun | null;
-}
-
-export interface P2PActionDetail {
-  action: P2PActionRow;
-  policy_decision: {
-    decision_id: string;
-    decision: string;
-    rationale: string;
-    policy_snapshot: Record<string, unknown>;
-    created_at: number;
-  } | null;
-  ledger_entries: P2PLedgerEntry[];
-  holds: P2PHold[];
-}
-
-export interface P2PHold {
-  hold_id: string;
-  request_id: string;
-  buyer_org_id: string;
-  seller_org_id: string;
-  ledger_entry_id: string | null;
-  reason: string;
-  status: 'active' | 'released' | 'disputed' | 'expired';
-  release_after: number | null;
-  released_at: number | null;
-  created_at: number;
-  updated_at: number;
-}
-
-export interface P2PLedgerEntry {
-  entry_id: string;
-  request_id: string;
-  capability_id: string;
-  pricing_component: string;
-  buyer_org_id: string;
-  seller_org_id: string;
-  initiating_principal_id: string;
-  executing_principal_id: string;
-  policy_decision_id: string;
-  amount_minor: number;
-  currency: string;
-  audit_correlation_id: string;
-  settlement_batch_id: string | null;
-  created_at: number;
-}
-
-export interface P2PPolicy {
-  organization_id: string;
-  auto_approve_under_minor: number;
-  agent_spend_limit_minor_per_day: number;
-  human_approval_threshold_minor: number;
-  unknown_counterparty_requires_approval: boolean;
-  blocked_capability_ids: string[];
-  trusted_counterparty_org_ids: string[];
-  updated_at: number | null;
-}
-
-export interface P2PConnection {
-  connection_id: string;
-  organization_id?: string;
-  counterparty_org_id: string;
-  status: 'pending' | 'active' | 'suspended' | 'revoked';
-  initiated_by_principal_id: string;
-  created_at: number;
-  updated_at: number;
-}
-
-export interface P2PSettlementGroup {
-  buyer_org_id: string;
-  seller_org_id: string;
-  currency: string;
-  total_minor: number;
-  line_items: Array<{
-    entry_id: string;
-    request_id: string;
-    capability_id: string;
-    pricing_component: string;
-    amount_minor: number;
-    audit_correlation_id: string;
-  }>;
-}
-
-export interface P2PSettlementBatch {
-  batch_id: string;
-  buyer_org_id: string;
-  seller_org_id: string;
-  currency: string;
-  total_minor: number;
-  trigger: string;
-  pay_settlement_id: string | null;
-  status: string;
-  created_at: number;
-  updated_at: number;
-}
-
-type EnvelopeData<T> = { data: T };
-
-/**
- * P2P module — typed wrapper over the TopoloP2P HTTP API.
- *
- * Cross-org isolation: `requestAction`, `respondAction`, `completeAction`,
- * etc. all derive the buyer/seller org from the auth credential. There is
- * intentionally no `orgId` parameter on per-org reads.
- *
- * Mutating calls go through TopoloClient's `confirm: true` write guardrail.
- */
-export class P2PModule {
-  constructor(private readonly client: TopoloClient) {}
-
-  // Directory ----------------------------------------------------------------
-
-  async listDirectory(options: { limit?: number } = {}): Promise<P2PCapability[]> {
-    const res = await this.client.request<EnvelopeData<{ capabilities: P2PCapability[] }>>({
-      service: 'p2p',
-      path: '/api/directory/capabilities',
-      query: { limit: options.limit },
-    });
-    return res.data.capabilities;
-  }
-
-  async getCapability(capabilityId: string): Promise<P2PCapability | null> {
-    if (!capabilityId) throw new Error('capabilityId is required');
-    try {
-      const res = await this.client.request<EnvelopeData<{ capability: P2PCapability }>>({
-        service: 'p2p',
-        path: `/api/directory/capabilities/${encodeURIComponent(capabilityId)}`,
-      });
-      return res.data.capability;
-    } catch (err) {
-      if (isNotFound(err)) return null;
-      throw err;
-    }
-  }
-
-  async publishCapability(input: PublishCapabilityInput): Promise<P2PCapability> {
-    const res = await this.client.request<EnvelopeData<{ capability: P2PCapability }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: '/api/p2p/internal/capabilities/sync',
-      body: {
-        capability_id: input.capability_id,
-        publisher_org_id: input.publisher_org_id,
-        app_id: input.app_id,
-        name: input.name,
-        description: input.description,
-        category: input.category,
-        pricing_model: input.pricing_model,
-        pricing_amount_minor: input.pricing_amount_minor ?? null,
-        currency: input.currency ?? null,
-        requires_human_approval: input.requires_human_approval ?? false,
-        supported_contexts: input.supported_contexts,
-        trust_level: input.trust_level ?? 'standard',
-        public_directory_visible: input.public_directory_visible,
-        source_revision: input.source_revision,
-        input_schema: input.input_schema ?? {},
-        output_schema: input.output_schema ?? {},
-        acting_for_org_id: input.acting_for_org_id ?? input.publisher_org_id,
-      },
-      confirm: true,
-    });
-    return res.data.capability;
-  }
-
-  // Actions ------------------------------------------------------------------
-
-  async listActions(options: { state?: string; limit?: number } = {}): Promise<P2PActionRow[]> {
-    const res = await this.client.request<EnvelopeData<{ actions: P2PActionRow[] }>>({
-      service: 'p2p',
-      path: '/api/actions',
-      query: { state: options.state, limit: options.limit },
-    });
-    return res.data.actions;
-  }
-
-  async getAction(requestId: string): Promise<P2PActionDetail | null> {
-    if (!requestId) throw new Error('requestId is required');
-    try {
-      const res = await this.client.request<EnvelopeData<P2PActionDetail>>({
-        service: 'p2p',
-        path: `/api/actions/${encodeURIComponent(requestId)}`,
-      });
-      return res.data;
-    } catch (err) {
-      if (isNotFound(err)) return null;
-      throw err;
-    }
-  }
-
-  async requestAction(input: P2PActionRequestInput): Promise<P2PActionRequestResult> {
-    if (!input.capability_id) throw new Error('capability_id is required');
-    if (!input.idempotency_key) throw new Error('idempotency_key is required');
-    const res = await this.client.request<EnvelopeData<P2PActionRequestResult>>({
-      service: 'p2p',
-      method: 'POST',
-      path: '/api/actions/request',
-      body: {
-        capability_id: input.capability_id,
-        idempotency_key: input.idempotency_key,
-        inputs: input.inputs ?? {},
-      },
-      confirm: true,
-    });
-    return res.data;
-  }
-
-  async respondAction(
-    requestId: string,
-    response: 'accepted' | 'rejected' | 'approved' | 'quoted',
-    extras: Record<string, unknown> = {},
-  ): Promise<P2PActionRow> {
-    if (!requestId) throw new Error('requestId is required');
-    const res = await this.client.request<EnvelopeData<{ request: P2PActionRow }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: `/api/actions/${encodeURIComponent(requestId)}/respond`,
-      body: { response, ...extras },
-      confirm: true,
-    });
-    return res.data.request;
-  }
-
-  async completeAction(requestId: string, result: Record<string, unknown> = {}): Promise<P2PActionRow> {
-    if (!requestId) throw new Error('requestId is required');
-    const res = await this.client.request<EnvelopeData<{ request: P2PActionRow }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: `/api/actions/${encodeURIComponent(requestId)}/complete`,
-      body: { result },
-      confirm: true,
-    });
-    return res.data.request;
-  }
-
-  async disputeAction(requestId: string, reason: string): Promise<P2PActionRow> {
-    if (!requestId) throw new Error('requestId is required');
-    const res = await this.client.request<EnvelopeData<{ request: P2PActionRow }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: `/api/actions/${encodeURIComponent(requestId)}/dispute`,
-      body: { reason },
-      confirm: true,
-    });
-    return res.data.request;
-  }
-
-  // Policy + connections + ledger + settlement -----------------------------
-
-  async getPolicy(): Promise<P2PPolicy> {
-    const res = await this.client.request<EnvelopeData<{ policy: P2PPolicy }>>({
-      service: 'p2p',
-      path: '/api/policies',
-    });
-    return res.data.policy;
-  }
-
-  async updatePolicy(policy: Partial<Omit<P2PPolicy, 'organization_id' | 'updated_at'>>): Promise<P2PPolicy> {
-    const res = await this.client.request<EnvelopeData<{ policy: P2PPolicy }>>({
-      service: 'p2p',
-      method: 'PUT',
-      path: '/api/policies',
-      body: policy,
-      confirm: true,
-    });
-    return res.data.policy;
-  }
-
-  async listConnections(): Promise<P2PConnection[]> {
-    const res = await this.client.request<EnvelopeData<{ connections: P2PConnection[] }>>({
-      service: 'p2p',
-      path: '/api/connections',
-    });
-    return res.data.connections;
-  }
-
-  async createConnection(
-    counterpartyOrgId: string,
-    options: { status?: 'pending' | 'active' | 'suspended' } = {},
-  ): Promise<P2PConnection> {
-    if (!counterpartyOrgId) throw new Error('counterpartyOrgId is required');
-    const res = await this.client.request<EnvelopeData<{ connection: P2PConnection }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: '/api/connections',
-      body: { counterparty_org_id: counterpartyOrgId, status: options.status ?? 'active' },
-      confirm: true,
-    });
-    return res.data.connection;
-  }
-
-  async revokeConnection(connectionId: string): Promise<void> {
-    if (!connectionId) throw new Error('connectionId is required');
-    await this.client.request({
-      service: 'p2p',
-      method: 'DELETE',
-      path: `/api/connections/${encodeURIComponent(connectionId)}`,
-      confirm: true,
-    });
-  }
-
-  async listLedger(): Promise<P2PLedgerEntry[]> {
-    const res = await this.client.request<EnvelopeData<{ ledger_entries: P2PLedgerEntry[] }>>({
-      service: 'p2p',
-      path: '/api/ledger',
-    });
-    return res.data.ledger_entries;
-  }
-
-  async previewSettlements(
-    filters: Partial<{ buyer_org_id: string; seller_org_id: string; currency: string }> = {},
-  ): Promise<P2PSettlementGroup[]> {
-    const res = await this.client.request<EnvelopeData<{ groups: P2PSettlementGroup[] }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: '/api/settlements/preview',
-      body: filters,
-      confirm: true,
-    });
-    return res.data.groups;
-  }
-
-  async createSettlement(
-    filters: Partial<{
-      buyer_org_id: string;
-      seller_org_id: string;
-      currency: string;
-      trigger: 'threshold' | 'schedule' | 'manual' | 'invoice' | 'delivery';
-    }> = {},
-  ): Promise<{ batch: P2PSettlementBatch; group: P2PSettlementGroup }> {
-    const res = await this.client.request<EnvelopeData<{ batch: P2PSettlementBatch; group: P2PSettlementGroup }>>({
-      service: 'p2p',
-      method: 'POST',
-      path: '/api/settlements/create',
-      body: { trigger: 'manual', ...filters },
-      confirm: true,
-    });
-    return res.data;
-  }
-
-  async releaseHold(
-    holdId: string,
-    resolution: 'buyer' | 'seller',
-    options: { reason?: string } = {},
-  ): Promise<{ hold: P2PHold; resolution: 'buyer' | 'seller'; cancel_entries: P2PLedgerEntry[] }> {
-    if (!holdId) throw new Error('holdId is required');
-    const res = await this.client.request<
-      EnvelopeData<{ hold: P2PHold; resolution: 'buyer' | 'seller'; cancel_entries: P2PLedgerEntry[] }>
-    >({
-      service: 'p2p',
-      method: 'POST',
-      path: `/api/holds/${encodeURIComponent(holdId)}/release`,
-      body: { resolution, reason: options.reason ?? null },
-      confirm: true,
-    });
-    return res.data;
-  }
-}
-
-function isNotFound(err: unknown): boolean {
-  return Boolean(err && typeof err === 'object' && 'status' in err && (err as { status?: number }).status === 404);
-}