codegraff 0.1.1__tar.gz → 0.1.2__tar.gz

{codegraff-0.1.1 → codegraff-0.1.2}/Cargo.lock

@@ -2744,7 +2744,7 @@ dependencies = [
 
 [[package]]
 name = "forge_sdk_python"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "forge_api",

{codegraff-0.1.1 → codegraff-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraff
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3

{codegraff-0.1.1 → codegraff-0.1.2}/crates/forge_services/src/mcp/manager.rs

@@ -120,6 +120,18 @@ where
             return Ok(McpConfig::default());
         }
 
+        // Opt-in non-interactive trust for headless / SDK use: when
+        // FORGE_MCP_TRUST_ALL is set, accept (and persist) project-local
+        // configs without prompting.
+        if std::env::var("FORGE_MCP_TRUST_ALL")
+            .map(|v| !v.is_empty() && v != "0" && !v.eq_ignore_ascii_case("false"))
+            .unwrap_or(false)
+        {
+            store.remember(local_path.to_path_buf(), hash);
+            self.write_trust_store(&store).await?;
+            return Ok(local);
+        }
+
         let prompt = format_trust_prompt(local_path);
         match self
             .infra
@@ -131,11 +143,16 @@ where
                 self.write_trust_store(&store).await?;
                 Ok(local)
             }
-            Some(McpTrustResponse::Reject) | None => {
+            // An explicit reject persists so we don't re-prompt next run.
+            Some(McpTrustResponse::Reject) => {
                 store.reject(local_path.to_path_buf(), hash);
                 self.write_trust_store(&store).await?;
                 Ok(McpConfig::default())
             }
+            // No interactive answer (headless / no TTY): skip loading this
+            // run but do NOT persist a reject — a non-answer must not become a
+            // sticky rejection. A later interactive run can still prompt.
+            None => Ok(McpConfig::default()),
         }
     }
 }

{codegraff-0.1.1 → codegraff-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "codegraff"
-version = "0.1.1"
+version = "0.1.2"
 description = "Python SDK for the codegraff agent (PyO3 bindings)."
 readme = "README.md"
 requires-python = ">=3.9"

{codegraff-0.1.1 → codegraff-0.1.2}/python/codegraff/__init__.py

@@ -68,10 +68,20 @@ class Graff:
         *,
         conversation_id: Optional[str] = None,
         model: Optional[str] = None,
+        agent: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        custom_rules: Optional[str] = None,
+        temperature: Optional[float] = None,
     ) -> Iterator[AgentEvent]:
-        """Run a chat turn. Yields AgentEvent objects."""
+        """Run a chat turn. Yields AgentEvent objects.
+
+        agent: select a built-in or custom (tool-scoped) agent for this run.
+        system_prompt / custom_rules / temperature: per-call overrides.
+        """
         validate("chat", {"prompt": prompt, "conversation_id": conversation_id, "model": model})
-        handle = self._api.chat(prompt, conversation_id, model)
+        handle = self._api.chat(
+            prompt, conversation_id, model, agent, system_prompt, custom_rules, temperature
+        )
         yield AgentEvent(type="ConversationStarted", data={"conversationId": handle.conversation_id})
         while True:
             raw = handle.next_event()
@@ -84,8 +94,20 @@ class Graff:
         *,
         conversation_id: Optional[str] = None,
         model: Optional[str] = None,
+        agent: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        custom_rules: Optional[str] = None,
+        temperature: Optional[float] = None,
     ) -> "GraffSession":
-        return GraffSession(self, conversation_id=conversation_id, model=model)
+        return GraffSession(
+            self,
+            conversation_id=conversation_id,
+            model=model,
+            agent=agent,
+            system_prompt=system_prompt,
+            custom_rules=custom_rules,
+            temperature=temperature,
+        )
 
     # -- Conversation management --
 
@@ -111,6 +133,15 @@ class Graff:
     def get_agent_infos(self) -> list[dict]:
         return json.loads(self._api.get_agent_infos())
 
+    def set_active_agent(self, agent_id: str) -> None:
+        """Select the agent for subsequent chats — a built-in ('forge'/'muse'/
+        'sage') or a custom, tool-scoped agent defined in
+        `.forge/agents/<id>.md` (its `tools:` allowlist constrains the run)."""
+        self._api.set_active_agent(agent_id)
+
+    def get_active_agent(self) -> Optional[str]:
+        return self._api.get_active_agent()
+
     # -- Auth --
 
     def upsert_credential(
@@ -148,17 +179,33 @@ class GraffSession:
         *,
         conversation_id: Optional[str] = None,
         model: Optional[str] = None,
+        agent: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        custom_rules: Optional[str] = None,
+        temperature: Optional[float] = None,
     ):
         self._graff = graff
         self._conversation_id = conversation_id
         self._model = model
+        self._agent = agent
+        self._system_prompt = system_prompt
+        self._custom_rules = custom_rules
+        self._temperature = temperature
 
     @property
     def conversation_id(self) -> Optional[str]:
         return self._conversation_id
 
     def send(self, prompt: str) -> Iterator[AgentEvent]:
-        for event in self._graff.chat(prompt, conversation_id=self._conversation_id, model=self._model):
+        for event in self._graff.chat(
+            prompt,
+            conversation_id=self._conversation_id,
+            model=self._model,
+            agent=self._agent,
+            system_prompt=self._system_prompt,
+            custom_rules=self._custom_rules,
+            temperature=self._temperature,
+        ):
             if event.type == "ConversationStarted" and not self._conversation_id:
                 self._conversation_id = event.data.get("conversationId")
             yield event

{codegraff-0.1.1 → codegraff-0.1.2}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "forge_sdk_python"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 publish = false
 description = "PyO3 bindings exposing the codegraff agent to Python."

{codegraff-0.1.1 → codegraff-0.1.2}/sdk/python/src/lib.rs

@@ -5,7 +5,7 @@ use std::sync::{Arc, OnceLock};
 use forge_api::{API, ChatRequest, ForgeAPI};
 use forge_config::ForgeConfig;
 use forge_domain::{
-    ApiKey, ApiKeyResponse, AuthContext, AuthContextRequest, AuthContextResponse,
+    AgentId, ApiKey, ApiKeyResponse, AuthContext, AuthContextRequest, AuthContextResponse,
     AuthMethod, ChatResponse, Conversation, ConversationId, Event, ModelId,
     ProviderId, URLParam, URLParamValue,
 };
@@ -119,10 +119,31 @@ impl GraffApi {
         })
     }
 
-    fn chat(&self, py: Python<'_>, prompt: String, conversation_id: Option<String>, model: Option<String>) -> PyResult<ChatStreamHandle> {
+    #[pyo3(signature = (prompt, conversation_id=None, model=None, agent=None, system_prompt=None, custom_rules=None, temperature=None))]
+    fn chat(
+        &self,
+        py: Python<'_>,
+        prompt: String,
+        conversation_id: Option<String>,
+        model: Option<String>,
+        agent: Option<String>,
+        system_prompt: Option<String>,
+        custom_rules: Option<String>,
+        temperature: Option<f64>,
+    ) -> PyResult<ChatStreamHandle> {
         let inner = self.inner.clone();
         py.detach(|| {
             runtime().block_on(async {
+                // Optional per-call agent selection — e.g. a tool-scoped custom
+                // agent from `.forge/agents/<id>.md`. Sets the active agent for
+                // this and subsequent chats (mirrors set_active_agent).
+                if let Some(agent_id) = agent {
+                    inner
+                        .set_active_agent(AgentId::new(agent_id))
+                        .await
+                        .map_err(map_err)?;
+                }
+
                 let conv_id = match conversation_id {
                     Some(s) => parse_conv_id(&s)?,
                     None => {
@@ -138,6 +159,15 @@ impl GraffApi {
                 if let Some(model_str) = model {
                     chat_req.model_override = Some(ModelId::new(model_str));
                 }
+                if let Some(sp) = system_prompt {
+                    chat_req.system_prompt_override = Some(sp);
+                }
+                if let Some(rules) = custom_rules {
+                    chat_req.custom_rules_override = Some(rules);
+                }
+                if let Some(temp) = temperature {
+                    chat_req.temperature_override = Some(temp as f32);
+                }
 
                 let stream = inner.chat(chat_req).await.map_err(map_err)?;
                 Ok(ChatStreamHandle {
@@ -216,6 +246,27 @@ impl GraffApi {
         })
     }
 
+    fn set_active_agent(&self, py: Python<'_>, agent_id: String) -> PyResult<()> {
+        let inner = self.inner.clone();
+        py.detach(|| {
+            runtime().block_on(async {
+                inner
+                    .set_active_agent(AgentId::new(agent_id))
+                    .await
+                    .map_err(map_err)
+            })
+        })
+    }
+
+    fn get_active_agent(&self, py: Python<'_>) -> PyResult<Option<String>> {
+        let inner = self.inner.clone();
+        py.detach(|| {
+            runtime().block_on(async {
+                Ok(inner.get_active_agent().await.map(|a| a.as_str().to_string()))
+            })
+        })
+    }
+
     fn version(&self) -> String {
         env!("CARGO_PKG_VERSION").to_string()
     }