Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Merge remote-tracking branch 'origin/rcc/telemetry' into integration/dori-cleanroom

YeonGyu-Kim164bd518a1c0
diff --cc rust/crates/api/tests/client_integration.rs
index dcaf4f66,6bb1c0f9..bdccbdd1
--- a/rust/crates/api/tests/client_integration.rs
+++ b/rust/crates/api/tests/client_integration.rs
@@@ -3,11 -3,12 +3,12 @@@ use std::sync::Arc
use std::time::Duration;
use api::{
- AnthropicClient, ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
- InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OutputContentBlock,
- StreamEvent, ToolChoice, ToolDefinition,
+ ApiClient, ApiError, AuthSource, ContentBlockDelta, ContentBlockDeltaEvent,
+ ContentBlockStartEvent, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
+ OutputContentBlock, ProviderClient, StreamEvent, ToolChoice, ToolDefinition,
};
use serde_json::json;
+ use telemetry::{ClientIdentity, MemoryTelemetrySink, SessionTracer, TelemetryEvent};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::sync::Mutex;
diff --cc rust/crates/runtime/src/conversation.rs
index 15f32626,d44fb90b..14a8133c
--- a/rust/crates/runtime/src/conversation.rs
+++ b/rust/crates/runtime/src/conversation.rs
@@@ -266,9 -167,11 +269,11 @@@ wher
user_input: impl Into<String>,
mut prompter: Option<&mut dyn PermissionPrompter>,
) -> Result<TurnSummary, RuntimeError> {
+ let user_input = user_input.into();
+ self.record_turn_started(&user_input);
self.session
- .messages
- .push(ConversationMessage::user_text(user_input));
+ .push_user_text(user_input.into())
+ .map_err(|error| RuntimeError::new(error.to_string()))?;
let mut assistant_messages = Vec::new();
let mut tool_results = Vec::new();
@@@ -301,10 -218,13 +320,15 @@@
_ => None,
})
.collect::<Vec<_>>();
+ self.record_assistant_iteration(
+ iterations,
+ &assistant_message,
+ pending_tool_uses.len(),
+ );
- self.session.messages.push(assistant_message.clone());
+ self.session
+ .push_message(assistant_message.clone())
+ .map_err(|error| RuntimeError::new(error.to_string()))?;
assistant_messages.push(assistant_message);
if pending_tool_uses.is_empty() {
@@@ -808,10 -801,9 +865,10 @@@ mod tests
}),
PermissionPolicy::new(PermissionMode::DangerFullAccess),
vec!["system".to_string()],
- RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
+ &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
vec![shell_snippet("printf 'blocked by hook'; exit 2")],
Vec::new(),
+ Vec::new(),
)),
);
@@@ -875,10 -867,9 +932,10 @@@
StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
PermissionPolicy::new(PermissionMode::DangerFullAccess),
vec!["system".to_string()],
- RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
+ &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
vec![shell_snippet("printf 'pre hook ran'")],
vec![shell_snippet("printf 'post hook ran'")],
+ Vec::new(),
)),
);
diff --cc rust/crates/runtime/src/hooks.rs
index 739065d6,f2187681..77f84710
--- a/rust/crates/runtime/src/hooks.rs
+++ b/rust/crates/runtime/src/hooks.rs
@@@ -476,132 -200,22 +476,141 @@@ impl HookRunner
}
}
+ struct HookInvocation<'a> {
+ event: HookEvent,
+ tool_name: &'a str,
+ tool_input: &'a str,
+ tool_output: Option<&'a str>,
+ is_error: bool,
+ payload: &'a str,
+ }
+
enum HookCommandOutcome {
- Allow { message: Option<String> },
- Deny { message: Option<String> },
+ Allow { parsed: ParsedHookOutput },
+ Deny { parsed: ParsedHookOutput },
Warn { message: String },
+ Cancelled { message: String },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+struct ParsedHookOutput {
+ messages: Vec<String>,
+ deny: bool,
+ permission_override: Option<PermissionOverride>,
+ permission_reason: Option<String>,
+ updated_input: Option<String>,
+}
+
+impl ParsedHookOutput {
+ fn with_fallback_message(mut self, fallback: String) -> Self {
+ if self.messages.is_empty() {
+ self.messages.push(fallback);
+ }
+ self
+ }
+
+ fn primary_message(&self) -> Option<&str> {
+ self.messages.first().map(String::as_str)
+ }
+}
+
+fn merge_parsed_hook_output(target: &mut HookRunResult, parsed: ParsedHookOutput) {
+ target.messages.extend(parsed.messages);
+ if parsed.permission_override.is_some() {
+ target.permission_override = parsed.permission_override;
+ }
+ if parsed.permission_reason.is_some() {
+ target.permission_reason = parsed.permission_reason;
+ }
+ if parsed.updated_input.is_some() {
+ target.updated_input = parsed.updated_input;
+ }
}
-fn parse_tool_input(tool_input: &str) -> serde_json::Value {
+fn parse_hook_output(stdout: &str) -> ParsedHookOutput {
+ if stdout.is_empty() {
+ return ParsedHookOutput::default();
+ }
+
+ let Ok(Value::Object(root)) = serde_json::from_str::<Value>(stdout) else {
+ return ParsedHookOutput {
+ messages: vec![stdout.to_string()],
+ ..ParsedHookOutput::default()
+ };
+ };
+
+ let mut parsed = ParsedHookOutput::default();
+
+ if let Some(message) = root.get("systemMessage").and_then(Value::as_str) {
+ parsed.messages.push(message.to_string());
+ }
+ if let Some(message) = root.get("reason").and_then(Value::as_str) {
+ parsed.messages.push(message.to_string());
+ }
+ if root.get("continue").and_then(Value::as_bool) == Some(false)
+ || root.get("decision").and_then(Value::as_str) == Some("block")
+ {
+ parsed.deny = true;
+ }
+
+ if let Some(Value::Object(specific)) = root.get("hookSpecificOutput") {
+ if let Some(Value::String(additional_context)) = specific.get("additionalContext") {
+ parsed.messages.push(additional_context.clone());
+ }
+ if let Some(decision) = specific.get("permissionDecision").and_then(Value::as_str) {
+ parsed.permission_override = match decision {
+ "allow" => Some(PermissionOverride::Allow),
+ "deny" => Some(PermissionOverride::Deny),
+ "ask" => Some(PermissionOverride::Ask),
+ _ => None,
+ };
+ }
+ if let Some(reason) = specific
+ .get("permissionDecisionReason")
+ .and_then(Value::as_str)
+ {
+ parsed.permission_reason = Some(reason.to_string());
+ }
+ if let Some(updated_input) = specific.get("updatedInput") {
+ parsed.updated_input = serde_json::to_string(updated_input).ok();
+ }
+ }
+
+ if parsed.messages.is_empty() {
+ parsed.messages.push(stdout.to_string());
+ }
+
+ parsed
+}
+
+fn hook_payload(
+ event: HookEvent,
+ tool_name: &str,
+ tool_input: &str,
+ tool_output: Option<&str>,
+ is_error: bool,
+) -> Value {
+ match event {
+ HookEvent::PostToolUseFailure => json!({
+ "hook_event_name": event.as_str(),
+ "tool_name": tool_name,
+ "tool_input": parse_tool_input(tool_input),
+ "tool_input_json": tool_input,
+ "tool_error": tool_output,
+ "tool_result_is_error": true,
+ }),
+ _ => json!({
+ "hook_event_name": event.as_str(),
+ "tool_name": tool_name,
+ "tool_input": parse_tool_input(tool_input),
+ "tool_input_json": tool_input,
+ "tool_output": tool_output,
+ "tool_result_is_error": is_error,
+ }),
+ }
+}
+
+fn parse_tool_input(tool_input: &str) -> Value {
serde_json::from_str(tool_input).unwrap_or_else(|_| json!({ "raw": tool_input }))
}
diff --cc rust/crates/rusty-claude-cli/src/main.rs
index e6d24ca4,41746b37..68c849f9
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@@ -1594,9 -1341,9 +1598,10 @@@ impl LiveCli
let handle = resolve_session_reference(&session_ref)?;
let session = Session::load_from_path(&handle.path)?;
let message_count = session.messages.len();
+ let session_id = session.session_id.clone();
self.runtime = build_runtime(
session,
+ &handle.id,
self.model.clone(),
self.system_prompt.clone(),
true,
@@@ -1683,9 -1414,9 +1688,10 @@@
let handle = resolve_session_reference(target)?;
let session = Session::load_from_path(&handle.path)?;
let message_count = session.messages.len();
+ let session_id = session.session_id.clone();
self.runtime = build_runtime(
session,
+ &handle.id,
self.model.clone(),
self.system_prompt.clone(),
true,
@@@ -3267,10 -2042,13 +3275,15 @@@ impl AnthropicRuntimeClient
enable_tools,
emit_output,
allowed_tools,
+ tool_registry,
+ progress_reporter,
})
}
+
+ fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
+ self.client = self.client.with_session_tracer(session_tracer);
+ self
+ }
}
fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {