productfoo 0.0.0-stage → 1.0.1

package/dist-public/src/discoveryProcess.d.ts

@@ -0,0 +1,221 @@
+import { type DiscoveryEvidenceEnvelope } from "./discoveryEvidence.js";
+import { type DiscoveryReadinessService, type DiscoveryServiceError, type DiscoveryServiceKeys, type DiscoveryServiceStatus, type ObservedProviderConnection } from "./discoveryReadiness.js";
+import { type DiscoveryConnectionRef, type DiscoveryHandoff, type DiscoveryLane, type DiscoveryServiceGrant, type DiscoverySubjectRef, type DiscoveryTargetRef } from "./discoveryConnections.js";
+import { type EnvelopeFailureReason, type SignedEnvelope, type SigningKeyStatus, type TrustedSigningKey, type TrustStore } from "./trustEnvelope.js";
+export declare const PROCESSING_VERSION = "discovery-process-0.1";
+export declare const PROMPT_VERSION = "discovery-process-prompt-0.1";
+export declare const RECEIPT_VERSION = "v1";
+export declare const RECEIPT_ARTIFACT_KIND = "discovery-processing-receipt";
+export declare const RECEIPT_TTL_MS: number;
+export declare const DISCOVERY_PROCESSING_LIMITS: {
+    readonly max_response_bytes: number;
+    readonly fetch_timeout_ms: 90000;
+    readonly max_model_input_tokens: 100000;
+};
+export declare const DISCOVERY_CONNECTION_MUTATION_ALLOWLIST: readonly ["connect", "credential_refresh", "target_suspend", "target_grant_revoke", "disconnect_revoke"];
+export declare class DiscoveryTranscriptOversizeError extends Error {
+    readonly limit_bytes: number;
+    constructor(limit_bytes: number);
+}
+export declare class DiscoveryTranscriptTimeoutError extends Error {
+    readonly timeout_ms: number;
+    constructor(timeout_ms: number);
+}
+export declare class DiscoveryTranscriptCancelledError extends Error {
+    constructor();
+}
+export type DiscoveryAttemptState = "claimed" | "receipt_issued" | "lost";
+export type DiscoveryProcessingAttemptRow = {
+    subject_ref: DiscoverySubjectRef;
+    target_ref: DiscoveryTargetRef;
+    source_fingerprint: string;
+    processing_version: string;
+    attempt_id: string;
+    state: DiscoveryAttemptState;
+};
+export type DiscoveryProcessingAttemptClaim = Omit<DiscoveryProcessingAttemptRow, "state">;
+export interface DiscoveryProcessingLedger {
+    beginAttempt(row: DiscoveryProcessingAttemptClaim): {
+        accepted: true;
+    } | {
+        accepted: false;
+        existing_state: DiscoveryAttemptState;
+    };
+    finishAttempt(attempt_id: string, state: "receipt_issued" | "lost"): void;
+}
+export declare function createInMemoryDiscoveryLedger(): DiscoveryProcessingLedger & {
+    rows(): DiscoveryProcessingAttemptRow[];
+};
+export type DiscoveryProcessingService = DiscoveryReadinessService & {
+    recordOperation(target_ref: DiscoveryTargetRef): void;
+    studyHypotheses(input: {
+        subject_ref: DiscoverySubjectRef;
+        target_ref: DiscoveryTargetRef;
+    }): Promise<Array<{
+        id: string;
+        text: string;
+    }>>;
+};
+export interface DiscoveryTranscriptSource {
+    readonly provider: string;
+    observeConnection(input: {
+        subject_ref: DiscoverySubjectRef;
+        connection_ref: DiscoveryConnectionRef;
+    }): Promise<ObservedProviderConnection>;
+    fetchTranscript(request: {
+        subject_ref: DiscoverySubjectRef;
+        provider_session_identity: string;
+        limits: typeof DISCOVERY_PROCESSING_LIMITS;
+    }): Promise<DiscoveryTranscriptFetch>;
+}
+export type DiscoveryTranscriptFetch = {
+    transcript_text: string;
+    transcript_complete: boolean;
+    completed_at: string;
+    stable_url?: string;
+};
+export interface DiscoverySynthesisProcessor {
+    readonly synthesizer_model: string;
+    process(request: {
+        system: string;
+        prompt: string;
+        max_output_tokens: number;
+    }): Promise<{
+        raw_output: string;
+    }>;
+}
+export type DiscoveryProcessingReceiptPayload = {
+    kind: "discovery_processing_receipt";
+    receipt_version: "v1";
+    subject_ref: DiscoverySubjectRef;
+    workspace_ref: string;
+    connection_ref: DiscoveryConnectionRef;
+    target_ref: DiscoveryTargetRef;
+    target_id: string;
+    lane: DiscoveryLane;
+    source_fingerprint: string;
+    approval_digest: string;
+    grant_digest: string;
+    revocation_epoch: number;
+    envelope_hash: string;
+    attempt_id: string;
+    processing: {
+        processing_version: string;
+        prompt_version: string;
+        policy_version: string;
+        synthesizer_model: string;
+        envelope_schema_version: "0.1";
+    };
+    limits: {
+        max_response_bytes: number;
+        fetch_timeout_ms: number;
+        max_model_input_tokens: number;
+    };
+};
+export type DiscoveryProcessingReceipt = SignedEnvelope<DiscoveryProcessingReceiptPayload>;
+export interface DiscoveryReceiptSigner {
+    readonly key_id: string;
+    signReceipt(input: {
+        payload: DiscoveryProcessingReceiptPayload;
+        issued_at: string;
+        expires_at: string;
+    }): DiscoveryProcessingReceipt;
+    trustEntry(options?: {
+        status?: SigningKeyStatus;
+        valid_from?: string;
+        valid_until?: string | null;
+    }): TrustedSigningKey;
+}
+export declare function createInMemoryDiscoveryReceiptSigner(options?: {
+    private_key_pem?: string;
+    key_id?: string;
+}): DiscoveryReceiptSigner;
+export type DiscoveryReceiptExpectation = {
+    subject_ref?: DiscoverySubjectRef;
+    workspace_ref?: string;
+    connection_ref?: DiscoveryConnectionRef;
+    target_ref?: DiscoveryTargetRef;
+    target_id?: string;
+    lane?: DiscoveryLane;
+    source_fingerprint?: string;
+    approval_digest?: string;
+    revocation_epoch?: number;
+    envelope_hash?: string;
+    attempt_id?: string;
+};
+export type DiscoveryReceiptVerification = {
+    ok: true;
+    payload: DiscoveryProcessingReceiptPayload;
+    receipt_hash: string;
+    key_status: SigningKeyStatus;
+} | {
+    ok: false;
+    reason: EnvelopeFailureReason | "malformed_payload" | "binding_mismatch";
+    message: string;
+};
+export declare function verifyDiscoveryProcessingReceipt(input: {
+    receipt: unknown;
+    trust_store: TrustStore<"foo">;
+    expectation?: DiscoveryReceiptExpectation;
+    now: string;
+}): DiscoveryReceiptVerification;
+export type DiscoveryReceiptStatusState = "active" | "revoked" | "unknown";
+export type DiscoveryReceiptStatusResult = {
+    receipt_status: DiscoveryReceiptStatusState;
+    revocation_epoch: number;
+};
+export interface DiscoveryReceiptStatusEndpoint {
+    receiptStatus(input: {
+        receipt_hash: string;
+        target_ref: DiscoveryTargetRef;
+    }): Promise<DiscoveryReceiptStatusResult>;
+}
+export declare class DiscoveryReceiptServiceUnreachableError extends Error {
+    constructor();
+}
+export declare function createUnreachableDiscoveryReceiptStatus(): DiscoveryReceiptStatusEndpoint;
+export declare function discoveryEnvelopeDigest(envelope: DiscoveryEvidenceEnvelope): string;
+export declare function discoveryGrantDigest(grant: DiscoveryServiceGrant): string;
+export type DiscoveryProcessSessionInput = {
+    subject_ref: DiscoverySubjectRef;
+    workspace_ref: string;
+    connection_ref: DiscoveryConnectionRef;
+    target_ref: DiscoveryTargetRef;
+    session_ref: string;
+    approval_digest: string;
+    revocation_epoch: number;
+    attempt_id?: string;
+};
+export type DiscoveryProcessSessionResult = {
+    schema_version: "0.1";
+    operation: "discovery_process_session";
+    status: DiscoveryServiceStatus;
+    errors: DiscoveryServiceError[];
+    handoff: DiscoveryHandoff | null;
+    next_actions: string[];
+    coverage: {
+        provider_metadata_probes: number;
+        transcript_body_calls: number;
+        synthesis_requests: number;
+        receipts_issued: number;
+        raw_content_retained: false;
+        attempt_id?: string;
+        recorded_attempt_state?: DiscoveryAttemptState;
+    };
+    connection_ref?: DiscoveryConnectionRef;
+    target_ref?: DiscoveryTargetRef;
+    stable_url?: string;
+    envelope?: DiscoveryEvidenceEnvelope;
+    processing_receipt?: DiscoveryProcessingReceipt;
+};
+export type DiscoveryProcessDeps = {
+    service: DiscoveryProcessingService;
+    keys: DiscoveryServiceKeys;
+    ledger: DiscoveryProcessingLedger;
+    signer: DiscoveryReceiptSigner;
+    source: DiscoveryTranscriptSource;
+    processor: DiscoverySynthesisProcessor;
+    delivery?: (result: DiscoveryProcessSessionResult) => Promise<DiscoveryProcessSessionResult>;
+    now: string;
+};
+export declare function processDiscoverySession(input: DiscoveryProcessSessionInput, deps: DiscoveryProcessDeps): Promise<DiscoveryProcessSessionResult>;