Skip to content
Python
36.0 KB
Raw Blame
//! Trusted model connections. Secrets never enter the session/event journal.
use anyhow::{bail, Context, Result};
use rusqlite::{params, Connection};
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::{collections::BTreeMap, path::Path, sync::Mutex};
use zeroize::Zeroizing;

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
pub struct Choice {
    pub connection: String,
    pub model: String,
}
impl Choice {
    pub fn new(provider: impl Into<String>, name: impl Into<String>) -> Self {
        Self {
            connection: provider.into(),
            model: name.into(),
        }
    }
    pub fn validate(&self) -> Result<()> {
        if !crate::bundle::safe_name(&self.connection)
            || self.connection.len() > 64
            || self.model.is_empty()
            || self.model.len() > 256
            || !self
                .model
                .bytes()
                .all(|c| c.is_ascii_alphanumeric() || b"-._:/".contains(&c))
        {
            bail!("Invalid model connection or model ID");
        }
        Ok(())
    }
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Selection {
    #[serde(default)]
    pub provider: crate::provider::Kind,
    pub connection: String,
    pub model: String,
    pub identity: String,
}
#[derive(Default, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Defaults {
    pub agent: Option<Choice>,
    pub reviewer: Option<Choice>,
}
struct State {
    db: Connection,
    memory: BTreeMap<String, Zeroizing<String>>,
    host_references: std::collections::BTreeSet<String>,
    tokens: BTreeMap<String, std::sync::Arc<crate::provider_auth::Tokens>>,
}
pub struct Manager {
    scope: String,
    state: Mutex<State>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Set {
    id: String,
    label: String,
    provider: crate::provider::Kind,
    api_key: String,
    persistence: String,
    #[serde(default)]
    api: Option<crate::model_api::Api>,
    #[serde(default)]
    base_url: Option<String>,
    #[serde(default)]
    stream_usage: Option<bool>,
    #[serde(default)]
    prompt_caching: Option<bool>,
    #[serde(default)]
    thinking: Option<crate::anthropic::Thinking>,
}
impl Manager {
    /// Trusted server bootstrap only; not exposed by the model or stdio protocol.
    /// A deployment-owned identity lets separate nodes resolve the same session.
    /// Only the key is rotated; changing identity makes existing sessions refuse.
    pub fn register_host(
        &self,
        id: &str,
        provider: crate::provider::Kind,
        identity: &str,
        key: Zeroizing<String>,
    ) -> Result<()> {
        self.host(id, provider, identity, Some(key))
    }
    /// API-only identity reference. Does not read or hold a provider credential.
    pub fn register_host_reference(
        &self,
        id: &str,
        provider: crate::provider::Kind,
        identity: &str,
    ) -> Result<()> {
        self.host(id, provider, identity, None)
    }
    fn host(
        &self,
        id: &str,
        provider: crate::provider::Kind,
        identity: &str,
        key: Option<Zeroizing<String>>,
    ) -> Result<()> {
        Choice {
            connection: id.into(),
            model: "validation".into(),
        }
        .validate()?;
        if identity.is_empty()
            || identity.len() > 128
            || !identity
                .bytes()
                .all(|b| b.is_ascii_alphanumeric() || b"-_.:".contains(&b))
            || key.as_ref().is_some_and(|key| {
                key.len() < 8 || key.len() > 4096 || !key.bytes().all(|b| (33..=126).contains(&b))
            })
        {
            bail!("Invalid host model connection");
        }
        let identity = crate::bundle::digest(
            format!("host-model-v1:{identity}:{}:{id}", provider.name()).as_bytes(),
        );
        let mut state = self.state.lock().unwrap();
        use rusqlite::OptionalExtension;
        let custom_endpoint: bool = state.db.query_row(
            "SELECT EXISTS(SELECT 1 FROM endpoints WHERE id=?1)",
            [id],
            |r| r.get(0),
        )?;
        if custom_endpoint {
            bail!("Host bootstrap cannot replace an SDK provider; use a separate connection ID");
        }
        let previous: Option<String> = state
            .db
            .query_row("SELECT provider FROM connections WHERE id=?1", [id], |r| {
                r.get(0)
            })
            .optional()?;
        if previous.as_deref().is_some_and(|p| p != provider.name()) {
            bail!("Host connection provider changed; use a new connection ID");
        }
        state.db.execute("INSERT INTO connections(id,label,identity,persistence,secret,provider) VALUES(?1,?1,?2,'memory',NULL,?3) ON CONFLICT(id) DO UPDATE SET identity=excluded.identity,persistence='memory',secret=NULL",params![id,identity,provider.name()])?;
        state.host_references.insert(id.into());
        if let Some(key) = key {
            state.memory.insert(id.into(), key);
        } else {
            state.memory.remove(id);
        }
        Ok(())
    }
    pub fn open(root: &Path) -> Result<Self> {
        crate::platform::private_directory(root)?;
        let path = root.join("model-connections.sqlite");
        if path.exists() && crate::platform::linked(&path.symlink_metadata()?) {
            bail!("Credential database cannot be a link");
        }
        let db = Connection::open(path)?;
        db.execute_batch("PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL; PRAGMA secure_delete=ON; BEGIN IMMEDIATE;
            CREATE TABLE IF NOT EXISTS connections(id TEXT PRIMARY KEY,label TEXT NOT NULL,identity TEXT NOT NULL,persistence TEXT NOT NULL,secret BLOB);
            CREATE TABLE IF NOT EXISTS settings(id INTEGER PRIMARY KEY CHECK(id=1),value TEXT NOT NULL);")?;
        let has_provider = db
            .prepare("PRAGMA table_info(connections)")?
            .query_map([], |r| r.get::<_, String>(1))?
            .collect::<std::result::Result<Vec<_>, _>>()?
            .iter()
            .any(|name| name == "provider");
        if !has_provider {
            db.execute_batch(
                "ALTER TABLE connections ADD COLUMN provider TEXT NOT NULL DEFAULT 'openai'",
            )?;
        }
        db.execute_batch("CREATE TABLE IF NOT EXISTS endpoints(id TEXT PRIMARY KEY, api TEXT NOT NULL, base_url TEXT NOT NULL);")?;
        db.execute_batch("CREATE TABLE IF NOT EXISTS thinking_options(id TEXT PRIMARY KEY, value TEXT NOT NULL);")?;
        let has_stream_usage = db
            .prepare("PRAGMA table_info(endpoints)")?
            .query_map([], |r| r.get::<_, String>(1))?
            .collect::<std::result::Result<Vec<_>, _>>()?
            .iter()
            .any(|name| name == "stream_usage");
        if !has_stream_usage {
            db.execute_batch(
                "ALTER TABLE endpoints ADD COLUMN stream_usage INTEGER NOT NULL DEFAULT 1 CHECK(stream_usage IN (0,1))",
            )?;
        }
        let has_prompt_caching = db
            .prepare("PRAGMA table_info(endpoints)")?
            .query_map([], |r| r.get::<_, String>(1))?
            .collect::<std::result::Result<Vec<_>, _>>()?
            .iter()
            .any(|name| name == "prompt_caching");
        if !has_prompt_caching {
            db.execute_batch(
                "ALTER TABLE endpoints ADD COLUMN prompt_caching INTEGER NOT NULL DEFAULT 1 CHECK(prompt_caching IN (0,1))",
            )?;
        }
        // Multiple service controllers may prepare the same immutable child type.
        // Serialize check-and-alter migrations so a duplicate initializer cannot
        // turn valid child provisioning into a permanent definition failure.
        db.execute_batch("COMMIT")?;
        Ok(Self {
            scope: root.canonicalize()?.to_string_lossy().into(),
            state: Mutex::new(State {
                db,
                memory: BTreeMap::new(),
                host_references: Default::default(),
                tokens: Default::default(),
            }),
        })
    }
    pub fn list(&self) -> Result<Value> {
        let state = self.state.lock().unwrap();
        let mut statement = state.db.prepare(
            "SELECT id,label,persistence,secret IS NOT NULL,provider FROM connections ORDER BY id",
        )?;
        let rows = statement.query_map([], |r| {
            Ok((
                r.get::<_, String>(0)?,
                r.get::<_, String>(1)?,
                r.get::<_, String>(2)?,
                r.get::<_, bool>(3)?,
                r.get::<_, String>(4)?,
            ))
        })?;
        let mut connections = vec![];
        for row in rows {
            let (id, label, persistence, stored, provider) = row?;
            use rusqlite::OptionalExtension;
            let endpoint: Option<(String, String, bool, bool)> = state
                .db
                .query_row(
                    "SELECT api,base_url,stream_usage,prompt_caching FROM endpoints WHERE id=?1",
                    [&id],
                    |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)),
                )
                .optional()?;
            let (api, base_url, stream_usage, prompt_caching) = endpoint
                .map(|(a, b, usage, caching)| {
                    (
                        serde_json::from_str::<Value>(&a).unwrap_or(Value::Null),
                        b,
                        usage,
                        caching,
                    )
                })
                .unwrap_or_else(|| {
                    let api = if provider == "anthropic" {
                        crate::model_api::Api::Anthropic
                    } else {
                        crate::model_api::Api::Responses
                    };
                    (json!(api), api.default_url().into(), true, true)
                });
            connections.push(json!({"id":id,"name":id,"label":label,"provider":provider,"api":api,"base_url":base_url,"persistence":persistence,"configured":persistence=="none"||stored||state.memory.contains_key(&id)||state.tokens.get(&id).is_some_and(|t|t.ready())}));
            if api == "chat-completions" {
                connections.last_mut().unwrap()["stream_usage"] = json!(stream_usage);
            }
            if api == "anthropic" {
                connections.last_mut().unwrap()["prompt_caching"] = json!(prompt_caching);
                let thinking: Option<String> = state
                    .db
                    .query_row(
                        "SELECT value FROM thinking_options WHERE id=?1",
                        [&id],
                        |r| r.get(0),
                    )
                    .optional()?;
                if let Some(value) = thinking {
                    connections.last_mut().unwrap()["thinking"] = serde_json::from_str(&value)?;
                }
            }
        }
        Ok(
            json!({"connections":connections,"secure_storage_available":cfg!(any(windows,target_os="macos"))}),
        )
    }
    pub fn set(&self, value: Value) -> Result<Value> {
        // Never return serde's raw invalid-value diagnostics for a secret-bearing request.
        let mut input: Set = serde_json::from_value(value)
            .map_err(|_| anyhow::anyhow!("Invalid connection settings"))?;
        let key = Zeroizing::new(std::mem::take(&mut input.api_key));
        let api = input
            .api
            .unwrap_or(if input.provider == crate::provider::Kind::Anthropic {
                crate::model_api::Api::Anthropic
            } else {
                crate::model_api::Api::Responses
            });
        if api.kind() != input.provider {
            bail!("API and provider transport disagree");
        }
        if input.stream_usage.is_some() && api != crate::model_api::Api::ChatCompletions {
            bail!("stream_usage is only supported for Chat Completions");
        }
        if input.prompt_caching.is_some() && api != crate::model_api::Api::Anthropic {
            bail!("prompt_caching is only supported for Anthropic Messages");
        }
        if let Some(thinking) = &input.thinking {
            anyhow::ensure!(
                api == crate::model_api::Api::Anthropic,
                "thinking is only supported for Anthropic"
            );
            thinking.validate()?;
        }
        let base_url =
            crate::model_api::base_url(input.base_url.as_deref().unwrap_or(api.default_url()))?;
        let api_json = serde_json::to_string(&api)?;
        Choice {
            connection: input.id.clone(),
            model: "validation".into(),
        }
        .validate()?;
        if input.label.trim().is_empty()
            || input.label.len() > 100
            || input.label.chars().any(char::is_control)
            || (!["none", "access_token"].contains(&input.persistence.as_str()) && key.len() < 8)
            || (["none", "access_token"].contains(&input.persistence.as_str()) && !key.is_empty())
            || key.len() > 4096
            || !key.bytes().all(|c| (33..=126).contains(&c))
            || !["secure", "memory", "none", "access_token"].contains(&input.persistence.as_str())
        {
            bail!("Invalid connection settings");
        }
        let mut state = self.state.lock().unwrap();
        use rusqlite::OptionalExtension;
        let existing: Option<String> = state
            .db
            .query_row(
                "SELECT provider FROM connections WHERE id=?1",
                [&input.id],
                |r| r.get(0),
            )
            .optional()?;
        if state
            .db
            .query_row(
                "SELECT persistence FROM connections WHERE id=?1",
                [&input.id],
                |r| r.get::<_, String>(0),
            )
            .optional()?
            .as_deref()
            == Some("access_token")
        {
            bail!("Use provider/auth/update to rotate access tokens");
        }
        #[cfg(target_os = "macos")]
        let was_secure = state
            .db
            .query_row(
                "SELECT persistence='secure' FROM connections WHERE id=?1",
                [&input.id],
                |r| r.get::<_, bool>(0),
            )
            .optional()?
            .unwrap_or(false);
        if existing
            .as_deref()
            .is_some_and(|p| p != input.provider.name())
        {
            bail!("Connection provider is immutable; create a different connection");
        }
        let endpoint: Option<(String, String)> = state
            .db
            .query_row(
                "SELECT api,base_url FROM endpoints WHERE id=?1",
                [&input.id],
                |r| Ok((r.get(0)?, r.get(1)?)),
            )
            .optional()?;
        if let Some((old_api, old_url)) = endpoint {
            if old_api != api_json || old_url != base_url {
                bail!("Provider API and endpoint are immutable; use a new provider name");
            }
        } else if existing.is_some()
            && (api
                != if input.provider == crate::provider::Kind::Anthropic {
                    crate::model_api::Api::Anthropic
                } else {
                    crate::model_api::Api::Responses
                }
                || base_url != api.default_url())
        {
            bail!("Existing connection endpoint is immutable; use a new provider name");
        }
        let encrypted = if input.persistence == "secure" {
            Some(protect(key.as_bytes(), &self.entropy(&input.id), false)?)
        } else {
            None
        };
        let transaction = state.db.transaction()?;
        transaction.execute("INSERT INTO connections(id,label,identity,persistence,secret,provider) VALUES(?1,?2,?3,?4,?5,?6)
            ON CONFLICT(id) DO UPDATE SET label=excluded.label,persistence=excluded.persistence,secret=excluded.secret",
            params![input.id,input.label,crate::id("connection"),input.persistence,encrypted,input.provider.name()])?;
        transaction.execute(
            "INSERT INTO endpoints(id,api,base_url,stream_usage,prompt_caching) VALUES(?1,?2,?3,COALESCE(?4,1),COALESCE(?5,1)) ON CONFLICT(id) DO UPDATE SET stream_usage=COALESCE(?4,endpoints.stream_usage),prompt_caching=COALESCE(?5,endpoints.prompt_caching)",
            params![input.id, api_json, base_url, input.stream_usage, input.prompt_caching],
        )?;
        if let Some(thinking) = input.thinking {
            transaction.execute("INSERT INTO thinking_options(id,value) VALUES(?1,?2) ON CONFLICT(id) DO UPDATE SET value=excluded.value", params![input.id,serde_json::to_string(&thinking)?])?;
        }
        transaction.commit()?;
        #[cfg(target_os = "macos")]
        if was_secure && input.persistence != "secure" {
            forget_keychain(&self.entropy(&input.id))?;
        }
        if input.persistence == "memory" {
            state.memory.insert(input.id, key);
        } else {
            state.memory.remove(&input.id);
        }
        Ok(json!({"saved":true}))
    }
    pub fn remove(&self, id: &str) -> Result<Value> {
        let mut state = self.state.lock().unwrap();
        #[cfg(target_os = "macos")]
        if state
            .db
            .query_row(
                "SELECT persistence='secure' FROM connections WHERE id=?1",
                [id],
                |r| r.get::<_, bool>(0),
            )
            .unwrap_or(false)
        {
            forget_keychain(&self.entropy(id))?;
        }
        state
            .db
            .execute("DELETE FROM connections WHERE id=?1", [id])?;
        state.memory.remove(id);
        state.tokens.remove(id);
        state.host_references.remove(id);
        state
            .db
            .execute("DELETE FROM endpoints WHERE id=?1", [id])?;
        state
            .db
            .execute("DELETE FROM thinking_options WHERE id=?1", [id])?;
        Ok(json!({"removed":true}))
    }
    pub fn defaults(&self) -> Result<Defaults> {
        use rusqlite::OptionalExtension;
        let raw: Option<String> = self
            .state
            .lock()
            .unwrap()
            .db
            .query_row("SELECT value FROM settings WHERE id=1", [], |r| r.get(0))
            .optional()?;
        raw.map(|s| serde_json::from_str(&s).map_err(Into::into))
            .unwrap_or_else(|| Ok(Defaults::default()))
    }
    pub fn set_defaults(&self, v: Value) -> Result<Value> {
        let defaults: Defaults =
            serde_json::from_value(v).map_err(|_| anyhow::anyhow!("Invalid model defaults"))?;
        for choice in [&defaults.agent, &defaults.reviewer].into_iter().flatten() {
            self.resolve(choice)?;
        }
        self.state.lock().unwrap().db.execute("INSERT INTO settings(id,value) VALUES(1,?1) ON CONFLICT(id) DO UPDATE SET value=excluded.value",[serde_json::to_string(&defaults)?])?;
        Ok(json!({"defaults":defaults}))
    }
    pub fn resolve(&self, choice: &Choice) -> Result<Selection> {
        choice.validate()?;
        let (identity, provider): (String, String) = self
            .state
            .lock()
            .unwrap()
            .db
            .query_row(
                "SELECT identity,provider FROM connections WHERE id=?1",
                [&choice.connection],
                |r| Ok((r.get(0)?, r.get(1)?)),
            )
            .map_err(|_| {
                anyhow::anyhow!("Credentials required: configure the selected connection")
            })?;
        let selected = Selection {
            provider: serde_json::from_value(json!(provider))
                .context("Unsupported stored provider")?,
            connection: choice.connection.clone(),
            model: choice.model.clone(),
            identity,
        };
        let host_reference = self
            .state
            .lock()
            .unwrap()
            .host_references
            .contains(&choice.connection);
        if !host_reference && !self.credentials_ready(&selected) {
            bail!("Provider authentication required");
        }
        Ok(selected)
    }
    pub fn key(&self, selected: &Selection) -> Result<Zeroizing<String>> {
        let state = self.state.lock().unwrap();
        let (identity, kind, secret, provider): (String, String, Option<Vec<u8>>, String) = state
            .db
            .query_row(
                "SELECT identity,persistence,secret,provider FROM connections WHERE id=?1",
                [&selected.connection],
                |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)),
            )
            .map_err(|_| anyhow::anyhow!("Credentials required: selected connection is missing"))?;
        if identity != selected.identity || provider != selected.provider.name() {
            bail!("Connection identity changed; create a new session");
        }
        if kind == "none" {
            return Ok(Zeroizing::new(String::new()));
        }
        if kind == "memory" {
            return state
                .memory
                .get(&selected.connection)
                .map(|s| Zeroizing::new(s.to_string()))
                .context("Credentials required: resupply this memory-only key");
        }
        let encrypted = secret.context("Credentials required")?;
        let bytes = Zeroizing::new(protect(
            &encrypted,
            &self.entropy(&selected.connection),
            true,
        )?);
        Ok(Zeroizing::new(
            std::str::from_utf8(&bytes)
                .context("Invalid protected credential")?
                .into(),
        ))
    }
    pub fn credentials_ready(&self, selected: &Selection) -> bool {
        match self.access_tokens(selected) {
            Ok(Some(tokens)) => tokens.ready(),
            Ok(None) => self.key(selected).is_ok(),
            Err(_) => false,
        }
    }
    pub fn access_tokens(
        &self,
        selected: &Selection,
    ) -> Result<Option<std::sync::Arc<crate::provider_auth::Tokens>>> {
        self.endpoint(selected)?; // Includes the pinned connection identity check.
        let mut state = self.state.lock().unwrap();
        let kind: String = state.db.query_row(
            "SELECT persistence FROM connections WHERE id=?1",
            [&selected.connection],
            |r| r.get(0),
        )?;
        Ok(if kind == "access_token" {
            Some(
                state
                    .tokens
                    .entry(selected.connection.clone())
                    .or_default()
                    .clone(),
            )
        } else {
            None
        })
    }
    pub fn register_access_auth(
        &self,
        name: &str,
        refresh: Option<crate::provider_auth::Refresh>,
    ) -> Result<()> {
        Choice::new(name, "validation").validate()?;
        let mut state = self.state.lock().unwrap();
        let (kind, provider): (String, String) = state.db.query_row(
            "SELECT persistence,provider FROM connections WHERE id=?1",
            [name],
            |r| Ok((r.get(0)?, r.get(1)?)),
        )?;
        anyhow::ensure!(
            provider == "openai",
            "Access-token authentication requires a Bearer API"
        );
        anyhow::ensure!(
            kind == "none" || kind == "access_token",
            "Use a new provider name for access-token authentication"
        );
        state.db.execute(
            "UPDATE connections SET persistence='access_token',secret=NULL WHERE id=?1",
            [name],
        )?;
        state.tokens.entry(name.into()).or_default().bind(refresh);
        Ok(())
    }
    pub fn update_access_token(
        &self,
        name: &str,
        token: crate::provider_auth::AccessToken,
    ) -> Result<()> {
        let mut state = self.state.lock().unwrap();
        let kind: String = state.db.query_row(
            "SELECT persistence FROM connections WHERE id=?1",
            [name],
            |r| r.get(0),
        )?;
        anyhow::ensure!(
            kind == "access_token",
            "Register access-token authentication first"
        );
        state.tokens.entry(name.into()).or_default().update(token);
        Ok(())
    }
    fn entropy(&self, id: &str) -> Vec<u8> {
        format!("openworker-model-credentials-v1:{}:{id}", self.scope).into_bytes()
    }
    /// Endpoint identity is immutable for the life of a named connection. Keys can rotate.
    pub fn endpoint(&self, selected: &Selection) -> Result<(crate::model_api::Api, String)> {
        use rusqlite::OptionalExtension;
        let state = self.state.lock().unwrap();
        let identity: String = state
            .db
            .query_row(
                "SELECT identity FROM connections WHERE id=?1",
                [&selected.connection],
                |r| r.get(0),
            )
            .context("Selected model provider is missing")?;
        if identity != selected.identity {
            bail!("Connection identity changed; create a new session");
        }
        let endpoint: Option<(String, String)> = state
            .db
            .query_row(
                "SELECT api,base_url FROM endpoints WHERE id=?1",
                [&selected.connection],
                |r| Ok((r.get(0)?, r.get(1)?)),
            )
            .optional()?;
        let (api, base) = match endpoint {
            Some((api, url)) => (
                serde_json::from_str::<crate::model_api::Api>(&api)?,
                crate::model_api::base_url(&url)?,
            ),
            None => {
                let api = if selected.provider == crate::provider::Kind::Anthropic {
                    crate::model_api::Api::Anthropic
                } else {
                    crate::model_api::Api::Responses
                };
                (api, api.default_url().into())
            }
        };
        Ok((api, format!("{base}/{}", api.path())))
    }
    /// Whether a Chat Completions connection requests streaming token usage.
    /// Defaults to true for existing connections and survives credential rotation.
    pub fn stream_usage(&self, selected: &Selection) -> Result<bool> {
        self.state.lock().unwrap().db.query_row(
            "SELECT COALESCE(e.stream_usage,1) FROM connections c LEFT JOIN endpoints e ON c.id=e.id WHERE c.id=?1 AND c.identity=?2",
            params![selected.connection, selected.identity],
            |r| r.get(0),
        ).context("Selected model provider is missing or its identity changed")
    }
    /// Anthropic automatic prompt caching is on unless explicitly disabled.
    pub fn prompt_caching(&self, selected: &Selection) -> Result<bool> {
        self.state.lock().unwrap().db.query_row(
            "SELECT COALESCE(e.prompt_caching,1) FROM connections c LEFT JOIN endpoints e ON c.id=e.id WHERE c.id=?1 AND c.identity=?2",
            params![selected.connection, selected.identity],
            |r| r.get(0),
        ).context("Selected model provider is missing or its identity changed")
    }
    pub fn thinking(&self, selected: &Selection) -> Result<Option<crate::anthropic::Thinking>> {
        let value: Option<String> = self.state.lock().unwrap().db.query_row(
            "SELECT t.value FROM connections c LEFT JOIN thinking_options t ON c.id=t.id WHERE c.id=?1 AND c.identity=?2",
            params![selected.connection, selected.identity], |r|r.get(0))?;
        value
            .map(|v| serde_json::from_str(&v).map_err(Into::into))
            .transpose()
    }
    /// Harness-owned provider registration; never journal this secret-bearing request.
    pub fn set_provider(&self, value: Value) -> Result<Value> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct Input {
            name: String,
            api: crate::model_api::Api,
            base_url: Option<String>,
            credentials: Option<Credentials>,
            #[serde(default)]
            stream_usage: Option<bool>,
            #[serde(default)]
            prompt_caching: Option<bool>,
            #[serde(default)]
            thinking: Option<crate::anthropic::Thinking>,
            #[serde(default)]
            access_token_auth: bool,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct Credentials {
            api_key: String,
            storage: Option<String>,
        }
        let input: Input = serde_json::from_value(value)
            .map_err(|_| anyhow::anyhow!("Invalid model provider configuration"))?;
        Choice::new(&input.name, "validation").validate()?;
        if input.stream_usage.is_some() && input.api != crate::model_api::Api::ChatCompletions {
            bail!("stream_usage is only supported for Chat Completions");
        }
        if input.prompt_caching.is_some() && input.api != crate::model_api::Api::Anthropic {
            bail!("prompt_caching is only supported for Anthropic Messages");
        }
        if let Some(thinking) = &input.thinking {
            anyhow::ensure!(
                input.api == crate::model_api::Api::Anthropic,
                "thinking is only supported for Anthropic"
            );
            thinking.validate()?;
        }
        anyhow::ensure!(
            !input.access_token_auth
                || (input.credentials.is_none()
                    && input.api.kind() == crate::provider::Kind::Openai),
            "Access tokens require a Bearer API without static credentials"
        );
        use rusqlite::OptionalExtension;
        let existing = {
            let state = self.state.lock().unwrap();
            state.db.query_row("SELECT c.provider,e.api,e.base_url FROM connections c LEFT JOIN endpoints e ON c.id=e.id WHERE c.id=?1",[&input.name],|r|Ok((r.get::<_,String>(0)?,r.get::<_,Option<String>>(1)?,r.get::<_,Option<String>>(2)?))).optional()?
        };
        if input.api == crate::model_api::Api::ChatCompletions
            && input.base_url.is_none()
            && existing
                .as_ref()
                .and_then(|(_, _, url)| url.as_ref())
                .is_none()
        {
            bail!("Chat Completions requires an explicit base_url; provider names do not select endpoints");
        }
        let base_url = crate::model_api::base_url(
            input
                .base_url
                .as_deref()
                .or_else(|| existing.as_ref().and_then(|(_, _, url)| url.as_deref()))
                .unwrap_or(input.api.default_url()),
        )?;
        if let Some((provider, api, url)) = &existing {
            let old_api = api
                .as_deref()
                .map(serde_json::from_str::<crate::model_api::Api>)
                .transpose()?
                .unwrap_or(if provider == "anthropic" {
                    crate::model_api::Api::Anthropic
                } else {
                    crate::model_api::Api::Responses
                });
            if old_api != input.api || url.as_deref().unwrap_or(old_api.default_url()) != base_url {
                bail!("Provider API and endpoint are immutable; use a new provider name");
            }
            // An empty Settings key field must never erase an existing credential.
            if input.credentials.is_none() {
                if input.access_token_auth {
                    let kind: String = self.state.lock().unwrap().db.query_row(
                        "SELECT persistence FROM connections WHERE id=?1",
                        [&input.name],
                        |r| r.get(0),
                    )?;
                    if kind != "access_token" {
                        self.register_access_auth(&input.name, None)?;
                    }
                }
                if let Some(enabled) = input.stream_usage {
                    self.state.lock().unwrap().db.execute(
                        "UPDATE endpoints SET stream_usage=?2 WHERE id=?1",
                        params![input.name, enabled],
                    )?;
                }
                if let Some(enabled) = input.prompt_caching {
                    self.state.lock().unwrap().db.execute(
                        "INSERT INTO endpoints(id,api,base_url,prompt_caching) VALUES(?1,?2,?3,?4) ON CONFLICT(id) DO UPDATE SET prompt_caching=excluded.prompt_caching",
                        params![input.name, serde_json::to_string(&input.api)?, base_url, enabled],
                    )?;
                }
                if let Some(thinking) = input.thinking {
                    self.state.lock().unwrap().db.execute("INSERT INTO thinking_options(id,value) VALUES(?1,?2) ON CONFLICT(id) DO UPDATE SET value=excluded.value", params![input.name,serde_json::to_string(&thinking)?])?;
                }
                return Ok(json!({"saved":true,"credentials_unchanged":true}));
            }
        }
        let (key, storage) = match input.credentials {
            Some(c) => {
                let storage = c.storage.unwrap_or_else(|| "secure".into());
                if !["secure", "memory"].contains(&storage.as_str()) {
                    bail!("Credentials require secure or memory storage");
                }
                (c.api_key, storage)
            }
            None => (
                String::new(),
                if input.access_token_auth {
                    "access_token"
                } else {
                    "none"
                }
                .into(),
            ),
        };
        self.set(json!({"id":input.name,"label":input.name,"provider":input.api.kind(),"api":input.api,"base_url":base_url,"stream_usage":input.stream_usage,"prompt_caching":input.prompt_caching,"thinking":input.thinking,"api_key":key,"persistence":storage}))
    }
}
#[cfg(not(any(windows, target_os = "macos")))]
fn protect(_: &[u8], _: &[u8], _: bool) -> Result<Vec<u8>> {
    bail!("Secure credential persistence requires Windows DPAPI or macOS Keychain; choose memory explicitly. No plaintext fallback.")
}
#[cfg(target_os = "macos")]
fn protect(data: &[u8], entropy: &[u8], decrypt: bool) -> Result<Vec<u8>> {
    use security_framework::passwords::{get_generic_password, set_generic_password};
    let account = crate::bundle::digest(entropy);
    if decrypt {
        anyhow::ensure!(
            data == b"macos-keychain-v1",
            "Invalid Keychain credential reference"
        );
        get_generic_password("OpenWorker Model Providers", &account).map_err(|_| {
            anyhow::anyhow!("macOS Keychain credential unavailable; no plaintext fallback")
        })
    } else {
        set_generic_password("OpenWorker Model Providers", &account, data)
            .map_err(|_| anyhow::anyhow!("macOS Keychain storage failed; no plaintext fallback"))?;
        Ok(b"macos-keychain-v1".to_vec())
    }
}
#[cfg(target_os = "macos")]
fn forget_keychain(entropy: &[u8]) -> Result<()> {
    match security_framework::passwords::delete_generic_password(
        "OpenWorker Model Providers",
        &crate::bundle::digest(entropy),
    ) {
        Ok(()) => Ok(()),
        Err(e) if e.code() == -25300 => Ok(()), // errSecItemNotFound
        Err(_) => bail!("macOS Keychain could not remove the provider credential"),
    }
}
#[cfg(windows)]
fn protect(data: &[u8], entropy: &[u8], decrypt: bool) -> Result<Vec<u8>> {
    use windows_sys::Win32::{Foundation::LocalFree, Security::Cryptography::*};
    let input = CRYPT_INTEGER_BLOB {
        cbData: data.len() as u32,
        pbData: data.as_ptr().cast_mut(),
    };
    let extra = CRYPT_INTEGER_BLOB {
        cbData: entropy.len() as u32,
        pbData: entropy.as_ptr().cast_mut(),
    };
    let mut output = CRYPT_INTEGER_BLOB {
        cbData: 0,
        pbData: std::ptr::null_mut(),
    };
    let ok = unsafe {
        if decrypt {
            CryptUnprotectData(
                &input,
                std::ptr::null_mut(),
                &extra,
                std::ptr::null(),
                std::ptr::null(),
                CRYPTPROTECT_UI_FORBIDDEN,
                &mut output,
            )
        } else {
            CryptProtectData(
                &input,
                std::ptr::null(),
                &extra,
                std::ptr::null(),
                std::ptr::null(),
                CRYPTPROTECT_UI_FORBIDDEN,
                &mut output,
            )
        }
    };
    if ok == 0 {
        bail!("Windows secure credential operation failed; no plaintext fallback");
    }
    let result =
        unsafe { std::slice::from_raw_parts(output.pbData, output.cbData as usize).to_vec() };
    unsafe {
        std::ptr::write_bytes(output.pbData, 0, output.cbData as usize);
        LocalFree(output.pbData.cast());
    }
    Ok(result)
}