reduced some noisy debug logging, also adjusted context window calculation a bit

Author: orual

crates/pattern_core/src/context/mod.rs

@@ -242,7 +242,7 @@ impl Default for ModelAdjustments {
             native_thinking: false,
             use_xml_tags: true,
             max_context_tokens: None,
-            token_multiplier: 1.5, // Rough estimate: 1 token ≈ 0.75 words
+            token_multiplier: 1.0, // Rough estimate: 1 token ≈ 0.75 words
         }
     }
 }
@@ -505,10 +505,7 @@ impl ContextBuilder {
 </value>
 </{}>",
                     block.label,
-                    block
-                        .description
-                        .as_deref()
-                        .unwrap_or("No description provided"),
+                    block.description.as_deref().unwrap_or("No description"),
                     block.permission,
                     block.memory_type,
                     char_count,

crates/pattern_core/src/context/state.rs

@@ -1613,7 +1613,7 @@ impl AgentContext {
                     let total_tokens = system_tokens + message_tokens;
 
                     // Leave some buffer (use 80% of limit to trigger compression)
-                    total_tokens > (max_tokens * 2 / 3)
+                    total_tokens > (max_tokens * 5 / 6)
                 } else {
                     false
                 };
@@ -1675,10 +1675,6 @@ impl AgentContext {
             context.len(),
             context.system_prompt.len()
         );
-        for msg in &context.messages() {
-            tracing::debug!("{:?}", msg);
-        }
-
         Ok(context)
     }
 

crates/pattern_core/src/data_source/bluesky.rs

@@ -2538,15 +2538,12 @@ impl BlueskyFirehoseSource {
         if let Some(cached) = self.thread_cache.get(thread_root) {
             let now = std::time::Instant::now();
             if now.duration_since(cached.cached_at) < self.thread_cache_ttl {
-                tracing::debug!("📁 Cache HIT for thread {}", thread_root);
                 return Some(cached.context.clone());
             } else {
-                tracing::debug!("🕐 Cache EXPIRED for thread {}", thread_root);
                 // Remove expired entry
                 self.thread_cache.remove(thread_root);
             }
         } else {
-            tracing::debug!("📁 Cache MISS for thread {}", thread_root);
         }
         None
     }
@@ -2559,7 +2556,6 @@ impl BlueskyFirehoseSource {
         };
 
         self.thread_cache.insert(thread_root.clone(), cached);
-        tracing::debug!("💾 Cached thread context for {}", thread_root);
     }
 
     /// Check if thread was recently shown to agent (within TTL window)
@@ -2588,19 +2584,7 @@ impl BlueskyFirehoseSource {
         if let Ok(pending_posts) = self.pending_batch.pending_posts.try_read() {
             if let Some(post) = pending_posts.iter().find(|p| p.uri == uri) {
                 if post.hydration >= required_hydration {
-                    tracing::debug!(
-                        "📁 Post cache HIT for {} (hydration: {:?})",
-                        uri,
-                        post.hydration
-                    );
                     return Some(post.clone());
-                } else {
-                    tracing::debug!(
-                        "🔄 Post cache PARTIAL for {} (has: {:?}, need: {:?})",
-                        uri,
-                        post.hydration,
-                        required_hydration
-                    );
                 }
             }
         }
@@ -2609,24 +2593,10 @@ impl BlueskyFirehoseSource {
         for entry in self.pending_batch.posts_by_thread.iter() {
             if let Some(post) = entry.value().iter().find(|p| p.uri == uri) {
                 if post.hydration >= required_hydration {
-                    tracing::debug!(
-                        "📁 Post cache HIT (batched) for {} (hydration: {:?})",
-                        uri,
-                        post.hydration
-                    );
                     return Some(post.clone());
-                } else {
-                    tracing::debug!(
-                        "🔄 Post cache PARTIAL (batched) for {} (has: {:?}, need: {:?})",
-                        uri,
-                        post.hydration,
-                        required_hydration
-                    );
                 }
             }
         }
-
-        tracing::debug!("📁 Post cache MISS for {}", uri);
         None
     }
 
@@ -2662,12 +2632,6 @@ impl BlueskyFirehoseSource {
                         {
                             pending_posts.push(post.clone());
                         }
-
-                        tracing::debug!(
-                            "🌐 Fetched and cached post {} (hydration: {:?})",
-                            uri,
-                            required_hydration
-                        );
                         return Ok(Some(post));
                     }
                 }
@@ -2725,11 +2689,6 @@ impl BlueskyFirehoseSource {
                             cached_posts.push(post);
                         }
                     }
-                    tracing::debug!(
-                        "🌐 Batch fetched {} posts (hydration: {:?})",
-                        need_fetch.len(),
-                        required_hydration
-                    );
                 }
                 Err(e) => {
                     tracing::warn!("Failed to batch fetch posts: {}", e);

crates/pattern_core/src/message.rs

@@ -949,12 +949,12 @@ impl Message {
                 self.content.clone()
             }
             MessageContent::ToolResponses(_) => {
-                tracing::debug!("Converting ToolResponses message with role {:?}", role);
+                tracing::trace!("Converting ToolResponses message with role {:?}", role);
                 self.content.clone()
             }
             MessageContent::Parts(parts) => match role {
                 ChatRole::System | ChatRole::Assistant | ChatRole::Tool => {
-                    tracing::debug!("Combining Parts message with role {:?}", role);
+                    tracing::trace!("Combining Parts message with role {:?}", role);
                     let string = parts
                         .into_iter()
                         .map(|part| match part {

crates/pattern_core/src/oauth/resolver.rs

@@ -34,19 +34,12 @@ pub fn create_oauth_auth_resolver<C: Connection + 'static>(
 
             // Only handle Anthropic OAuth for now
             if adapter_kind == AdapterKind::Anthropic {
-                tracing::debug!("Checking OAuth token for Anthropic, user: {}", user_id);
                 // Use OAuthModelProvider to handle token refresh automatically
                 let provider =
                     crate::oauth::integration::OAuthModelProvider::new(db.clone(), user_id.clone());
 
                 match provider.get_token("anthropic").await {
                     Ok(Some(token)) => {
-                        // Token is automatically refreshed if needed by get_token()
-                        tracing::debug!(
-                            "Using OAuth token for Anthropic (expires: {})",
-                            token.expires_at
-                        );
-
                         // Return bearer token with "Bearer " prefix so genai detects OAuth
                         return Ok(Some(AuthData::Key(format!(
                             "Bearer {}",
@@ -57,9 +50,6 @@ pub fn create_oauth_auth_resolver<C: Connection + 'static>(
                         // No OAuth token found
                         // Check if API key is available as fallback
                         if std::env::var("ANTHROPIC_API_KEY").is_ok() {
-                            tracing::debug!(
-                                "No OAuth token found for Anthropic, falling back to API key"
-                            );
                             // Return None to use default auth (API key)
                             return Ok(None);
                         } else {
@@ -102,67 +92,6 @@ pub fn create_service_target_resolver() -> ServiceTargetResolver {
     ServiceTargetResolver::from_resolver_async_fn(resolver_fn)
 }
 
-/// Load OAuth token for a provider from the database
-#[allow(dead_code)]
-async fn get_oauth_token<C: Connection>(
-    db: &Surreal<C>,
-    user_id: &UserId,
-    provider: &str,
-) -> Result<Option<OAuthToken>, CoreError> {
-    // Query for OAuth token belonging to this user and provider
-    let query = r#"
-        SELECT * FROM oauth_token
-        WHERE owner_id = $user_id
-        AND provider = $provider
-        ORDER BY last_used_at DESC
-        LIMIT 1
-    "#;
-
-    // Clone to avoid borrow issues
-    let user_id = user_id.clone();
-    let provider = provider.to_string();
-
-    let mut result = db
-        .query(query)
-        .bind(("user_id", RecordId::from(user_id.clone())))
-        .bind(("provider", provider.clone()))
-        .await
-        .map_err(|e| CoreError::DatabaseQueryFailed {
-            query: query.to_string(),
-            table: "oauth_token".to_string(),
-            cause: e,
-        })?;
-
-    let tokens: Vec<<OAuthToken as DbEntity>::DbModel> =
-        result.take(0).map_err(|e| CoreError::DatabaseQueryFailed {
-            query: query.to_string(),
-            table: "oauth_token".to_string(),
-            cause: e,
-        })?;
-
-    let mut tokens = tokens
-        .into_iter()
-        .map(|tok| OAuthToken::from_db_model(tok).expect("should be the db model"));
-
-    let token = tokens.next();
-
-    if token.is_none() {
-        tracing::info!(
-            "No OAuth token found for user {} provider {}",
-            user_id,
-            provider
-        );
-    } else {
-        tracing::info!(
-            "Found OAuth token for user {} provider {}",
-            user_id,
-            provider
-        );
-    }
-
-    Ok(token)
-}
-
 /// Builder for creating a genai client with OAuth support
 pub struct OAuthClientBuilder<C: Connection> {
     db: Arc<Surreal<C>>,