text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>pub<|fim_suffix|>_tools::glob_search::*;
<|fim_middle|> use zeroclaw<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zerocla<|fim_suffix|>e_workspace::*;
<|fim_middle|>w_tools::googl<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
pub use zeroclaw_tools::hardware_board_info::*;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_too<|fim_suffix|>_map::*;
<|fim_middle|>ls::hardware_memory<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tools::hardware_m<|fim_suffix|>ry_read::*;
<|fim_middle|>emo<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>::*;
<|fim_prefix|>pub use zeroclaw_tools::http_re<|fim_middle|>quest<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>mage_gen::*;
<|fim_prefix|>pub use zeroclaw_tools:<|fim_middle|>:i<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>info::*;
<|fim_prefix|>p<|fim_middle|>ub use zeroclaw_tools::image_<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>:jira_tool::*;
<|fim_prefix|>pub use zeroclaw_tools<|fim_middle|>:<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_to<|fim_suffix|>edge_tool::*;
<|fim_middle|>ols::knowl<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>kedin::*;
<|fim_prefix|>p<|fim_middle|>ub use zeroclaw_tools::lin<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ent::*;
<|fim_prefix|>pub use zeroclaw_tools<|fim_middle|>::linkedin_cli<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>:*;
<|fim_prefix|>pub use zeroclaw_tools::llm_t<|fim_middle|>ask:<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use <|fim_suffix|>ols::mcp_client::*;
<|fim_middle|>zeroclaw_to<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|><|fim_suffix|>_deferred::*;
<|fim_middle|>pub use zeroclaw_tools::mcp<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|><|fim_suffix|>mcp_protocol::*;
<|fim_middle|>pub use zeroclaw_tools::<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub us<|fim_suffix|>eroclaw_tools::mcp_tool::*;
<|fim_middle|>e z<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|><|fim_suffix|>sport::*;
<|fim_middle|>pub use zeroclaw_tools::mcp_tran<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw<|fim_suffix|>emory_export::*;
<|fim_middle|>_tools::m<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zerocla<|fim_suffix|>forget::*;
<|fim_middle|>w_tools::memory_<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>law_tools::memory_purge::*;
<|fim_prefix|>pub u<|fim_middle|>se zeroc<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|><|fim_suffix|>emory_recall::*;
<|fim_middle|>pub use zeroclaw_tools::m<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ore::*;
<|fim_prefix|>pub use zeroclaw_t<|fim_middle|>ools::memory_st<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>law_runtime::tools::*;
<|fim_prefix|>pu<|fim_middle|>b use zeroc<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|><|fim_prefix|>pub use z<|fim_middle|>eroclaw_tools::model_routing_config::*;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tools::node<|fim_suffix|>:*;
<|fim_middle|>_capabilities:<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tools::not<|fim_suffix|>::*;
<|fim_middle|>ion_tool<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>zeroclaw_tools::opencode_cli::*;
<|fim_prefix|>pub <|fim_middle|>use <|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>s::pdf_read::*;
<|fim_prefix|>pub u<|fim_middle|>se zeroclaw_tool<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_t<|fim_suffix|>;
<|fim_middle|>ools::pipeline::*<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_t<|fim_suffix|>ls::poll::*;
<|fim_middle|>oo<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>::*;
<|fim_prefix|>pub use zerocla<|fim_middle|>w_tools::project_intel<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use z<|fim_suffix|>::proxy_config::*;
<|fim_middle|>eroclaw_tools<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub <|fim_suffix|>w_tools::pushover::*;
<|fim_middle|>use zerocla<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tools<|fim_suffix|>::*;
<|fim_middle|>::reaction<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
pub use zeroclaw_tools::report_template_tool::*;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ools::report_templates::*;
<|fim_prefix|>pub use zer<|fim_middle|>oclaw_t<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>zeroclaw_api::schema::*;
<|fim_prefix|>pub use<|fim_middle|> <|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tool<|fim_suffix|>creenshot::*;
<|fim_middle|>s::s<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>::sessions::*;
<|fim_prefix|>pub use zeroclaw_tool<|fim_middle|>s<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw_tools::<|fim_suffix|>rowser::*;
<|fim_middle|>text_b<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>_search::*;
<|fim_prefix|>pub <|fim_middle|>use zeroclaw_tools::tool<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>her_tool::*;
<|fim_prefix|>p<|fim_middle|>ub use zeroclaw_tools::weat<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>eb_fetch::*;
<|fim_prefix|>pub use z<|fim_middle|>eroclaw_tools::w<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>rovider_routing::*;
<|fim_prefix|>pub use zeroclaw_<|fim_middle|>tools::web_search_p<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
pub use zeroclaw_tools::web_search_tool::*;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
pub use zeroclaw_tools::wrappers::*;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>me::trust::*;
<|fim_prefix|>#[allo<|fim_middle|>w(unused_imports)]
pub use zeroclaw_runti<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>me(), "ngrok");
assert!(t.public_url().is_none());
}
#[test]
fn ngrok_with_domain() {
let t = NgrokTunnel::new("tok".into(), Some("my.ngrok.io".into()));
assert_eq!(t.name(), "ngrok");
}
#[test]
fn custom_tunnel_name() {
let t = CustomTunnel::new("... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>pub use zeroclaw<|fim_suffix|>::util::*;
<|fim_middle|>_runtime<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>aw_runtime::verifiable_intent::*;
<|fim_prefix|>pub use z<|fim_middle|>erocl<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Architecture gate: user-facing strings must route through Fluent, not ship
//! as bare literals. A PR that adds an un-localized user-facing string fails
//! this test (and therefore CI), so it can never land.
//!
//! Two classes are caught in `src/` (the user-facing CLI surface):
//! 1. `clap` help ... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>+ offset,
line.trim()
));
}
}
}
}
<|fim_prefix|>//! Architecture gate: tests that persist `Config` must isolate the target
//! path. `Config::default()` targets the real ~/.zeroclaw, so an
//! unisolated save clobbers the developer's live config.... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Architecture gate: forbid duplicate-state patterns across the codebase.
//!
//! See `AGENTS.md` β "ABSOLUTE RULE β SINGLE SOURCE OF TRUTH". This test
//! catches the patterns most likely to drift back into the codebase: peer
//! authorization caches on channel handles, snapshot copies of Config
//! fi... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ope["message"]
.as_str()
.expect("message")
.contains("gateway.host must not be empty"),
"message should describe validation failure: {envelope}"
);
}
<|fim_prefix|>//! Regression coverage for `zeroclaw config patch --json` error output.
use axum::{Router, ... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>() {
let mut config = Config::default();
config.memory.embedding_provider = "openai".into();
config.memory.embedding_model = "text-embedding-3-small".into();
config.memory.vector_weight = 0.8;
config.memory.keyword_weight = 0.2;
let toml_str = toml::to_string(&config).expect("conf... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Config Schema Boundary Tests
//!
//! Validates: config defaults, backward compatibility, invalid input rejection,
//! and gateway/security/agent config boundary conditions.
use zeroclaw::config::migration;
use zeroclaw::config::{ChannelsConfig, Config, GatewayConfig, RiskProfileConfig, SecurityConfig... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ew(env!("CARGO_MANIFEST_DIR")).join(".dockerignore");
let content = tokio::fs::read_to_string(&path)
.await
.expect("Failed to read .dockerignore");
let patterns = parse_dockerignore(&content);
assert!(
is_excluded(&patterns, ".github"),
".github must be exclud... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|> zeroclaw::gateway::RATE_LIMIT_WINDOW_SECS,
60,
"Rate limit window should be 60 seconds"
);
}
<|fim_prefix|>//! Gateway component tests.
//!
//! Tests public gateway infrastructure (rate limiter, idempotency, signature
//! verification) in isolation. The gateway module (`zeroclaw::gate... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>;
}
#[test]
fn gemini_supports_vision_returns_true() {
let model_provider = gemini_model_provider();
assert!(model_provider.supports_vision());
}
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Tool conversion contract
// ββββββββββββββββββββββββββββββββββββββ... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>mod config_persistence;
mod <|fim_suffix|>mod whatsapp_webhook_security;
<|fim_middle|>config_schema;
mod dockerignore_test;
mod gateway;
mod gemini_capabilities;
mod otel_dependency_feature_regression;
mod provider_resolution;
mod provider_schema;
mod reply_target_field_regression;
mod security;
<|endoft... | fim | zeroclaw-labs/zeroclaw | rust |
#[test]
fn opentelemetry_otlp_uses_blocking_reqwest_client() {
// opentelemetry-otlp lives in zeroclaw-runtime (moved from root during workspace split)
let manifest = include_str!("../../crates/zeroclaw-runtime/Cargo.toml");
let otlp_line = manifest
.lines()
.find(|line: &&str| line.trim_sta... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|> assert!(
result.is_ok(),
"convenience factory should resolve {provider_name}: {}",
result.err().map(|e| e.to_string()).unwrap_or_default()
);
}
}
#[test]
fn convenience_factory_ollama_no_key() {
let result = create_model_provider("ollama", None);
... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>"assistant");
// Verify tool message content is valid JSON with tool_call_id
let tool_content: serde_json::Value = serde_json::from_str(&history[3].content).unwrap();
assert!(tool_content.get("tool_call_id").is_some());
}
<|fim_prefix|>//! TG7: ModelProvider Schema Conformance Tests
//!
//! P... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>line_idx + 1,
line.trim()
));
}
}
}
}
assert!(
violations.is_empty(),
"Found legacy `reply_to` field usage:\n{}",
violations.join("\n")
);
}
<|fim_prefix|>//! Regression guard for ChannelMe... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>pect("Failed to serialize");
// Override the level to readonly
toml_str = toml_str.replace("level = \"supervised\"", "level = \"readonly\"");
let config: RiskProfileConfig = toml::from_str(&toml_str).expect("Failed to parse readonly");
assert_eq!(format!("{:?}", config.level), "ReadOnly");... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>pute_signature(secret, body);
assert!(zeroclaw::gateway::verify_whatsapp_signature(
secret, body, &valid_sig
));
}
#[test]
fn whatsapp_signature_rejects_tampered_body() {
let secret = "test_app_secret";
let original_body = b"original message";
let tampered_body = b"tampered m... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! End-to-end integration tests for agent orchestration.
//!
//! These tests exercise the full agent turn cycle through the public API,
//! using mock model_providers and tools to validate orchestration behavior without
//! external service dependencies. They complement the unit tests in
//! `src/agent/t... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! TG4: Agent Loop Robustness Tests
//!
//! Prevents: Pattern 4 β Agent loop & tool call processing bugs (13% of user bugs).
//! Issues: #746, #418, #777, #848
//!
//! Tests agent behavior with malformed tool calls, empty responses,
//! max iteration limits, and cascading tool failures using mock model_p... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>use std::collections::HashMap;
use tempfile::TempDir;
use zeroclaw::config::Config;
use zeroclaw::config::schema::{AliasedAgentConfig, CronJobDecl, CronScheduleDecl};
use zeroclaw::cron::{JobType, Schedule, get_job, list_jobs, sync_declarative_jobs};
/// Test fixture: configures a cron-scheduled backup a... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Channel Matrix β comprehensive capability coverage tests.
//!
//! Validates every channel implementation against the full `Channel` trait
//! contract, covering: identity semantics, threading, default methods,
//! capability declarations, cross-channel parity, and edge cases.
//!
//! This matrix ensur... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>0].recipient, "test_target",
"reply should use reply_target as recipient"
);
}
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Channel trait default methods
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
#[tokio::test]
asy... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>use mail_parser::{MessageParser, MimeHeaders};
use zeroclaw::channels::SendMessage;
use zeroclaw::channels::media_pipeline::MediaAttachment;
/// Test that extract_attachments correctly parses binary attachments from multipart MIME
#[test]
fn extract_attachments_from_multipart_email() {
// Construct a... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>use async_trait::async_trait;
use<|fim_suffix|>}
}
}
#[tokio::test]
async fn hook_runner_full_pipeline() {
let gateway_starts = Arc::new(AtomicUsize::new(0));
let tool_calls = Arc::new(AtomicUsize::new(0));
let mut runner = HookRunner::new();
runner.register(Box::new(CounterHook {
... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>());
assert!(!md_all.is_empty());
}
<|fim_prefix|>//! Head-to-head comparison: SQLite vs Markdown memory backends
//!
//! Run with: cargo test --test memory_comparison -- --nocapture
use std::time::Instant;
use tempfile::TempDir;
// We test both backends through the public memory module
use zeroclaw... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! End-to-end tests for memoryβloopβheartbeat continuity.
//!
//! Validates that:
//! - Memory persists across agent turns and sessions
//! - The agent loop maintains context awareness through tool iterations
//! - Memory recall enriches prompts so the agent "remembers" prior work
//! - Context compressi... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Session scoping: messages scoped to sessions don't leak
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
#[tokio::test]
async fn sqlite_memory_session_scoped_store_and_recall() {
let tmp = tempfile... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>mod agent;
mod agent_robustness;
mod backup_cron_scheduling;
mod channel_matrix;
mod channel_routing;
mod email_attachments;
mod hooks;
mod memory_comparison;
mod memory_loop_continuity;
mod memory_restart;
mod report_template_too<|fim_suffix|>lback;
mod telegram_finalize_draft;
<|fim_middle|>l_test;
mod ... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Integration tests for ReportTemplateTool.
use serde_json::json;
use zeroclaw::tools::{ReportTemplateTool, Tool};
#[tokio::test]
async fn render_weekly_status_en() {
let tool = ReportTemplateTool::new();
let params = json!({
"template": "weekly_status",
"language": "en",
... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Regression tests for Telegram attachment fallback behavior.
//!
//! When sending media by URL fails (e.g. Telegram can't fetch the URL or the
//! content type is wrong), the channel should fall back to sending the URL as
//! a text link instead of losing the entire reply.
//!
//! Bug: Previously, `sen... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|> .expect(1)
.mount(&server)
.await;
let channel = test_channel(&server.uri());
let result = channel.finalize_draft("123", "42", "final text").await;
assert!(
result.is_ok(),
"successful delete should allow safe sendMessage fallback, got: {result:?}"
... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>le.get("refresh_token").is_none() {
eprintln!("β οΈ Gemini profile has no refresh_token β cannot test refresh");
return Ok(());
}
println!("β Gemini profile has refresh_token");
// Backup original expires_at
let original_expires_at = gemini_profile.get("expires_at").cloned... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>mod gemini_fallback_oauth_refresh;
mod openai_codex_vision_e<|fim_suffix|>mod zai_jwt_auth;
<|fim_middle|>2e;
mod providers;
<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|> Create minimal PNG if missing
use base64::{Engine as _, engine::general_purpose};
let png_data = general_purpose::STANDARD.decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
)?;
std::fs::write(test_image, ... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>, "Turn 2 failed: {:?}", response2.err());
let r2 = response2.unwrap().to_lowercase();
assert!(
r2.contains("zephyr"),
"Model should recall 'zephyr' from history, got: {r2}",
);
}
<|fim_prefix|>//! Consolidated live model_provider tests.
//!
//! All tests in this module require... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Live test for Z.AI JWT authentication.
//!
//! Verifies that the ZhipuJwt auth style correctly generates a JWT token
//! and authenticates against the real Z.AI API.
//!
//! Requires `ZAI_API_KEY` env var set (format: `id.secret`).
//! Run: `ZAI_API_KEY=... cargo test live_zai -- --ignored --nocapture... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>t message (< 100 chars)")
print(" medium - Medium message (~1000 chars)")
print(" long - Long message (~5000 chars, requires splitting)")
print(" exact - Exactly 4096 chars")
print(" over - Just over 4096 chars")
print(" multi - Very l... | fim | zeroclaw-labs/zeroclaw | python |
<|fim_prefix|>//! Declarative expectation verification for trace fixtures.
use super::trace::TraceExpects;
/// Verify trace expectations against actual test results.
///
/// - `expects`: declarative expectations from the trace fixture
/// - `final_response`: the final text response from the agent
/// - `tools_called`... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Shared builder helpers for constructing test agents.
use anyhow::Result;
use async_trait::async_trait;
use std::sync::Arc;
use zeroclaw::agent::agent::Agent;
use zeroclaw::agent::dispatcher::{NativeToolDispatcher, XmlToolDispatcher};
use zeroclaw::config::MemoryConfig;
use zeroclaw::memory;
use zeroc... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Mock channel for system-level tests.
//!
//! `TestChannel` implements the `Channel` trait with MPSC-based message
//! injection and response capture for race-free testing.
use async_trait::async_trait;
use std::sync::{Arc, Mutex};
use zeroclaw::channels::{Channel, ChannelMessage, SendMessage};
/// A... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>(trace: &LlmTrace) -> Self {
let mut steps = Vec::new();
for turn in &trace.turns {
for step in &turn.steps {
steps.push(step.response.clone());
}
}
Self {
steps: Mutex::new(steps),
trace_name: trace.model_name... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>external service.
pub struct FailingTool;
#[async_trait]
impl Tool for FailingTool {
fn name(&self) -> &str {
"failing_tool"
}
fn description(&self) -> &str {
"Always fails"
}
fn parameters_schema(&self) -> serde_json::Value {
json!({"type": "object"})
}
... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>#![allow(dead_code, unused_imports)]
pub mod assertions;
pub mod helpers;
pub mod mock_channel;
pub mod mock_model_provider;
pub mod mock_tools;
pub mod trace;
pub use mock_model_provider::<|fim_suffix|>Tool, RecordingTool};
<|fim_middle|>{MockModelProvider, RecordingModelProvider};
pub use mock_tools::... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>]
pub expects: TraceExpects,
}
/// A single conversation turn (user input + LLM response steps).
#[derive(Debug, Deserialize)]
pub struct TraceTurn {
pub user_input: String,
pub steps: Vec<TraceStep>,
}
/// A single LLM response step within a turn.
#[derive(Debug, Deserialize)]
pub struct Tr... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>rn("run both tools").await.unwrap();
assert_eq!(response, "Both tools completed");
assert_eq!(*count.lock().unwrap(), 1, "Counter should be invoked once");
}
<|fim_prefix|>//! System-level tests β full agent orchestration with real components.
//!
//! These tests wire ALL internal components toget... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|>_e2e;
<|fim_prefix|>mod full_stack;
m<|fim_middle|>od multi_agent<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_suffix|> );
let dev = tool
.execute(json!({
"channel": "telegram.dev",
"target": "beta",
"message": "hi"
}))
.await
.expect("execute returns Ok with structured failure");
assert!(
!dev.success,
"sibling alias dispatch mu... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>//! Workspace architecture-invariant test entry. Each submodule here is a
//! detector that fails the workspace test suite when the corresponding
//! invariant is violated. See AGENTS.md Β§1 ("ABSOLUTE RULE β SINGLE
//! SOURCE OF TRUT<|fim_suffix|>ent_coverage;
<|fim_middle|>H") for context on why these ga... | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>mod componen<|fim_suffix|>upport;
<|fim_middle|>t;
mod s<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
<|fim_prefix|>mod integration;<|fim_suffix|>;
<|fim_middle|>
mod support<|endoftext|> | fim | zeroclaw-labs/zeroclaw | rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.