Create / edit recipe form unification and improvements

crates/goose-cli/src/session/builder.rs

@@ -240,7 +240,7 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
             process::exit(1);
         });
 
-    // Handle session file resolution and resuming
+    // Handle session resolution and resuming
     let session_id: Option<String> = if session_config.no_session {
         None
     } else if session_config.resume {

crates/goose-server/src/openapi.rs

@@ -6,7 +6,6 @@ use goose::config::ExtensionEntry;
 use goose::conversation::Conversation;
 use goose::permission::permission_confirmation::PrincipalType;
 use goose::providers::base::{ConfigKey, ModelInfo, ProviderMetadata};
-
 use goose::session::{Session, SessionInsights};
 use rmcp::model::{
     Annotations, Content, EmbeddedResource, Icon, ImageContent, JsonObject, RawAudioContent,
@@ -353,6 +352,7 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::session::get_session_insights,
         super::routes::session::update_session_description,
         super::routes::session::delete_session,
+        super::routes::session::update_session_user_recipe_values,
         super::routes::schedule::create_schedule,
         super::routes::schedule::list_schedules,
         super::routes::schedule::delete_schedule,
@@ -391,6 +391,7 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::context::ContextManageResponse,
         super::routes::session::SessionListResponse,
         super::routes::session::UpdateSessionDescriptionRequest,
+        super::routes::session::UpdateSessionUserRecipeValuesRequest,
         Message,
         MessageContent,
         MessageMetadata,

crates/goose-server/src/routes/recipe.rs

@@ -4,10 +4,10 @@ use std::sync::Arc;
 
 use axum::routing::get;
 use axum::{extract::State, http::StatusCode, routing::post, Json, Router};
-use goose::conversation::{message::Message, Conversation};
 use goose::recipe::recipe_library;
 use goose::recipe::Recipe;
 use goose::recipe_deeplink;
+use goose::session::SessionManager;
 
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
@@ -18,16 +18,10 @@ use crate::state::AppState;
 
 #[derive(Debug, Deserialize, ToSchema)]
 pub struct CreateRecipeRequest {
-    messages: Vec<Message>,
-    // Required metadata
-    title: String,
-    description: String,
+    session_id: String,
     // Optional fields
     #[serde(default)]
-    activities: Option<Vec<String>>,
-    #[serde(default)]
     author: Option<AuthorRequest>,
-    session_id: String,
 }
 
 #[derive(Debug, Deserialize, ToSchema)]
@@ -127,25 +121,38 @@ async fn create_recipe(
     Json(request): Json<CreateRecipeRequest>,
 ) -> Result<Json<CreateRecipeResponse>, StatusCode> {
     tracing::info!(
-        "Recipe creation request received with {} messages",
-        request.messages.len()
+        "Recipe creation request received for session_id: {}",
+        request.session_id
     );
 
+    // Load messages from session
+    let session = match SessionManager::get_session(&request.session_id, true).await {
+        Ok(session) => session,
+        Err(e) => {
+            tracing::error!("Failed to get session: {}", e);
+            return Err(StatusCode::INTERNAL_SERVER_ERROR);
+        }
+    };
+
+    let conversation = match session.conversation {
+        Some(conversation) => conversation,
+        None => {
+            let error_message = "Session has no conversation".to_string();
+            let error_response = CreateRecipeResponse {
+                recipe: None,
+                error: Some(error_message),
+            };
+            return Ok(Json(error_response));
+        }
+    };
+
     let agent = state.get_agent_for_route(request.session_id).await?;
 
     // Create base recipe from agent state and messages
-    let recipe_result = agent
-        .create_recipe(Conversation::new_unvalidated(request.messages))
-        .await;
+    let recipe_result = agent.create_recipe(conversation).await;
 
     match recipe_result {
         Ok(mut recipe) => {
-            recipe.title = request.title;
-            recipe.description = request.description;
-            if request.activities.is_some() {
-                recipe.activities = request.activities
-            };
-
             if let Some(author_req) = request.author {
                 recipe.author = Some(goose::recipe::Author {
                     contact: author_req.contact,
@@ -160,7 +167,11 @@ async fn create_recipe(
         }
         Err(e) => {
             tracing::error!("Error details: {:?}", e);
-            Err(StatusCode::BAD_REQUEST)
+            let error_response = CreateRecipeResponse {
+                recipe: None,
+                error: Some(format!("Failed to create recipe: {}", e)),
+            };
+            Ok(Json(error_response))
         }
     }
 }
@@ -241,7 +252,7 @@ async fn scan_recipe(
 async fn list_recipes(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<ListRecipeResponse>, StatusCode> {
-    let recipe_manifest_with_paths = get_all_recipes_manifests().unwrap();
+    let recipe_manifest_with_paths = get_all_recipes_manifests().unwrap_or_default();
     let mut recipe_file_hash_map = HashMap::new();
     let recipe_manifest_responses = recipe_manifest_with_paths
         .iter()

crates/goose-server/src/routes/session.rs

@@ -8,6 +8,7 @@ use axum::{
 use goose::session::session_manager::SessionInsights;
 use goose::session::{Session, SessionManager};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::sync::Arc;
 use utoipa::ToSchema;
 
@@ -25,6 +26,13 @@ pub struct UpdateSessionDescriptionRequest {
     description: String,
 }
 
+#[derive(Deserialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateSessionUserRecipeValuesRequest {
+    /// Recipe parameter values entered by the user
+    user_recipe_values: HashMap<String, String>,
+}
+
 const MAX_DESCRIPTION_LENGTH: usize = 200;
 
 #[utoipa::path(
@@ -128,6 +136,38 @@ async fn update_session_description(
     Ok(StatusCode::OK)
 }
 
+#[utoipa::path(
+    put,
+    path = "/sessions/{session_id}/user_recipe_values",
+    request_body = UpdateSessionUserRecipeValuesRequest,
+    params(
+        ("session_id" = String, Path, description = "Unique identifier for the session")
+    ),
+    responses(
+        (status = 200, description = "Session user recipe values updated successfully"),
+        (status = 401, description = "Unauthorized - Invalid or missing API key"),
+        (status = 404, description = "Session not found"),
+        (status = 500, description = "Internal server error")
+    ),
+    security(
+        ("api_key" = [])
+    ),
+    tag = "Session Management"
+)]
+// Update session user recipe parameter values
+async fn update_session_user_recipe_values(
+    Path(session_id): Path<String>,
+    Json(request): Json<UpdateSessionUserRecipeValuesRequest>,
+) -> Result<StatusCode, StatusCode> {
+    SessionManager::update_session(&session_id)
+        .user_recipe_values(Some(request.user_recipe_values))
+        .apply()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    Ok(StatusCode::OK)
+}
+
 #[utoipa::path(
     delete,
     path = "/sessions/{session_id}",
@@ -169,5 +209,9 @@ pub fn routes(state: Arc<AppState>) -> Router {
             "/sessions/{session_id}/description",
             put(update_session_description),
         )
+        .route(
+            "/sessions/{session_id}/user_recipe_values",
+            put(update_session_user_recipe_values),
+        )
         .with_state(state)
 }

crates/goose/src/agents/agent.rs

@@ -1591,9 +1591,31 @@ impl Agent {
             extension_configs.len()
         );
 
+        let (title, description) =
+            if let Ok(json_content) = serde_json::from_str::<Value>(&clean_content) {
+                let title = json_content
+                    .get("title")
+                    .and_then(|t| t.as_str())
+                    .unwrap_or("Custom recipe from chat")
+                    .to_string();
+
+                let description = json_content
+                    .get("description")
+                    .and_then(|d| d.as_str())
+                    .unwrap_or("a custom recipe instance from this chat session")
+                    .to_string();
+
+                (title, description)
+            } else {
+                (
+                    "Custom recipe from chat".to_string(),
+                    "a custom recipe instance from this chat session".to_string(),
+                )
+            };
+
         let recipe = Recipe::builder()
-            .title("Custom recipe from chat")
-            .description("a custom recipe instance from this chat session")
+            .title(title)
+            .description(description)
             .instructions(instructions)
             .activities(activities)
             .extensions(extension_configs)

crates/goose/src/context_mgmt/auto_compact.rs

@@ -330,6 +330,7 @@ mod tests {
             extension_data: extension_data::ExtensionData::new(),
             conversation: Some(conversation),
             message_count,
+            user_recipe_values: None,
         }
     }
 

crates/goose/src/prompts/recipe.md

@@ -1,13 +1,16 @@
 Based on our conversation so far, could you create:
 
-1. A concise set of instructions (1-2 paragraphs) that describe what you've been helping with. Make the instructions generic, and higher-level so that can be re-used across various similar tasks. Pay special attention if any output styles or formats are requested (and make it clear), and note any non standard tools used or required.
+1. A concise title (5-10 words) that captures the main topic or task
+2. A brief description (1-2 sentences) that summarizes what this recipe helps with
+3. A concise set of instructions (1-2 paragraphs) that describe what you've been helping with. Make the instructions generic, and higher-level so that can be re-used across various similar tasks. Pay special attention if any output styles or formats are requested (and make it clear), and note any non standard tools used or required.
+4. A list of 3-5 example activities (as a few words each at most) that would be relevant to this topic
 
-2. A list of 3-5 example activities (as a few words each at most) that would be relevant to this topic
-
-Format your response in _VALID_ json, with one key being `instructions` which contains a string, and the other key `activities` as an array of strings.
+Format your response in _VALID_ json, with keys being `title`, `description`, `instructions` (string), and `activities` (array of strings).
 For example, perhaps we have been discussing fruit and you might write:
 
 {
+"title": "Fruit Information Assistant",
+"description": "A recipe for finding and sharing information about different types of fruit.",
 "instructions": "Using web searches we find pictures of fruit, and always check what language to reply in.",
 "activities": [
 "Show pics of apples",