Skip to content
Python
7.3 KB
Raw Blame
#![cfg(all(feature = "test-support", feature = "attachments"))]
use openworker_sdk::{agents::*, *};
use serde_json::Value;
use std::{
    path::PathBuf,
    sync::{Arc, Mutex},
    time::Duration,
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
async fn exercise(managed: bool, small_stack: bool) {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let url = format!("http://{}/v1", listener.local_addr().unwrap());
    let requests = Arc::new(Mutex::new(vec![]));
    let captured = requests.clone();
    let server = tokio::spawn(async move {
        for _ in 0..3 {
            let (mut socket, _) = listener.accept().await.unwrap();
            let mut raw = vec![];
            let mut buffer = [0; 8192];
            let end = loop {
                let n = socket.read(&mut buffer).await.unwrap();
                assert!(n > 0);
                raw.extend_from_slice(&buffer[..n]);
                if let Some(i) = raw.windows(4).position(|b| b == b"\r\n\r\n") {
                    break i + 4;
                }
            };
            let len = String::from_utf8_lossy(&raw[..end])
                .lines()
                .find_map(|l| {
                    l.to_lowercase()
                        .strip_prefix("content-length:")
                        .map(|v| v.trim().parse::<usize>().unwrap())
                })
                .unwrap();
            assert!(len < 2_000_000);
            while raw.len() < end + len {
                let n = socket.read(&mut buffer).await.unwrap();
                assert!(n > 0);
                raw.extend_from_slice(&buffer[..n]);
            }
            let body: Value = serde_json::from_slice(&raw[end..end + len]).unwrap();
            captured.lock().unwrap().push(body);
            let response="data: {\"id\":\"fixture\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Read.\"},\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n";
            socket.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",response.len(),response).as_bytes()).await.unwrap();
        }
    });
    let root = tempfile::tempdir().unwrap();
    let original = PathBuf::from(env!("CARGO_BIN_EXE_sdk-test-host"));
    let binary = if small_stack {
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let path = root.path().join("small-stack-host");
            let quoted = original.to_str().unwrap().replace('\'', "'\\''");
            std::fs::write(
                &path,
                format!("#!/bin/sh\nulimit -s 1024\nexec '{quoted}' \"$@\"\n"),
            )
            .unwrap();
            std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap();
            path
        }
        #[cfg(not(unix))]
        {
            panic!("Process-stack wrapper is Unix-only")
        }
    } else {
        original.clone()
    };
    let builder = || {
        Harness::builder()
            .state_dir(root.path())
            .executable(&original)
            .sandbox(Sandbox::Off)
    };
    let harness = if managed {
        builder()
            .managed(binary.clone(), RestartPolicy::default())
            .await
    } else {
        builder().start().await
    }
    .unwrap();
    harness
        .set_model_provider(ModelProvider::chat_completions("Fixture").base_url(url.clone()))
        .await
        .unwrap();
    let definition = || {
        Agent::new("reader")
            .instructions("Read attached files.")
            .tools([] as [&str; 0])
            .memory(false)
            .planning(false)
            .scheduling(false)
            .default_model(Model::new("Fixture", "fixture"))
    };
    let session = harness
        .create_agent(definition())
        .await
        .unwrap()
        .new_session()
        .await
        .unwrap();
    let document = Attachment::from_bytes("notes.md", "text/plain", vec![65; 300000]).unwrap();
    let input = UserInput::new(vec![
        InputContent::text("Before"),
        document.clone().into(),
        InputContent::text("After"),
    ]);
    let stream = session.run_input_streamed(input.clone()).await.unwrap();
    let mut stream = stream;
    let mut deltas = String::new();
    while let Some(e) = stream.next().await {
        if let RunEvent::TextDelta { text, .. } = e {
            deltas.push_str(&text);
        }
    }
    assert_eq!(stream.finish().await.unwrap().status, RunStatus::Completed);
    assert_eq!(deltas, "Read.");
    let request = requests.lock().unwrap()[0].clone();
    let parts = &request["messages"][1]["content"];
    assert_eq!(parts[0]["text"], "Before");
    assert!(parts[1]["text"]
        .as_str()
        .unwrap()
        .starts_with("Attached text file: notes.md\n"));
    assert_eq!(parts[2]["text"], "After");
    let run = session
        .send_input(
            input.clone(),
            TurnOptions {
                submission_id: Some("same".into()),
                ..Default::default()
            },
        )
        .await
        .unwrap();
    assert_eq!(run.result().await.unwrap().status, RunStatus::Completed);
    assert_eq!(
        session
            .send_input(
                input,
                TurnOptions {
                    submission_id: Some("same".into()),
                    ..Default::default()
                }
            )
            .await
            .unwrap()
            .result()
            .await
            .unwrap()
            .status,
        RunStatus::Completed
    );
    assert_eq!(requests.lock().unwrap().len(), 2);
    assert!(session
        .send_input(
            UserInput::new(vec![InputContent::text("different")]),
            TurnOptions {
                submission_id: Some("same".into()),
                ..Default::default()
            }
        )
        .await
        .is_err());
    let reference = session.reference().clone();
    harness.shutdown().await.unwrap();
    drop(session);
    drop(harness);
    let harness = if managed {
        builder()
            .managed(binary.clone(), RestartPolicy::default())
            .await
    } else {
        builder().start().await
    }
    .unwrap();
    harness
        .set_model_provider(ModelProvider::chat_completions("Fixture").base_url(url))
        .await
        .unwrap();
    harness.create_agent(definition()).await.unwrap();
    let resumed = harness.resume(reference).await.unwrap();
    assert_eq!(
        resumed.run("Continue").await.unwrap().status,
        RunStatus::Completed
    );
    assert_eq!(
        requests.lock().unwrap()[2]["messages"][1]["content"],
        *parts
    );
    harness.shutdown().await.unwrap();
    server.await.unwrap();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn attachments_work_in_process_and_managed_subprocess() {
    tokio::time::timeout(Duration::from_secs(120), async {
        exercise(false, false).await;
        exercise(true, false).await
    })
    .await
    .unwrap();
}

/// Reproduce the small Windows process-main stack on Unix using an owned
/// wrapper. The normal native Windows test already exercises its real stack.
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn managed_attachments_fit_a_small_host_stack() {
    tokio::time::timeout(Duration::from_secs(120), exercise(true, true))
        .await
        .unwrap();
}