Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! Prompt validation and generation-to-static-file orchestration.
use super::models::{
GenerateImageError, ImageGenerationError, ImageGenerationRequest, MAX_PROMPT_BYTES,
MAX_REFERENCE_BYTES, MAX_REFERENCE_IMAGES, NewGeneratedImage, NewStaticImage,
StoredGeneratedImage,
};
use super::ports::{
ImageGenerationService, ImageGenerator, ImageMarkdownComposer, ImageReferenceReader,
ImageStore, UnconfiguredImageReferenceReader,
};
use ai_billing::AiAdmissionService;
use ai_usage::{AiFeature, UsageContext, UsageRecorder};
use model_owner::CreationPrincipal;
use std::sync::Arc;
#[cfg(test)]
mod test;
/// Image generation use case composed from a provider, static file store, and markup composer.
pub struct ImageGenerationServiceImpl<Store, References = UnconfiguredImageReferenceReader> {
generator: Arc<dyn ImageGenerator>,
store: Store,
composer: Arc<dyn ImageMarkdownComposer>,
references: References,
recorder: Arc<dyn UsageRecorder>,
}
impl<Store> ImageGenerationServiceImpl<Store> {
/// Compose the provider, image-saving capability, and markup serializer.
pub fn new(
generator: Arc<dyn ImageGenerator>,
store: Store,
composer: Arc<dyn ImageMarkdownComposer>,
recorder: Arc<dyn UsageRecorder>,
) -> Self {
Self {
generator,
store,
composer,
references: UnconfiguredImageReferenceReader,
recorder,
}
}
}
impl<Store, References> ImageGenerationServiceImpl<Store, References> {
/// Enable reference photos using the owning domains' read capabilities.
pub fn with_reference_reader<R>(self, references: R) -> ImageGenerationServiceImpl<Store, R> {
ImageGenerationServiceImpl {
generator: self.generator,
store: self.store,
composer: self.composer,
references,
recorder: self.recorder,
}
}
}
impl<Store: ImageStore, References: ImageReferenceReader> ImageGenerationService
for ImageGenerationServiceImpl<Store, References>
{
/// Generate an image and store it through the image-saving port.
#[tracing::instrument(skip_all, err)]
async fn create_generated_image(
&self,
principal: &CreationPrincipal,
image: NewGeneratedImage,
) -> Result<StoredGeneratedImage, GenerateImageError> {
let NewGeneratedImage {
prompt,
aspect_ratio,
reference_images,
} = image;
let prompt = prompt.trim();
if prompt.is_empty() {
return Err(GenerateImageError::BadRequest(
"prompt must not be empty".to_string(),
));
}
if prompt.len() > MAX_PROMPT_BYTES {
return Err(GenerateImageError::BadRequest(format!(
"prompt exceeds the {MAX_PROMPT_BYTES} byte limit"
)));
}
if reference_images.len() > MAX_REFERENCE_IMAGES {
return Err(GenerateImageError::BadRequest(format!(
"referenceImages accepts at most {MAX_REFERENCE_IMAGES} images"
)));
}
let mut references = Vec::with_capacity(reference_images.len());
let mut reference_bytes = 0;
for reference in &reference_images {
let image = self.references.read_image(principal, reference).await?;
if image.bytes.is_empty()
|| !matches!(
image.mime_type.as_str(),
"image/png" | "image/jpeg" | "image/webp"
)
{
return Err(GenerateImageError::BadRequest(
"referenceImages must contain readable PNG, JPEG, or WebP images".to_string(),
));
}
if image.bytes.len() > MAX_REFERENCE_BYTES - reference_bytes {
return Err(GenerateImageError::BadRequest(
"reference images exceed the 12 MiB total limit; use smaller images"
.to_string(),
));
}
reference_bytes += image.bytes.len();
references.push(image);
}
let usage = match principal.user() {
Some(user) => UsageContext::new(AiFeature::ImageGeneration, user.clone()),
None => UsageContext::system(AiFeature::ImageGeneration),
};
let generated = self
.generator
.generate_image(
&ImageGenerationRequest {
prompt: prompt.to_string(),
aspect_ratio,
reference_images: references,
},
&usage,
self.recorder.as_ref(),
)
.await?;
generated.file_type().ok_or_else(|| {
ImageGenerationError::Provider(anyhow::anyhow!(
"provider returned an unsupported image type {}",
generated.mime_type
))
})?;
if generated.bytes.is_empty() {
return Err(ImageGenerationError::Provider(anyhow::anyhow!(
"provider returned an empty image"
))
.into());
}
let size_bytes = generated.bytes.len();
let static_file = self
.store
.save_image(NewStaticImage {
mime_type: generated.mime_type.clone(),
bytes: generated.bytes,
})
.await?;
let markdown = self
.composer
.compose_image(&static_file, generated.width, generated.height)
.await?;
Ok(StoredGeneratedImage {
markdown,
static_file,
mime_type: generated.mime_type,
size_bytes,
width: generated.width,
height: generated.height,
note: generated.note,
})
}
}
/// Admits each request against the acting user's AI allowance before
/// generating. Hosts that call the use case outside an admitted agent turn,
/// such as the public HTTP API, compose this around the plain service.
pub struct AdmittedImageGenerationService<Svc> {
service: Arc<Svc>,
admission: Arc<dyn AiAdmissionService>,
}
impl<Svc> AdmittedImageGenerationService<Svc> {
/// Gate `service` behind `admission`.
pub fn new(service: Arc<Svc>, admission: Arc<dyn AiAdmissionService>) -> Self {
Self { service, admission }
}
}
impl<Svc: ImageGenerationService> ImageGenerationService for AdmittedImageGenerationService<Svc> {
#[tracing::instrument(name = "image_generation.admit", skip_all, err)]
async fn create_generated_image(
&self,
principal: &CreationPrincipal,
image: NewGeneratedImage,
) -> Result<StoredGeneratedImage, GenerateImageError> {
let user = principal.user().ok_or(GenerateImageError::UserRequired)?;
self.admission
.admit(user, AiFeature::ImageGeneration)
.await?;
self.service.create_generated_image(principal, image).await
}
}