Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

20.5 KB
Raw Blame
use hiroute_domain::{
    ContentId, ConversationContentEnvelopeV1, ConversationContentPhaseV2,
    ObservationBlobAcknowledgementV1, TranscriptRoot,
};
use rusqlite::{OptionalExtension, Transaction, params};

use super::lifecycle::ContentProjectionError;

#[derive(Clone, Debug)]
pub(super) struct StreamState {
    pub(super) workspace_id: String,
    pub(super) conversation_id: String,
    pub(super) turn_id: String,
    pub(super) session_scope: String,
    pub(super) correlation_provenance: String,
    pub(super) attempt_id: Option<String>,
    pub(super) parent_root: Option<String>,
    pub(super) state: String,
    pub(super) next_chunk_ordinal: u32,
    pub(super) active_content_id: Option<String>,
}

pub(super) fn insert_or_verify<Insert, Select>(
    _transaction: &Transaction<'_>,
    table: &str,
    workspace: &str,
    id: &str,
    rejected: &serde_json::Value,
    insert: Insert,
    select: Select,
) -> Result<(), ContentProjectionError>
where
    Insert: FnOnce() -> rusqlite::Result<usize>,
    Select: FnOnce() -> rusqlite::Result<serde_json::Value>,
{
    match insert() {
        Ok(_) => Ok(()),
        Err(rusqlite::Error::SqliteFailure(ref code, _))
            if code.code == rusqlite::ErrorCode::ConstraintViolation =>
        {
            let existing = select().map_err(|_| ContentProjectionError::ActivityStorage)?;
            if existing == *rejected {
                Ok(())
            } else {
                Err(ContentProjectionError::ImmutableConflict {
                    key: format!("{table}:{workspace}:{id}"),
                    existing: projection_digest(&existing),
                    rejected: projection_digest(rejected),
                })
            }
        }
        Err(_) => Err(ContentProjectionError::ActivityStorage),
    }
}

pub(super) fn insert_transcript_root(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
    result: &TranscriptRoot,
) -> Result<(), ContentProjectionError> {
    let inserted = transaction
        .execute(
            "INSERT OR IGNORE INTO transcript_roots_v2
         (workspace_id, transcript_root, conversation_id, request_id, direction, fork_id,
          parent_transcript_root, state, acknowledged_at_unix_nanos)
         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
            params![
                envelope.correlation.workspace_id.as_str(),
                result.as_str(),
                envelope.correlation.conversation_id.as_str(),
                envelope.correlation.request_id.as_str(),
                envelope.direction.as_str(),
                envelope.fork_id,
                envelope
                    .parent_transcript_root
                    .as_ref()
                    .map(|value| value.as_str()),
                envelope.phase.as_str(),
                i64_from_u64(envelope.occurred_at_unix_nanos)?
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    if inserted == 0 {
        let existing: (String, String, String, Option<String>, String) = transaction
            .query_row(
                "SELECT conversation_id, request_id, direction, parent_transcript_root, state
             FROM transcript_roots_v2 WHERE workspace_id=?1 AND transcript_root=?2",
                params![envelope.correlation.workspace_id.as_str(), result.as_str()],
                |row| {
                    Ok((
                        row.get(0)?,
                        row.get(1)?,
                        row.get(2)?,
                        row.get(3)?,
                        row.get(4)?,
                    ))
                },
            )
            .map_err(|_| ContentProjectionError::ActivityStorage)?;
        let rejected = (
            envelope.correlation.conversation_id.as_str().to_owned(),
            envelope.correlation.request_id.as_str().to_owned(),
            envelope.direction.as_str().to_owned(),
            envelope
                .parent_transcript_root
                .as_ref()
                .map(ToString::to_string),
            envelope.phase.as_str().to_owned(),
        );
        if existing != rejected {
            return Err(ContentProjectionError::ImmutableConflict {
                key: format!("transcript_root:{}", result),
                existing: projection_digest(&existing),
                rejected: projection_digest(&rejected),
            });
        }
    }
    Ok(())
}

pub(super) fn ensure_scope(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<(), ContentProjectionError> {
    let occurred_ms = envelope.occurred_at_unix_nanos / 1_000_000;
    transaction
        .execute(
            "INSERT OR IGNORE INTO sessions
         (workspace_id, session_id, agent_id, correlation, started_at_ms, updated_at_ms,
          facts_completeness, content_completeness)
         VALUES (?1, ?2, '', ?3, ?4, ?4, 'unknown', 'unknown')",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.conversation_id.as_str(),
                enum_json(&envelope.correlation.correlation_provenance)?,
                i64_from_u64(occurred_ms)?
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    let correlation = enum_json(&envelope.correlation.correlation_provenance)?;
    let session_scope = enum_json(&envelope.correlation.session_scope)?;
    let existing_correlation: String = transaction
        .query_row(
            "SELECT correlation FROM sessions WHERE workspace_id=?1 AND session_id=?2",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.conversation_id.as_str()
            ],
            |row| row.get(0),
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    if existing_correlation == "unproven" && correlation != "unproven" {
        transaction
            .execute(
                "UPDATE sessions SET correlation=?3 WHERE workspace_id=?1 AND session_id=?2",
                params![
                    envelope.correlation.workspace_id.as_str(),
                    envelope.correlation.conversation_id.as_str(),
                    correlation,
                ],
            )
            .map_err(|_| ContentProjectionError::ActivityStorage)?;
    } else if existing_correlation != correlation {
        return Err(ContentProjectionError::ImmutableConflict {
            key: format!("session:{}", envelope.correlation.conversation_id),
            existing: projection_digest(&existing_correlation),
            rejected: projection_digest(&correlation),
        });
    }
    transaction
        .execute(
            "INSERT OR IGNORE INTO turns (workspace_id, turn_id, session_id, started_at_ms)
         VALUES (?1, ?2, ?3, ?4)",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.turn_id.as_str(),
                envelope.correlation.conversation_id.as_str(),
                i64_from_u64(occurred_ms)?
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    let turn_session: String = transaction
        .query_row(
            "SELECT session_id FROM turns WHERE workspace_id=?1 AND turn_id=?2",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.turn_id.as_str()
            ],
            |row| row.get(0),
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    if turn_session != envelope.correlation.conversation_id.as_str() {
        return Err(ContentProjectionError::ImmutableConflict {
            key: format!("turn:{}", envelope.correlation.turn_id),
            existing: projection_digest(&turn_session),
            rejected: projection_digest(&envelope.correlation.conversation_id.as_str()),
        });
    }
    transaction
        .execute(
            "INSERT OR IGNORE INTO logical_requests
         (workspace_id, request_id, session_id, turn_id, session_scope,
          correlation_provenance, traffic_kind, started_at_ms)
         VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'unknown', ?7)",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.request_id.as_str(),
                envelope.correlation.conversation_id.as_str(),
                envelope.correlation.turn_id.as_str(),
                session_scope,
                correlation,
                i64_from_u64(occurred_ms)?
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    transaction
        .execute(
            "UPDATE logical_requests SET session_scope=?3, correlation_provenance=?4
             WHERE workspace_id=?1 AND request_id=?2
               AND session_scope IS NULL AND correlation_provenance IS NULL",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.request_id.as_str(),
                session_scope,
                correlation,
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    let scope: (String, String, Option<String>, Option<String>) = transaction
        .query_row(
            "SELECT session_id, turn_id, session_scope, correlation_provenance
             FROM logical_requests WHERE workspace_id=?1 AND request_id=?2",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.request_id.as_str()
            ],
            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    if scope
        != (
            envelope.correlation.conversation_id.to_string(),
            envelope.correlation.turn_id.to_string(),
            Some(session_scope.clone()),
            Some(correlation.clone()),
        )
    {
        return Err(ContentProjectionError::ImmutableConflict {
            key: format!("request:{}", envelope.correlation.request_id),
            existing: projection_digest(&scope),
            rejected: projection_digest(&(
                envelope.correlation.conversation_id.as_str(),
                envelope.correlation.turn_id.as_str(),
                session_scope.as_str(),
                correlation.as_str(),
            )),
        });
    }
    Ok(())
}

pub(super) fn load_stream(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<StreamState, ContentProjectionError> {
    transaction
        .query_row(
            "SELECT workspace_id, conversation_id, turn_id, session_scope,
                correlation_provenance, attempt_id, parent_transcript_root, state,
                next_chunk_ordinal, active_content_id
         FROM conversation_content_streams_v2
         WHERE producer_id=?1 AND producer_epoch=?2 AND stream_id=?3 AND request_id=?4
           AND direction=?5 AND fork_id=?6",
            coordinate_params(envelope),
            |row| {
                let ordinal: i64 = row.get(8)?;
                Ok(StreamState {
                    workspace_id: row.get(0)?,
                    conversation_id: row.get(1)?,
                    turn_id: row.get(2)?,
                    session_scope: row.get(3)?,
                    correlation_provenance: row.get(4)?,
                    attempt_id: row.get(5)?,
                    parent_root: row.get(6)?,
                    state: row.get(7)?,
                    next_chunk_ordinal: ordinal
                        .try_into()
                        .map_err(|_| rusqlite::Error::IntegralValueOutOfRange(8, ordinal))?,
                    active_content_id: row.get(9)?,
                })
            },
        )
        .optional()
        .map_err(|_| ContentProjectionError::ActivityStorage)?
        .ok_or(ContentProjectionError::ContentStateConflict {
            expected: ConversationContentPhaseV2::Begin,
            rejected: envelope.phase,
        })
}

pub(super) fn validate_stream_coordinates(
    stream: &StreamState,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<(), ContentProjectionError> {
    let expected = (
        &stream.workspace_id,
        &stream.conversation_id,
        &stream.turn_id,
        &stream.session_scope,
        &stream.correlation_provenance,
        &stream.attempt_id,
        &stream.parent_root,
    );
    let rejected = (
        envelope.correlation.workspace_id.as_str(),
        envelope.correlation.conversation_id.as_str(),
        envelope.correlation.turn_id.as_str(),
        enum_json(&envelope.correlation.session_scope)?,
        enum_json(&envelope.correlation.correlation_provenance)?,
        &envelope.attempt_id.as_ref().map(ToString::to_string),
        &envelope
            .parent_transcript_root
            .as_ref()
            .map(ToString::to_string),
    );
    if expected.0 != rejected.0
        || expected.1 != rejected.1
        || expected.2 != rejected.2
        || expected.3.as_str() != rejected.3.as_str()
        || expected.4.as_str() != rejected.4.as_str()
        || expected.5 != rejected.5
        || expected.6 != rejected.6
    {
        return Err(ContentProjectionError::ImmutableConflict {
            key: format!(
                "content_stream:{}:{}:{}",
                envelope.correlation.request_id,
                envelope.direction.as_str(),
                envelope.fork_id
            ),
            existing: projection_digest(&expected),
            rejected: projection_digest(&rejected),
        });
    }
    Ok(())
}

// Finish only visits its request/direction/fork before sorting the small result.
// The workspace/content-ID ordering index otherwise makes some planner estimates
// scan all retained content while holding the ingestion writer.
const ACKNOWLEDGED_BLOBS_SQL: &str =
    "SELECT content_id, content_blob_digest FROM content_instances_v2 INDEXED BY content_instances_v2_request
     WHERE workspace_id=?1 AND request_id=?2 AND direction=?3 AND fork_id=?4 AND state='complete'
     ORDER BY content_id";
const MISSING_BLOBS_SQL: &str = "SELECT content_id, content_blob_digest FROM content_instances_v2 INDEXED BY content_instances_v2_request
     WHERE workspace_id=?1 AND request_id=?2 AND direction=?3 AND fork_id=?4 AND state!='complete'
     ORDER BY content_id";

#[cfg(test)]
#[path = "projection_tests.rs"]
mod tests;

pub(super) fn acknowledged_blobs(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<Vec<ObservationBlobAcknowledgementV1>, ContentProjectionError> {
    let mut statement = transaction
        .prepare(ACKNOWLEDGED_BLOBS_SQL)
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    statement
        .query_map(
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.request_id.as_str(),
                envelope.direction.as_str(),
                envelope.fork_id
            ],
            |row| {
                Ok(ObservationBlobAcknowledgementV1 {
                    content_id: row.get(0)?,
                    digest: row.get(1)?,
                })
            },
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?
        .collect::<Result<Vec<_>, _>>()
        .map_err(|_| ContentProjectionError::ActivityStorage)
}

pub(super) fn missing_blobs(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<Vec<ObservationBlobAcknowledgementV1>, ContentProjectionError> {
    let mut statement = transaction
        .prepare(MISSING_BLOBS_SQL)
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    statement
        .query_map(
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.request_id.as_str(),
                envelope.direction.as_str(),
                envelope.fork_id
            ],
            |row| {
                Ok(ObservationBlobAcknowledgementV1 {
                    content_id: row.get(0)?,
                    digest: row.get(1)?,
                })
            },
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?
        .collect::<Result<Vec<_>, _>>()
        .map_err(|_| ContentProjectionError::ActivityStorage)
}

pub(super) fn accumulated_expected(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
    content: &ContentId,
) -> Result<Option<u64>, ContentProjectionError> {
    let value: Option<i64> = transaction.query_row("SELECT expected_byte_count FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2",
        params![envelope.correlation.workspace_id.as_str(), content.as_str()], |row| row.get(0)).map_err(|_| ContentProjectionError::ActivityStorage)?;
    value
        .map(|value| {
            value
                .try_into()
                .map_err(|_| ContentProjectionError::ContentCorrupt)
        })
        .transpose()
}
pub(super) fn accumulated_expected_str(
    transaction: &Transaction<'_>,
    workspace: &str,
    content: &str,
) -> Result<Option<u64>, ContentProjectionError> {
    let value: Option<i64> = transaction.query_row("SELECT expected_byte_count FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2", params![workspace, content], |row| row.get(0)).map_err(|_| ContentProjectionError::ActivityStorage)?;
    value
        .map(|value| {
            value
                .try_into()
                .map_err(|_| ContentProjectionError::ContentCorrupt)
        })
        .transpose()
}
pub(super) fn accumulated_actual_str(
    transaction: &Transaction<'_>,
    workspace: &str,
    content: &str,
) -> Result<u64, ContentProjectionError> {
    let value: i64 = transaction.query_row("SELECT accumulated_byte_count FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2", params![workspace, content], |row| row.get(0)).map_err(|_| ContentProjectionError::ActivityStorage)?;
    value
        .try_into()
        .map_err(|_| ContentProjectionError::ContentCorrupt)
}
pub(super) fn content_digest(
    transaction: &Transaction<'_>,
    workspace: &str,
    content: &str,
) -> Result<String, ContentProjectionError> {
    transaction.query_row("SELECT content_blob_digest FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2", params![workspace, content], |row| row.get(0)).map_err(|_| ContentProjectionError::ActivityStorage)
}

pub(super) fn touch_content_session(
    transaction: &Transaction<'_>,
    envelope: &ConversationContentEnvelopeV1,
) -> Result<(), ContentProjectionError> {
    transaction
        .execute(
            "UPDATE sessions SET updated_at_ms=MAX(updated_at_ms, ?3)
         WHERE workspace_id=?1 AND session_id=?2",
            params![
                envelope.correlation.workspace_id.as_str(),
                envelope.correlation.conversation_id.as_str(),
                i64_from_u64(envelope.occurred_at_unix_nanos / 1_000_000)?
            ],
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    if envelope.phase != hiroute_domain::ConversationContentPhaseV2::Append {
        super::completeness::refresh_session(
            transaction,
            envelope.correlation.workspace_id.as_str(),
            envelope.correlation.conversation_id.as_str(),
        )
        .map_err(|_| ContentProjectionError::ActivityStorage)?;
    }
    Ok(())
}

pub(super) fn coordinate_params(envelope: &ConversationContentEnvelopeV1) -> [&str; 6] {
    [
        envelope.producer.stream.producer_id.as_str(),
        envelope.producer.stream.producer_epoch.as_str(),
        envelope.producer.stream.stream_id.as_str(),
        envelope.correlation.request_id.as_str(),
        envelope.direction.as_str(),
        envelope.fork_id.as_str(),
    ]
}
pub(super) fn enum_json<T: serde::Serialize>(value: &T) -> Result<String, ContentProjectionError> {
    serde_json::to_value(value)
        .map_err(|_| ContentProjectionError::Invalid("enum"))?
        .as_str()
        .map(ToOwned::to_owned)
        .ok_or(ContentProjectionError::Invalid("enum"))
}
pub(super) fn projection_digest<T: serde::Serialize>(value: &T) -> String {
    use sha2::{Digest as _, Sha256};
    let bytes = serde_json::to_vec(value).unwrap_or_default();
    format!("sha256:{:x}", Sha256::digest(bytes))
}
pub(super) fn event_file_key(event_id: &str) -> String {
    use sha2::{Digest as _, Sha256};
    format!("{:x}", Sha256::digest(event_id.as_bytes()))
}
pub(super) fn terminal_phase(state: &str) -> ConversationContentPhaseV2 {
    if state == "abort" {
        ConversationContentPhaseV2::Abort
    } else {
        ConversationContentPhaseV2::Finish
    }
}
pub(super) fn i64_from_u64(value: u64) -> Result<i64, ContentProjectionError> {
    value
        .try_into()
        .map_err(|_| ContentProjectionError::Invalid("integer"))
}