codegraff 0.1.1__tar.gz → 0.1.3__tar.gz

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

@@ -2744,7 +2744,7 @@ dependencies = [
 
 [[package]]
 name = "forge_sdk_python"
-version = "0.1.1"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "forge_api",
@@ -2755,6 +2755,7 @@ dependencies = [
  "futures",
  "pyo3",
  "rustls 0.23.40",
+ "schemars 1.2.1",
  "serde",
  "serde_json",
  "tokio",

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

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

{codegraff-0.1.1 → codegraff-0.1.3}/crates/forge_app/src/app.rs

@@ -200,6 +200,10 @@ impl<S: Services + EnvironmentInfra<Config = forge_config::ForgeConfig>> ForgeAp
             ),
             None => agent,
         };
+        let agent = match chat.response_format.clone() {
+            Some(rf) => agent.response_format(rf),
+            None => agent,
+        };
 
         let selected_model = models.iter().find(|model| model.id == agent.model);
         let agent = agent.compaction_threshold(selected_model);

{codegraff-0.1.1 → codegraff-0.1.3}/crates/forge_app/src/apply_tunable_parameters.rs

@@ -41,6 +41,9 @@ impl ApplyTunableParameters {
         if let Some(verbosity) = self.agent.verbosity {
             ctx = ctx.verbosity(verbosity);
         }
+        if let Some(ref response_format) = self.agent.response_format {
+            ctx = ctx.response_format(response_format.clone());
+        }
 
         // Send only meta-tool definitions to the provider instead of all tool definitions.
         // Meta-tools (tools_list, tools_info, call_tool) allow the LLM to dynamically

{codegraff-0.1.1 → codegraff-0.1.3}/crates/forge_domain/src/agent.rs

@@ -8,7 +8,8 @@ use serde::{Deserialize, Serialize};
 use strum_macros::{Display as StrumDisplay, EnumString};
 
 use crate::{
-    Compact, Error, EventContext, MaxTokens, Model, ModelId, ProviderId, Result, SystemContext,
+    Compact, Error, EventContext, MaxTokens, Model, ModelId, ProviderId, ResponseFormat, Result,
+    SystemContext,
     Temperature, Template, ToolDefinition, ToolName, TopK, TopP,
 };
 
@@ -182,6 +183,14 @@ pub struct Agent {
     /// Reasoning configuration for the agent.
     pub reasoning: Option<ReasoningConfig>,
 
+    /// Optional structured-output format. When `Some(JsonSchema(..))`,
+    /// providers that support it constrain the model reply to the schema —
+    /// the SDK's JSON / structured-output mode. Set per-request via
+    /// `ChatRequest::response_format`; unset = normal text output.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    #[schemars(skip)]
+    pub response_format: Option<ResponseFormat>,
+
     /// Maximum number of times a tool can fail before sending the response back
     pub max_tool_failure_per_turn: Option<usize>,
 
@@ -239,6 +248,7 @@ impl Agent {
             top_k: Default::default(),
             max_tokens: Default::default(),
             reasoning: Default::default(),
+            response_format: Default::default(),
             max_tool_failure_per_turn: Default::default(),
             max_requests_per_turn: Default::default(),
             fast_mode: Default::default(),

{codegraff-0.1.1 → codegraff-0.1.3}/crates/forge_domain/src/chat_request.rs

@@ -29,6 +29,11 @@ pub struct ChatRequest {
     /// Optional per-request sampling temperature (0.0-2.0). Defaults to `None`.
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub temperature_override: Option<f32>,
+    /// Optional per-request structured-output format (JSON schema). When set,
+    /// the model reply is constrained to the schema where the provider supports
+    /// it — the SDK's JSON / structured-output mode. Defaults to `None`.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub response_format: Option<crate::ResponseFormat>,
 }
 
 impl ChatRequest {
@@ -40,6 +45,7 @@ impl ChatRequest {
             system_prompt_override: None,
             custom_rules_override: None,
             temperature_override: None,
+            response_format: None,
         }
     }
 }

{codegraff-0.1.1 → codegraff-0.1.3}/crates/forge_repo/src/agent_definition.rs

@@ -156,6 +156,7 @@ impl AgentDefinition {
             top_k: self.top_k,
             tools: self.tools,
             reasoning: self.reasoning,
+            response_format: None,
             compact: self.compact.unwrap_or_default(),
             max_turns: self.max_turns,
             custom_rules: self.custom_rules,

{codegraff-0.1.1 → codegraff-0.1.3}/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.3}/pyproject.toml

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

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

@@ -68,10 +68,24 @@ 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,
+        json_schema: Optional[Any] = 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.
+        json_schema: a JSON Schema (dict or JSON string) for structured output —
+            the model reply is constrained to it where the provider supports it.
+        """
         validate("chat", {"prompt": prompt, "conversation_id": conversation_id, "model": model})
-        handle = self._api.chat(prompt, conversation_id, model)
+        _schema = json.dumps(json_schema) if isinstance(json_schema, dict) else json_schema
+        handle = self._api.chat(
+            prompt, conversation_id, model, agent, system_prompt, custom_rules, temperature, _schema
+        )
         yield AgentEvent(type="ConversationStarted", data={"conversationId": handle.conversation_id})
         while True:
             raw = handle.next_event()
@@ -84,8 +98,22 @@ 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,
+        json_schema: Optional[Any] = 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,
+            json_schema=json_schema,
+        )
 
     # -- Conversation management --
 
@@ -111,6 +139,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 +185,36 @@ 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,
+        json_schema: Optional[Any] = 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
+        self._json_schema = json_schema
 
     @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,
+            json_schema=self._json_schema,
+        ):
             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.3}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "forge_sdk_python"
-version = "0.1.1"
+version = "0.1.3"
 edition = "2021"
 publish = false
 description = "PyO3 bindings exposing the codegraff agent to Python."
@@ -19,6 +19,7 @@ forge_domain = { path = "../../crates/forge_domain" }
 forge_stream = { path = "../../crates/forge_stream" }
 serde.workspace = true
 serde_json.workspace = true
+schemars.workspace = true
 futures = "0.3"
 tokio = { version = "1", features = ["full"] }
 anyhow = "1"

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

@@ -5,9 +5,9 @@ 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,
+    ProviderId, ResponseFormat, URLParam, URLParamValue,
 };
 use forge_stream::MpscStream;
 use futures::StreamExt;
@@ -119,10 +119,32 @@ 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, json_schema=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>,
+        json_schema: Option<String>,
+    ) -> 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 +160,21 @@ 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);
+                }
+                if let Some(schema_str) = json_schema {
+                    let schema: schemars::Schema = serde_json::from_str(&schema_str)
+                        .map_err(|e| py_err(format!("invalid json_schema: {e}")))?;
+                    chat_req.response_format =
+                        Some(ResponseFormat::JsonSchema(Box::new(schema)));
+                }
 
                 let stream = inner.chat(chat_req).await.map_err(map_err)?;
                 Ok(ChatStreamHandle {
@@ -216,6 +253,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()
     }