feat: expand companion platform, device controls, and memoir workflows
ci / verify (push) Canceled after 0s
ci / verify (push) Canceled after 0s
Add customer and operator login, BLE provisioning, device fleet controls, call memory, memoir generation, and refreshed family and maintenance portals. Include API contracts, migrations, firmware sources, tests, assets, and deployment documentation.
This commit is contained in:
Codex Local
@@ -0,0 +1,254 @@
|
||||
package callmemory
|
||||
|
||||
import (
|
||||
"context"
|
||||
"data-terminal-cloud/internal/deviceauth"
|
||||
"errors"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
type Event struct {
|
||||
ID string `json:"event_id"`
|
||||
Seq int64 `json:"event_seq"`
|
||||
Type string `json:"type"`
|
||||
Monotonic int64 `json:"monotonic_ms"`
|
||||
Occurred int64 `json:"occurred_at_ms"`
|
||||
AttemptID string `json:"media_attempt_id"`
|
||||
Payload map[string]any `json:"payload"`
|
||||
}
|
||||
type EventsInput struct {
|
||||
CallKey
|
||||
Events []Event `json:"events"`
|
||||
}
|
||||
type Transcript struct {
|
||||
Utterance string `json:"utterance_id"`
|
||||
Revision int64 `json:"source_revision"`
|
||||
Speaker string `json:"speaker"`
|
||||
Final bool `json:"source_final"`
|
||||
Text string `json:"text"`
|
||||
Part int `json:"text_part_index,omitempty"`
|
||||
Parts int `json:"text_part_count,omitempty"`
|
||||
Hash string `json:"full_text_sha256,omitempty"`
|
||||
ProviderID *string `json:"provider_event_id,omitempty"`
|
||||
Delivery string `json:"delivery_state,omitempty"`
|
||||
}
|
||||
|
||||
func transcriptPermission(ctx context.Context, tx pgx.Tx, subject string) (bool, error) {
|
||||
var allowed bool
|
||||
e := tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM subject_profile sp WHERE sp.id=$1::uuid AND sp.status='active' AND NOT EXISTS(SELECT 1 FROM privacy_request pr WHERE pr.subject_id=sp.id AND pr.request_type='DELETE') AND EXISTS(SELECT 1 FROM consent_record cr WHERE cr.subject_id=sp.id AND cr.consent_type='transcript_storage' AND cr.withdrawn_at IS NULL AND (cr.expires_at IS NULL OR cr.expires_at>now())))`, subject).Scan(&allowed)
|
||||
return allowed, e
|
||||
}
|
||||
|
||||
func (s *Service) events(ctx context.Context, tx pgx.Tx, d deviceauth.Identity, in EventsInput) (any, error) {
|
||||
if in.SessionID == nil || len(in.Events) < 1 || len(in.Events) > 16 {
|
||||
return nil, fault(400, "INVALID_EVENT_BATCH")
|
||||
}
|
||||
c, e := readSession(ctx, tx, d.ID, in.CallKey)
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
if c.Boot != in.BootID || c.Generation != in.Generation || c.Binding != in.Binding || (in.HookID != "" && c.Hook != in.HookID) {
|
||||
return nil, fault(409, "CALL_IDENTITY_MISMATCH")
|
||||
}
|
||||
canStore, e := transcriptPermission(ctx, tx, c.Subject)
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
accepted := []string{}
|
||||
rejected := []map[string]any{}
|
||||
for _, event := range in.Events {
|
||||
nested, beginErr := tx.Begin(ctx)
|
||||
if beginErr != nil {
|
||||
return nil, beginErr
|
||||
}
|
||||
err := s.event(ctx, nested, c, event, canStore)
|
||||
if err != nil {
|
||||
_ = nested.Rollback(ctx)
|
||||
var f *Error
|
||||
if !errors.As(err, &f) {
|
||||
return nil, err
|
||||
}
|
||||
rejected = append(rejected, map[string]any{"event_id": event.ID, "error_code": f.Code, "retryable": false})
|
||||
} else {
|
||||
if err = nested.Commit(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
accepted = append(accepted, event.ID)
|
||||
}
|
||||
}
|
||||
next := c.LastSeq
|
||||
for {
|
||||
var exists bool
|
||||
e = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM call_event WHERE session_id=$1::uuid AND seq=$2)`, c.ID, next+1).Scan(&exists)
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
if !exists {
|
||||
break
|
||||
}
|
||||
next++
|
||||
}
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET highest_contiguous_seq=GREATEST(highest_contiguous_seq,$2) WHERE id=$1::uuid`, c.ID, next)
|
||||
return map[string]any{"accepted_event_ids": accepted, "rejected_events": rejected, "highest_contiguous_seq": next}, e
|
||||
}
|
||||
func (s *Service) event(ctx context.Context, tx pgx.Tx, c session, v Event, canStore bool) error {
|
||||
if !validUUID(v.ID) || v.Seq < 1 || v.Seq > 2147483647 || v.Monotonic < 0 || v.Occurred < 0 || !validUUID(v.AttemptID) || v.Payload == nil {
|
||||
return fault(400, "INVALID_EVENT")
|
||||
}
|
||||
if !oneOf(v.Type, "START_INTENT", "MEDIA_CONNECTED", "MEDIA_DISCONNECTED", "FIRST_AUDIO_RECEIVED", "FIRST_PLAYBACK_STARTED", "CONVERSATION_STATUS", "TRANSCRIPT_REVISION", "INTERRUPTED", "GAP_DECLARED", "SDK_STOP_RESULT", "CALL_ERROR", "LOCAL_NOTICE_RESULT") {
|
||||
return fault(400, "UNKNOWN_EVENT_TYPE")
|
||||
}
|
||||
digest := hash(jsonBytes(v))
|
||||
var oldID, oldHash string
|
||||
e := tx.QueryRow(ctx, `SELECT event_id,digest FROM call_event WHERE session_id=$1::uuid AND (event_id=$2 OR seq=$3) LIMIT 1`, c.ID, v.ID, v.Seq).Scan(&oldID, &oldHash)
|
||||
if e == nil {
|
||||
if oldID != v.ID || oldHash != digest {
|
||||
return fault(409, "EVENT_CONFLICT")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if !errors.Is(e, pgx.ErrNoRows) {
|
||||
return e
|
||||
}
|
||||
var attempt string
|
||||
e = tx.QueryRow(ctx, `SELECT COALESCE(media_attempt_id,'') FROM call_session WHERE id=$1::uuid`, c.ID).Scan(&attempt)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if attempt != "" && attempt != v.AttemptID {
|
||||
return fault(409, "MEDIA_ATTEMPT_CONFLICT")
|
||||
}
|
||||
if v.Type == "TRANSCRIPT_REVISION" && !canStore {
|
||||
return fault(403, "TRANSCRIPT_STORAGE_REVOKED")
|
||||
}
|
||||
if v.Type == "START_INTENT" {
|
||||
manifest, _ := v.Payload["manifest_id"].(string)
|
||||
if manifest != c.ManifestID || c.ManifestStatus != "ISSUED" || c.Expires == nil || !c.Expires.After(s.now()) {
|
||||
return fault(409, "MANIFEST_REVOKED")
|
||||
}
|
||||
var renewed bool
|
||||
e = tx.QueryRow(ctx, `SELECT authorization_renewed_at IS NOT NULL AND lease_expires_at>now() FROM call_session WHERE id=$1::uuid`, c.ID).Scan(&renewed)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if !renewed {
|
||||
return fault(409, "FIRST_HEARTBEAT_REQUIRED")
|
||||
}
|
||||
}
|
||||
_, e = tx.Exec(ctx, `INSERT INTO call_event(session_id,event_id,seq,event_type,digest,payload) VALUES($1::uuid,$2,$3,$4,$5,$6::jsonb)`, c.ID, v.ID, v.Seq, v.Type, digest, jsonBytes(v))
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
// Event persistence never renews authorization or revives a terminal call.
|
||||
switch v.Type {
|
||||
case "START_INTENT":
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET media_attempt_id=COALESCE(media_attempt_id,$2),call_state=CASE WHEN call_state='PREPARING' THEN 'STARTING' ELSE call_state END WHERE id=$1::uuid`, c.ID, v.AttemptID)
|
||||
case "MEDIA_CONNECTED":
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET media_attempt_id=COALESCE(media_attempt_id,$2),remote_state=CASE WHEN sdk_stopped THEN remote_state ELSE 'ACTIVE' END,call_state=CASE WHEN manifest_status='ISSUED' AND call_state IN ('PREPARING','STARTING') THEN 'TALKING' ELSE call_state END WHERE id=$1::uuid`, c.ID, v.AttemptID)
|
||||
case "MEDIA_DISCONNECTED":
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET remote_state=CASE WHEN sdk_stopped THEN remote_state ELSE 'UNKNOWN' END WHERE id=$1::uuid`, c.ID)
|
||||
case "GAP_DECLARED":
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET text_gap=true,transcript_state=CASE WHEN transcript_state IN ('COMPLETE','EMPTY') THEN 'PARTIAL' ELSE transcript_state END WHERE id=$1::uuid`, c.ID)
|
||||
case "SDK_STOP_RESULT":
|
||||
if v.Payload["outcome"] == "STOPPED_OBSERVED" {
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET sdk_stopped=true,remote_state=CASE WHEN remote_state IN ('NOT_STARTED','STOPPED_OBSERVED') THEN remote_state ELSE 'UNKNOWN' END WHERE id=$1::uuid`, c.ID)
|
||||
}
|
||||
case "TRANSCRIPT_REVISION":
|
||||
var t Transcript
|
||||
if e = StrictJSON(jsonBytes(v.Payload), &t); e != nil {
|
||||
return e
|
||||
}
|
||||
e = s.transcript(ctx, tx, c, v, t)
|
||||
}
|
||||
return e
|
||||
}
|
||||
func (s *Service) transcript(ctx context.Context, tx pgx.Tx, c session, v Event, t Transcript) error {
|
||||
var suppressed bool
|
||||
if e := tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM memory_source_suppression s CROSS JOIN LATERAL jsonb_array_elements(s.source_refs) r WHERE s.subject_id=$1::uuid AND s.scope='SOURCE_AND_DERIVED' AND r->>'session_id'=$2 AND r->>'utterance_id'=$3)`, c.Subject, c.ID, t.Utterance).Scan(&suppressed); e != nil {
|
||||
return e
|
||||
}
|
||||
if suppressed {
|
||||
return fault(410, "SOURCE_REDACTED")
|
||||
}
|
||||
if t.Parts == 0 {
|
||||
t.Parts = 1
|
||||
}
|
||||
if t.Hash == "" && t.Parts == 1 {
|
||||
t.Hash = hash([]byte(t.Text))
|
||||
}
|
||||
if !short(t.Utterance) || t.Revision < 0 || !oneOf(t.Speaker, "USER", "ASSISTANT", "UNKNOWN") || !utf8.ValidString(t.Text) || len(t.Text) > 4096 || len(t.Text) == 0 || t.Parts < 1 || t.Parts > 16 || t.Part < 0 || t.Part >= t.Parts || len(t.Hash) != 64 {
|
||||
return fault(400, "INVALID_TRANSCRIPT_FRAGMENT")
|
||||
}
|
||||
var oldText, oldHash, oldSpeaker string
|
||||
var oldParts int
|
||||
var oldFinal bool
|
||||
e := tx.QueryRow(ctx, `SELECT text_content,content_sha256,speaker,part_count,is_final FROM call_text_fragment WHERE session_id=$1::uuid AND utterance_id=$2 AND source_revision=$3 AND part_index=$4`, c.ID, t.Utterance, t.Revision, t.Part).Scan(&oldText, &oldHash, &oldSpeaker, &oldParts, &oldFinal)
|
||||
if e == nil {
|
||||
if oldText != t.Text || oldHash != t.Hash || oldSpeaker != t.Speaker || oldParts != t.Parts || oldFinal != t.Final {
|
||||
return fault(409, "FRAGMENT_CONFLICT")
|
||||
}
|
||||
} else {
|
||||
if !errors.Is(e, pgx.ErrNoRows) {
|
||||
return e
|
||||
}
|
||||
var mismatch bool
|
||||
e = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM call_text_fragment WHERE session_id=$1::uuid AND utterance_id=$2 AND source_revision=$3 AND (content_sha256<>$4 OR part_count<>$5 OR speaker<>$6 OR is_final<>$7))`, c.ID, t.Utterance, t.Revision, t.Hash, t.Parts, t.Speaker, t.Final).Scan(&mismatch)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if mismatch {
|
||||
return fault(409, "FRAGMENT_CONFLICT")
|
||||
}
|
||||
_, e = tx.Exec(ctx, `INSERT INTO call_text_fragment(session_id,utterance_id,source_revision,part_index,part_count,speaker,text_content,content_sha256,is_final,interrupted,source_at) VALUES($1::uuid,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`, c.ID, t.Utterance, t.Revision, t.Part, t.Parts, t.Speaker, t.Text, t.Hash, t.Final, t.Delivery == "PARTIAL", time.UnixMilli(v.Occurred))
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
}
|
||||
var count int
|
||||
var full string
|
||||
e = tx.QueryRow(ctx, `SELECT count(*),COALESCE(string_agg(text_content,'' ORDER BY part_index),'') FROM call_text_fragment WHERE session_id=$1::uuid AND utterance_id=$2 AND source_revision=$3`, c.ID, t.Utterance, t.Revision).Scan(&count, &full)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if count != t.Parts {
|
||||
return nil
|
||||
}
|
||||
if hash([]byte(full)) != strings.ToLower(t.Hash) {
|
||||
return fault(409, "TEXT_HASH_MISMATCH")
|
||||
}
|
||||
if t.Final && t.Speaker == "UNKNOWN" {
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET text_gap=true WHERE id=$1::uuid`, c.ID)
|
||||
return e
|
||||
}
|
||||
if !t.Final {
|
||||
return nil
|
||||
}
|
||||
var priorRevision int64
|
||||
var priorSpeaker string
|
||||
e = tx.QueryRow(ctx, `SELECT source_revision,speaker FROM call_utterance WHERE session_id=$1::uuid AND utterance_id=$2`, c.ID, t.Utterance).Scan(&priorRevision, &priorSpeaker)
|
||||
if e == nil {
|
||||
if priorSpeaker != t.Speaker {
|
||||
return fault(409, "SPEAKER_CONFLICT")
|
||||
}
|
||||
if priorRevision >= t.Revision {
|
||||
return nil
|
||||
}
|
||||
} else if !errors.Is(e, pgx.ErrNoRows) {
|
||||
return e
|
||||
}
|
||||
_, e = tx.Exec(ctx, `INSERT INTO call_utterance(session_id,utterance_id,source_revision,speaker,text_content,interrupted,playback_complete,source_at) VALUES($1::uuid,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(session_id,utterance_id) DO UPDATE SET source_revision=excluded.source_revision,text_content=excluded.text_content,interrupted=excluded.interrupted,playback_complete=excluded.playback_complete,source_at=excluded.source_at WHERE call_utterance.source_revision<excluded.source_revision`, c.ID, t.Utterance, t.Revision, t.Speaker, full, t.Delivery == "PARTIAL", t.Delivery == "COMPLETED_OBSERVED", time.UnixMilli(v.Occurred))
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
_, e = tx.Exec(ctx, `UPDATE call_session SET transcript_revision=transcript_revision+1,last_text_at=now(),transcript_state=CASE WHEN transcript_state IN ('COMPLETE','PARTIAL','EMPTY') THEN 'DRAINING' ELSE transcript_state END,drain_started_at=CASE WHEN transcript_state IN ('COMPLETE','PARTIAL','EMPTY') THEN now() ELSE drain_started_at END WHERE id=$1::uuid`, c.ID)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if t.Speaker == "USER" {
|
||||
_, e = tx.Exec(ctx, `INSERT INTO call_postprocess_job(session_id,transcript_revision,extractor_version) SELECT id,transcript_revision,'intent-1' FROM call_session WHERE id=$1::uuid ON CONFLICT DO NOTHING`, c.ID)
|
||||
}
|
||||
return e
|
||||
}
|
||||
Reference in New Issue
Block a user