Skip to main content

stateknot_store_postgres/
tool_authorization_receipts.rs

1// Copyright 2026 StateKnot contributors
2// SPDX-License-Identifier: Apache-2.0
3
4use chrono::{DateTime, Utc};
5use sqlx_core::{from_row::FromRow, query::query, query_as::query_as, row::Row};
6use sqlx_postgres::PgRow;
7use stateknot_core::{
8    AuthorizationReceiptId, BoxFuture, InvocationId, RunId, TenantId, Timestamp,
9    ToolAuthorizationOperation, ToolAuthorizationReceipt, ToolAuthorizationReceiptSink,
10    ToolAuthorizationReceiptSinkError, ToolAuthorizationReceiptSinkFailure, ToolInvocationIntent,
11};
12use uuid::Uuid;
13
14use super::{
15    MAX_TOOL_INVOCATION_INTENT_BYTES, PostgresStore, StoreError, decode_digest, from_database_time,
16    has_database_constraint, to_database_time,
17};
18
19const MAX_RECEIPT_BYTES: usize = 65_536;
20
21const SELECT_RECEIPT: &str = r"
22SELECT
23    tenant_id,
24    receipt_id,
25    run_id,
26    thread_id,
27    invocation_id,
28    attempt_id,
29    origin_event_id,
30    operation,
31    descriptor_digest,
32    input_digest,
33    subject_digest,
34    policy_digest,
35    decision_digest,
36    authorization_window_id,
37    receipt_digest,
38    has_recovery_handle,
39    authorized_at,
40    recorded_at,
41    receipt_bytes,
42    receipt_bytes_digest
43FROM stateknot.tool_authorization_receipts
44WHERE tenant_id = $1 AND receipt_id = $2
45";
46
47const SELECT_INVOCATION_AUTHORIZATION_BOUNDARY: &str = r"
48SELECT
49    invocation.intent_bytes,
50    invocation.current_status,
51    invocation.current_attempt_id,
52    run.thread_id,
53    revision.journal_event_id
54FROM stateknot.tool_invocations AS invocation
55JOIN stateknot.runs AS run
56  ON run.tenant_id = invocation.tenant_id
57 AND run.run_id = invocation.run_id
58JOIN stateknot.tool_invocation_revisions AS revision
59  ON revision.tenant_id = invocation.tenant_id
60 AND revision.run_id = invocation.run_id
61 AND revision.invocation_id = invocation.invocation_id
62 AND revision.revision = invocation.current_revision
63 AND revision.record_digest = invocation.current_record_digest
64WHERE invocation.tenant_id = $1
65  AND invocation.run_id = $2
66  AND invocation.invocation_id = $3
67FOR UPDATE OF invocation
68";
69
70const SELECT_RECEIPT_PAGE: &str = r"
71SELECT
72    tenant_id,
73    receipt_id,
74    run_id,
75    thread_id,
76    invocation_id,
77    attempt_id,
78    origin_event_id,
79    operation,
80    descriptor_digest,
81    input_digest,
82    subject_digest,
83    policy_digest,
84    decision_digest,
85    authorization_window_id,
86    receipt_digest,
87    has_recovery_handle,
88    authorized_at,
89    recorded_at,
90    receipt_bytes,
91    receipt_bytes_digest
92FROM stateknot.tool_authorization_receipts
93WHERE tenant_id = $1
94  AND run_id = $2
95  AND invocation_id = $3
96  AND (recorded_at, receipt_id) > ($4, $5)
97ORDER BY recorded_at ASC, receipt_id ASC
98LIMIT $6
99";
100
101/// Result of an exact immutable authorization-receipt write.
102#[derive(Clone, Copy, Debug, Eq, PartialEq)]
103#[non_exhaustive]
104pub enum ToolAuthorizationReceiptOutcome {
105    /// New evidence was committed.
106    Recorded,
107    /// The exact canonical receipt was already durable.
108    Idempotent,
109}
110
111/// One verified immutable receipt and its authoritative database commit time.
112#[derive(Clone, Debug, Eq, PartialEq)]
113pub struct StoredToolAuthorizationReceipt {
114    receipt: ToolAuthorizationReceipt,
115    recorded_at: Timestamp,
116}
117
118impl StoredToolAuthorizationReceipt {
119    /// Returns the integrity-verified authorization evidence.
120    #[must_use]
121    pub const fn receipt(&self) -> &ToolAuthorizationReceipt {
122        &self.receipt
123    }
124
125    /// Returns when the database made the receipt durable.
126    #[must_use]
127    pub const fn recorded_at(&self) -> Timestamp {
128        self.recorded_at
129    }
130}
131
132/// Bounded number of authorization receipts returned in one audit page.
133#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
134pub struct ToolAuthorizationReceiptPageSize(u8);
135
136impl ToolAuthorizationReceiptPageSize {
137    /// Maximum decoded receipt count owned by one query.
138    pub const MAX: u8 = 100;
139
140    /// Constructs a positive bounded page size.
141    ///
142    /// # Errors
143    ///
144    /// Returns [`StoreError::InvalidToolAuthorizationReceiptPageSize`] outside
145    /// `1..=100`.
146    pub const fn new(value: u8) -> Result<Self, StoreError> {
147        if value == 0 || value > Self::MAX {
148            return Err(StoreError::InvalidToolAuthorizationReceiptPageSize);
149        }
150        Ok(Self(value))
151    }
152
153    /// Returns the validated query bound.
154    #[must_use]
155    pub const fn get(self) -> u8 {
156        self.0
157    }
158}
159
160/// One ascending, verified authorization-receipt audit page.
161#[derive(Clone, Debug)]
162pub struct ToolAuthorizationReceiptPage {
163    records: Vec<StoredToolAuthorizationReceipt>,
164    has_more: bool,
165}
166
167impl ToolAuthorizationReceiptPage {
168    /// Returns receipts in database commit order.
169    #[must_use]
170    pub fn records(&self) -> &[StoredToolAuthorizationReceipt] {
171        &self.records
172    }
173
174    /// Returns whether a later receipt remained in the observed snapshot.
175    #[must_use]
176    pub const fn has_more(&self) -> bool {
177        self.has_more
178    }
179
180    /// Returns the exact full-record continuation cursor.
181    #[must_use]
182    pub fn next_cursor(&self) -> Option<StoredToolAuthorizationReceipt> {
183        self.records.last().cloned()
184    }
185}
186
187impl PostgresStore {
188    /// Durably records an exact Tool authorization before provider I/O.
189    ///
190    /// A fresh write is accepted only while the referenced Tool invocation is
191    /// at the exact current execution/reconciliation boundary. An exact retry
192    /// remains idempotent after the invocation advances.
193    ///
194    /// # Errors
195    ///
196    /// Returns an invalid/conflict/not-found error for crossed provenance or
197    /// reused receipt identity, an integrity failure for corrupted durable
198    /// bytes, or an availability error when `PostgreSQL` cannot commit.
199    #[allow(clippy::too_many_lines)]
200    pub async fn record_tool_authorization_receipt(
201        &self,
202        receipt: ToolAuthorizationReceipt,
203    ) -> Result<ToolAuthorizationReceiptOutcome, StoreError> {
204        let receipt_bytes = encode_receipt(&receipt)?;
205        let provenance = receipt.provenance();
206        let operation = operation_text(receipt.operation())
207            .ok_or(StoreError::InvalidToolAuthorizationReceipt)?;
208        let mut transaction = self.begin_mutation("Tool authorization receipt").await?;
209
210        if let Some(row) = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
211            .bind(provenance.tenant_id().as_str())
212            .bind(*receipt.receipt_id().as_uuid())
213            .fetch_optional(&mut *transaction)
214            .await
215            .map_err(|source| StoreError::database("Tool authorization receipt retry", source))?
216        {
217            let stored = decode_receipt(&row)?;
218            if stored.receipt != receipt || encode_receipt(&stored.receipt)? != receipt_bytes {
219                return Err(StoreError::ToolAuthorizationReceiptConflict);
220            }
221            transaction.commit().await.map_err(|source| {
222                StoreError::database("Tool authorization receipt retry commit", source)
223            })?;
224            return Ok(ToolAuthorizationReceiptOutcome::Idempotent);
225        }
226
227        super::skill_activation_windows::validate_receipt_window(&mut transaction, &receipt)
228            .await?;
229        let boundary =
230            query_as::<_, ToolAuthorizationBoundaryRow>(SELECT_INVOCATION_AUTHORIZATION_BOUNDARY)
231                .bind(provenance.tenant_id().as_str())
232                .bind(*provenance.run_id().as_uuid())
233                .bind(*provenance.invocation_id().as_uuid())
234                .fetch_optional(&mut *transaction)
235                .await
236                .map_err(|source| StoreError::database("Tool authorization boundary", source))?
237                .ok_or(StoreError::ToolAuthorizationReceiptNotFound)?;
238        validate_boundary(&receipt, &boundary)?;
239
240        let inserted = query(
241            r"
242INSERT INTO stateknot.tool_authorization_receipts (
243    tenant_id,
244    receipt_id,
245    run_id,
246    thread_id,
247    invocation_id,
248    attempt_id,
249    origin_event_id,
250    operation,
251    descriptor_digest,
252    input_digest,
253    subject_digest,
254    policy_digest,
255    decision_digest,
256    authorization_window_id,
257    receipt_digest,
258    has_recovery_handle,
259    authorized_at,
260    receipt_bytes
261)
262VALUES (
263    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18
264)
265ON CONFLICT (tenant_id, receipt_id) DO NOTHING
266",
267        )
268        .bind(provenance.tenant_id().as_str())
269        .bind(*receipt.receipt_id().as_uuid())
270        .bind(*provenance.run_id().as_uuid())
271        .bind(*provenance.thread_id().as_uuid())
272        .bind(*provenance.invocation_id().as_uuid())
273        .bind(*provenance.attempt_id().as_uuid())
274        .bind(*provenance.origin_event_id().as_uuid())
275        .bind(operation)
276        .bind(receipt.descriptor_digest().as_bytes())
277        .bind(receipt.input_digest().as_bytes())
278        .bind(receipt.subject_digest().as_bytes())
279        .bind(receipt.policy_digest().as_bytes())
280        .bind(receipt.decision_digest().as_bytes())
281        .bind(receipt.authorization_window_id().map(|id| *id.as_uuid()))
282        .bind(receipt.receipt_digest().as_bytes())
283        .bind(receipt.has_recovery_handle())
284        .bind(to_database_time(receipt.authorized_at())?)
285        .bind(receipt_bytes.clone())
286        .execute(&mut *transaction)
287        .await
288        .map_err(map_receipt_insert_error)?
289        .rows_affected();
290
291        let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
292            .bind(provenance.tenant_id().as_str())
293            .bind(*receipt.receipt_id().as_uuid())
294            .fetch_optional(&mut *transaction)
295            .await
296            .map_err(|source| StoreError::database("Tool authorization receipt verify", source))?
297            .ok_or(StoreError::ToolAuthorizationReceiptConflict)?;
298        let stored = decode_receipt(&row)?;
299        if stored.receipt != receipt || encode_receipt(&stored.receipt)? != receipt_bytes {
300            return Err(StoreError::ToolAuthorizationReceiptConflict);
301        }
302        transaction
303            .commit()
304            .await
305            .map_err(|source| StoreError::database("Tool authorization receipt commit", source))?;
306        Ok(if inserted == 1 {
307            ToolAuthorizationReceiptOutcome::Recorded
308        } else {
309            ToolAuthorizationReceiptOutcome::Idempotent
310        })
311    }
312
313    /// Loads one exact immutable authorization receipt with full validation.
314    ///
315    /// # Errors
316    ///
317    /// Returns not-found, corruption, or database availability failures.
318    pub async fn load_tool_authorization_receipt(
319        &self,
320        tenant_id: &TenantId,
321        receipt_id: AuthorizationReceiptId,
322    ) -> Result<StoredToolAuthorizationReceipt, StoreError> {
323        let mut transaction = self
324            .begin_repeatable_read("Tool authorization receipt load")
325            .await?;
326        let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
327            .bind(tenant_id.as_str())
328            .bind(*receipt_id.as_uuid())
329            .fetch_optional(&mut *transaction)
330            .await
331            .map_err(|source| StoreError::database("Tool authorization receipt load", source))?
332            .ok_or(StoreError::ToolAuthorizationReceiptNotFound)?;
333        let stored = decode_receipt(&row)?;
334        if stored.receipt.provenance().tenant_id() != tenant_id
335            || stored.receipt.receipt_id() != receipt_id
336        {
337            return Err(StoreError::corrupt("Tool authorization receipt scope"));
338        }
339        transaction.commit().await.map_err(|source| {
340            StoreError::database("Tool authorization receipt load commit", source)
341        })?;
342        Ok(stored)
343    }
344
345    /// Lists one bounded verified receipt page for an exact Tool invocation.
346    ///
347    /// # Errors
348    ///
349    /// Returns an invalid cursor when the supplied full record crosses scope or
350    /// no longer matches immutable storage; otherwise returns integrity or
351    /// database errors.
352    pub async fn load_tool_authorization_receipt_page(
353        &self,
354        tenant_id: &TenantId,
355        run_id: RunId,
356        invocation_id: InvocationId,
357        after: Option<&StoredToolAuthorizationReceipt>,
358        page_size: ToolAuthorizationReceiptPageSize,
359    ) -> Result<ToolAuthorizationReceiptPage, StoreError> {
360        if after.is_some_and(|cursor| {
361            let provenance = cursor.receipt.provenance();
362            provenance.tenant_id() != tenant_id
363                || provenance.run_id() != run_id
364                || provenance.invocation_id() != invocation_id
365        }) {
366            return Err(StoreError::InvalidToolAuthorizationReceiptCursor);
367        }
368        let mut transaction = self
369            .begin_repeatable_read("Tool authorization receipt page")
370            .await?;
371        if let Some(cursor) = after {
372            let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
373                .bind(tenant_id.as_str())
374                .bind(*cursor.receipt.receipt_id().as_uuid())
375                .fetch_optional(&mut *transaction)
376                .await
377                .map_err(|source| {
378                    StoreError::database("Tool authorization receipt cursor", source)
379                })?
380                .ok_or(StoreError::InvalidToolAuthorizationReceiptCursor)?;
381            if decode_receipt(&row)? != *cursor {
382                return Err(StoreError::InvalidToolAuthorizationReceiptCursor);
383            }
384        }
385        let (after_time, after_id) = after.map_or(
386            (
387                to_database_time(Timestamp::MIN)
388                    .expect("minimum core timestamp fits qualified PostgreSQL"),
389                Uuid::nil(),
390            ),
391            |cursor| {
392                (
393                    to_database_time(cursor.recorded_at)
394                        .expect("validated stored receipt time remains representable"),
395                    *cursor.receipt.receipt_id().as_uuid(),
396                )
397            },
398        );
399        let limit = i64::from(page_size.get()) + 1;
400        let rows = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT_PAGE)
401            .bind(tenant_id.as_str())
402            .bind(*run_id.as_uuid())
403            .bind(*invocation_id.as_uuid())
404            .bind(after_time)
405            .bind(after_id)
406            .bind(limit)
407            .fetch_all(&mut *transaction)
408            .await
409            .map_err(|source| StoreError::database("Tool authorization receipt page", source))?;
410        let mut records = rows
411            .into_iter()
412            .map(|row| decode_receipt(&row))
413            .collect::<Result<Vec<_>, _>>()?;
414        let has_more = records.len() > usize::from(page_size.get());
415        if has_more {
416            records.pop();
417        }
418        transaction.commit().await.map_err(|source| {
419            StoreError::database("Tool authorization receipt page commit", source)
420        })?;
421        Ok(ToolAuthorizationReceiptPage { records, has_more })
422    }
423}
424
425impl ToolAuthorizationReceiptSink for PostgresStore {
426    fn record(
427        &self,
428        receipt: ToolAuthorizationReceipt,
429    ) -> BoxFuture<'_, Result<(), ToolAuthorizationReceiptSinkError>> {
430        Box::pin(async move {
431            self.record_tool_authorization_receipt(receipt)
432                .await
433                .map(|_| ())
434                .map_err(|source| {
435                    let failure = receipt_sink_failure(&source);
436                    ToolAuthorizationReceiptSinkError::new(failure, source)
437                })
438        })
439    }
440}
441
442fn receipt_sink_failure(error: &StoreError) -> ToolAuthorizationReceiptSinkFailure {
443    match error {
444        StoreError::Database { .. }
445        | StoreError::Migration { .. }
446        | StoreError::UnsupportedServerVersion
447        | StoreError::SchemaNotMigrated
448        | StoreError::IncompatibleSchema
449        | StoreError::IncompleteSchema => ToolAuthorizationReceiptSinkFailure::Unavailable,
450        _ => ToolAuthorizationReceiptSinkFailure::Rejected,
451    }
452}
453
454fn validate_boundary(
455    receipt: &ToolAuthorizationReceipt,
456    boundary: &ToolAuthorizationBoundaryRow,
457) -> Result<(), StoreError> {
458    if boundary.intent_bytes.is_empty()
459        || boundary.intent_bytes.len() > MAX_TOOL_INVOCATION_INTENT_BYTES
460    {
461        return Err(StoreError::corrupt(
462            "Tool authorization invocation intent size",
463        ));
464    }
465    let intent = serde_json::from_slice::<ToolInvocationIntent>(&boundary.intent_bytes)
466        .map_err(|_| StoreError::corrupt("Tool authorization invocation intent"))?;
467    let canonical = serde_json_canonicalizer::to_vec(&intent)
468        .map_err(|_| StoreError::corrupt("Tool authorization invocation canonicalization"))?;
469    if canonical != boundary.intent_bytes {
470        return Err(StoreError::corrupt(
471            "Tool authorization invocation canonical bytes",
472        ));
473    }
474    let provenance = receipt.provenance();
475    let thread_id = stateknot_core::ThreadId::from_uuid(boundary.thread_id)
476        .map_err(|_| StoreError::corrupt("Tool authorization thread identity"))?;
477    let attempt_id = boundary
478        .current_attempt_id
479        .map(stateknot_core::AttemptId::from_uuid)
480        .transpose()
481        .map_err(|_| StoreError::corrupt("Tool authorization attempt identity"))?;
482    let origin_event_id = stateknot_core::EventId::from_uuid(boundary.journal_event_id)
483        .map_err(|_| StoreError::corrupt("Tool authorization event identity"))?;
484    let expected_status = match receipt.operation() {
485        ToolAuthorizationOperation::Execute => "executing",
486        ToolAuthorizationOperation::Reconcile => "unknown",
487        _ => return Err(StoreError::InvalidToolAuthorizationReceipt),
488    };
489    let descriptor = intent.descriptor();
490    if intent.tenant_id() != provenance.tenant_id()
491        || intent.run_id() != provenance.run_id()
492        || intent.invocation_id() != provenance.invocation_id()
493        || thread_id != provenance.thread_id()
494        || attempt_id != Some(provenance.attempt_id())
495        || origin_event_id != provenance.origin_event_id()
496        || boundary.current_status != expected_status
497        || descriptor.metadata().identity() != receipt.tool()
498        || ToolAuthorizationReceipt::digest_descriptor(descriptor)
499            .map_err(|_| StoreError::InvalidToolAuthorizationReceipt)?
500            != receipt.descriptor_digest()
501        || ToolAuthorizationReceipt::digest_input(intent.input())
502            .map_err(|_| StoreError::InvalidToolAuthorizationReceipt)?
503            != receipt.input_digest()
504    {
505        return Err(StoreError::InvalidToolAuthorizationReceipt);
506    }
507    Ok(())
508}
509
510fn encode_receipt(receipt: &ToolAuthorizationReceipt) -> Result<Vec<u8>, StoreError> {
511    let bytes = serde_json_canonicalizer::to_vec(receipt)
512        .map_err(|_| StoreError::encoding("Tool authorization receipt"))?;
513    if bytes.is_empty() || bytes.len() > MAX_RECEIPT_BYTES {
514        return Err(StoreError::InvalidToolAuthorizationReceipt);
515    }
516    Ok(bytes)
517}
518
519fn decode_receipt(
520    row: &ToolAuthorizationReceiptRow,
521) -> Result<StoredToolAuthorizationReceipt, StoreError> {
522    if row.receipt_bytes.is_empty() || row.receipt_bytes.len() > MAX_RECEIPT_BYTES {
523        return Err(StoreError::corrupt("Tool authorization receipt size"));
524    }
525    let receipt = serde_json::from_slice::<ToolAuthorizationReceipt>(&row.receipt_bytes)
526        .map_err(|_| StoreError::corrupt("Tool authorization receipt value"))?;
527    let canonical = serde_json_canonicalizer::to_vec(&receipt)
528        .map_err(|_| StoreError::corrupt("Tool authorization receipt canonicalization"))?;
529    if canonical != row.receipt_bytes {
530        return Err(StoreError::corrupt(
531            "Tool authorization receipt canonical bytes",
532        ));
533    }
534    let provenance = receipt.provenance();
535    let tenant_id = TenantId::try_from(row.tenant_id.as_str())
536        .map_err(|_| StoreError::corrupt("Tool authorization receipt tenant"))?;
537    let receipt_id = AuthorizationReceiptId::from_uuid(row.receipt_id)
538        .map_err(|_| StoreError::corrupt("Tool authorization receipt identity"))?;
539    let run_id = RunId::from_uuid(row.run_id)
540        .map_err(|_| StoreError::corrupt("Tool authorization receipt run"))?;
541    let thread_id = stateknot_core::ThreadId::from_uuid(row.thread_id)
542        .map_err(|_| StoreError::corrupt("Tool authorization receipt thread"))?;
543    let invocation_id = InvocationId::from_uuid(row.invocation_id)
544        .map_err(|_| StoreError::corrupt("Tool authorization receipt invocation"))?;
545    let attempt_id = stateknot_core::AttemptId::from_uuid(row.attempt_id)
546        .map_err(|_| StoreError::corrupt("Tool authorization receipt attempt"))?;
547    let origin_event_id = stateknot_core::EventId::from_uuid(row.origin_event_id)
548        .map_err(|_| StoreError::corrupt("Tool authorization receipt event"))?;
549    let recorded_at = from_database_time(row.recorded_at)?;
550    if tenant_id != *provenance.tenant_id()
551        || receipt_id != receipt.receipt_id()
552        || run_id != provenance.run_id()
553        || thread_id != provenance.thread_id()
554        || invocation_id != provenance.invocation_id()
555        || attempt_id != provenance.attempt_id()
556        || origin_event_id != provenance.origin_event_id()
557        || Some(row.operation.as_str()) != operation_text(receipt.operation())
558        || decode_digest(
559            &row.descriptor_digest,
560            "Tool authorization descriptor digest",
561        )? != receipt.descriptor_digest()
562        || decode_digest(&row.input_digest, "Tool authorization input digest")?
563            != receipt.input_digest()
564        || decode_digest(&row.subject_digest, "Tool authorization subject digest")?
565            != receipt.subject_digest()
566        || decode_digest(&row.policy_digest, "Tool authorization policy digest")?
567            != receipt.policy_digest()
568        || decode_digest(&row.decision_digest, "Tool authorization decision digest")?
569            != receipt.decision_digest()
570        || row.authorization_window_id != receipt.authorization_window_id().map(|id| *id.as_uuid())
571        || decode_digest(&row.receipt_digest, "Tool authorization receipt digest")?
572            != receipt.receipt_digest()
573        || decode_digest(
574            &row.receipt_bytes_digest,
575            "Tool authorization receipt bytes digest",
576        )? != stateknot_core::Digest::sha256(&row.receipt_bytes)
577        || row.has_recovery_handle != receipt.has_recovery_handle()
578        || from_database_time(row.authorized_at)? != receipt.authorized_at()
579        || recorded_at < receipt.authorized_at()
580    {
581        return Err(StoreError::corrupt("Tool authorization receipt projection"));
582    }
583    Ok(StoredToolAuthorizationReceipt {
584        receipt,
585        recorded_at,
586    })
587}
588
589const fn operation_text(operation: ToolAuthorizationOperation) -> Option<&'static str> {
590    match operation {
591        ToolAuthorizationOperation::Execute => Some("execute"),
592        ToolAuthorizationOperation::Reconcile => Some("reconcile"),
593        _ => None,
594    }
595}
596
597fn map_receipt_insert_error(source: sqlx_core::Error) -> StoreError {
598    if has_database_constraint(&source, "tool_authorization_receipts_run_thread_fk")
599        || has_database_constraint(&source, "tool_authorization_receipts_attempt_event_fk")
600        || has_database_constraint(&source, "tool_authorization_receipts_window_fk")
601    {
602        StoreError::ToolAuthorizationReceiptNotFound
603    } else if has_database_constraint(&source, "tool_authorization_receipts_ids_are_uuid_v7")
604        || has_database_constraint(&source, "tool_authorization_receipts_operation_valid")
605        || has_database_constraint(&source, "tool_authorization_receipts_digest_lengths")
606        || has_database_constraint(&source, "tool_authorization_receipts_bytes_bounded")
607        || has_database_constraint(&source, "tool_authorization_receipts_clock_valid")
608        || has_database_constraint(&source, "tool_authorization_receipts_window_uuid_v7")
609    {
610        StoreError::InvalidToolAuthorizationReceipt
611    } else {
612        StoreError::database("Tool authorization receipt insert", source)
613    }
614}
615
616struct ToolAuthorizationBoundaryRow {
617    intent_bytes: Vec<u8>,
618    current_status: String,
619    current_attempt_id: Option<Uuid>,
620    thread_id: Uuid,
621    journal_event_id: Uuid,
622}
623
624impl<'row> FromRow<'row, PgRow> for ToolAuthorizationBoundaryRow {
625    fn from_row(row: &'row PgRow) -> Result<Self, sqlx_core::Error> {
626        Ok(Self {
627            intent_bytes: row.try_get("intent_bytes")?,
628            current_status: row.try_get("current_status")?,
629            current_attempt_id: row.try_get("current_attempt_id")?,
630            thread_id: row.try_get("thread_id")?,
631            journal_event_id: row.try_get("journal_event_id")?,
632        })
633    }
634}
635
636struct ToolAuthorizationReceiptRow {
637    tenant_id: String,
638    receipt_id: Uuid,
639    run_id: Uuid,
640    thread_id: Uuid,
641    invocation_id: Uuid,
642    attempt_id: Uuid,
643    origin_event_id: Uuid,
644    operation: String,
645    descriptor_digest: Vec<u8>,
646    input_digest: Vec<u8>,
647    subject_digest: Vec<u8>,
648    policy_digest: Vec<u8>,
649    decision_digest: Vec<u8>,
650    authorization_window_id: Option<Uuid>,
651    receipt_digest: Vec<u8>,
652    has_recovery_handle: bool,
653    authorized_at: DateTime<Utc>,
654    recorded_at: DateTime<Utc>,
655    receipt_bytes: Vec<u8>,
656    receipt_bytes_digest: Vec<u8>,
657}
658
659impl<'row> FromRow<'row, PgRow> for ToolAuthorizationReceiptRow {
660    fn from_row(row: &'row PgRow) -> Result<Self, sqlx_core::Error> {
661        Ok(Self {
662            tenant_id: row.try_get("tenant_id")?,
663            receipt_id: row.try_get("receipt_id")?,
664            run_id: row.try_get("run_id")?,
665            thread_id: row.try_get("thread_id")?,
666            invocation_id: row.try_get("invocation_id")?,
667            attempt_id: row.try_get("attempt_id")?,
668            origin_event_id: row.try_get("origin_event_id")?,
669            operation: row.try_get("operation")?,
670            descriptor_digest: row.try_get("descriptor_digest")?,
671            input_digest: row.try_get("input_digest")?,
672            subject_digest: row.try_get("subject_digest")?,
673            policy_digest: row.try_get("policy_digest")?,
674            decision_digest: row.try_get("decision_digest")?,
675            authorization_window_id: row.try_get("authorization_window_id")?,
676            receipt_digest: row.try_get("receipt_digest")?,
677            has_recovery_handle: row.try_get("has_recovery_handle")?,
678            authorized_at: row.try_get("authorized_at")?,
679            recorded_at: row.try_get("recorded_at")?,
680            receipt_bytes: row.try_get("receipt_bytes")?,
681            receipt_bytes_digest: row.try_get("receipt_bytes_digest")?,
682        })
683    }
684}