@heyanon-arp/sdk 0.0.15 → 0.0.23

package/dist/types/read-model.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Public read-model row shapes returned by the server's relationship
+ * read endpoints and consumed by the CLI. Framework-agnostic plain
+ * interfaces (no decorators): the server's NestJS DTO classes
+ * `implements` these (keeping their @ApiProperty/@nestjs decorators for
+ * OpenAPI) and the CLI imports them directly — so the wire contract
+ * lives in ONE place and can't drift between the two packages.
+ */
+import type { LockTerminalState } from '../escrow/lock-account';
+import type { BodyType, ReceiptVerdict } from './body';
+import type { DelegationState } from './delegation';
+import type { ReadModelStatus } from './event';
+import type { RelationshipState } from './relationship';
+import type { WorkLogState } from './work-log';
+/**
+ * camelCase REST projection of an asset identifier (the snake_case
+ * envelope form is {@link AssetIdentifier} in body.ts). Embedded on
+ * `DelegationPublic.currency`.
+ */
+export interface AssetIdentifierWire {
+    /** CAIP-19 chain-qualified asset id. */
+    assetId: string;
+    /** Decimals 0-18, for amount → base-unit conversion. */
+    decimals: number;
+    /** Optional UI hint ("USDC", "SOL"). */
+    symbol?: string;
+}
+/**
+ * Public projection of one delegation row (one per delegationId).
+ * `id` is the per-row Mongo ObjectId hex — the opaque `?after=` cursor.
+ */
+export interface DelegationPublic {
+    id: string;
+    delegationId: string;
+    relationshipId: string;
+    offererDid: string;
+    state: DelegationState;
+    title?: string;
+    brief?: Record<string, unknown>;
+    acceptanceCriteria?: string[];
+    deadline?: string;
+    amount?: string;
+    currency?: AssetIdentifierWire;
+    /** Inline agreed terms the on-chain condition_hash binds. */
+    scopeSummary?: string;
+    createdAt: string;
+    updatedAt: string;
+    /** Machine-readable decline reason — present only on DECLINED rows. */
+    declineReason?: string | null;
+    declineReasonDetail?: string | null;
+    /** On-chain settlement outcome, set by the indexer at the terminal flip. */
+    releaseStatus?: LockTerminalState;
+}
+/**
+ * Public projection of one receipt row (one per
+ * delegationId/requestHash/responseHash). Receipts are propose-only.
+ */
+export interface ReceiptPublic {
+    id: string;
+    delegationId: string;
+    relationshipId: string;
+    payeeDid: string;
+    callerDid: string;
+    requestHash: string;
+    /** Opaque request_id from the matching work_request, denormalised at propose. */
+    requestId?: string;
+    responseHash: string;
+    verdictProposed: ReceiptVerdict;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        latency_ms?: number;
+        model?: string;
+        computed_amount?: string;
+    };
+    deliverableHash?: string;
+    notesHash?: string;
+    receiptEventHash: string;
+    /** On-chain settlement outcome, stamped by the indexer on terminal. */
+    releaseStatus?: LockTerminalState;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Public projection of one relationship row (per DID pair). */
+export interface RelationshipPublic {
+    relationshipId: string;
+    pairDidA: string;
+    pairDidB: string;
+    state: RelationshipState;
+    lastEventIndex: number;
+    lastServerEventHash: string | null;
+    lastEventAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Handshake decline reason — present on CLOSED rows from a decline. */
+    declineReason?: string | null;
+    declineReasonDetail?: string | null;
+}
+/**
+ * Public projection of one work-log row (per delegationId/requestId).
+ * Two-step FSM: a RESPONDED row carries exactly one of responseOutput /
+ * responseError.
+ */
+export interface WorkLogPublic {
+    id: string;
+    delegationId: string;
+    requestId: string;
+    relationshipId: string;
+    callerDid: string;
+    payeeDid: string;
+    state: WorkLogState;
+    requestParams: Record<string, unknown>;
+    responseOutput?: Record<string, unknown>;
+    responseError?: {
+        code: string;
+        message: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Public projection of one event row — the FULL canonical envelope
+ * (protectedBlock + body + optional attachments + senderSignature) plus
+ * the server-assigned chain coordinates, so a recipient can
+ * re-canonicalise + re-verify locally. `type` is widened to
+ * `BodyType | string` for forward-compat (a server may emit a body type
+ * a given client's union doesn't yet know).
+ */
+export interface EventPublic {
+    eventId: string;
+    messageId: string;
+    senderDid: string;
+    recipientDid: string;
+    relationshipId: string;
+    senderSequence: number;
+    protocolVersion: string;
+    purpose: string;
+    type: BodyType | string;
+    protectedBlock: Record<string, unknown>;
+    body: Record<string, unknown>;
+    attachments?: Record<string, unknown>;
+    senderSignature: string;
+    relationshipEventIndex: number;
+    prevServerEventHash: string | null;
+    serverTimestamp: string;
+    signedMessageHash: string;
+    serverEventHash: string;
+    /** Read-model outcome; `rejected` = committed to chain but body handler threw post-commit. */
+    readModelStatus: ReadModelStatus;
+}
+/** Response shape for `POST /v1/messages` (202 accepted, chain already committed). */
+export interface IngestResult {
+    eventId: string;
+    relationshipEventIndex: number;
+    prevServerEventHash: string | null;
+    signedMessageHash: string;
+    serverEventHash: string;
+    serverTimestamp: string;
+    relationshipId: string;
+}

package/dist/types/relationship.d.ts

@@ -14,3 +14,14 @@ export type RelationshipState = (typeof RELATIONSHIP_STATE_NAMES)[number];
  */
 export declare const LIVE_RELATIONSHIP_STATE_NAMES: readonly ["pending", "active", "paused"];
 export declare function isRelationshipState(v: unknown): v is RelationshipState;
+/**
+ * Named-member accessor for the relationship FSM (see
+ * {@link DelegationStates} for the rationale). Values are the wire
+ * strings; parity with {@link RELATIONSHIP_STATE_NAMES} is vocab-tested.
+ */
+export declare const RelationshipStates: {
+    readonly PENDING: "pending";
+    readonly ACTIVE: "active";
+    readonly PAUSED: "paused";
+    readonly CLOSED: "closed";
+};

package/dist/types/work-log.d.ts

@@ -8,3 +8,11 @@
 export declare const WORK_LOG_STATES: readonly ["requested", "responded"];
 export type WorkLogState = (typeof WORK_LOG_STATES)[number];
 export declare function isWorkLogState(v: unknown): v is WorkLogState;
+/**
+ * Named-member accessor for the work-log FSM (see {@link WORK_LOG_STATES}).
+ * Values are the wire strings; parity is vocab-tested.
+ */
+export declare const WorkLogStates: {
+    readonly REQUESTED: "requested";
+    readonly RESPONDED: "responded";
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyanon-arp/sdk",
-  "version": "0.0.15",
+  "version": "0.0.23",
   "description": "TypeScript SDK for the Agent Relationship Protocol — canonical JSON, Ed25519 envelope sign/verify, did:arp identity, scrypt key attestation, chain-audit helpers.",
   "license": "MIT",
   "keywords": [