mirror of
https://github.com/langbot-app/LangBot.git
synced 2026-10-26 18:35:38 +08:00
234 lines
10 KiB
Python
234 lines
10 KiB
Python
"""Runner-owned Box selection over Host-owned execution and file services."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import copy
|
|
import base64
|
|
import hashlib
|
|
import uuid
|
|
from dataclasses import dataclass, field, replace
|
|
|
|
from langbot_plugin.api.entities.builtin.platform import message as pm
|
|
from langbot_plugin.api.entities.builtin.runner.box import BoxAcquireRequest
|
|
from langbot_plugin.box.errors import BoxValidationError
|
|
|
|
|
|
@dataclass
|
|
class RunBoxBinding:
|
|
run_id: str
|
|
session_id: str
|
|
spec: dict
|
|
io_scope: str
|
|
imported: dict = field(default_factory=dict)
|
|
exported: dict = field(default_factory=dict)
|
|
submitted: set = field(default_factory=set)
|
|
lock: asyncio.Lock = field(default_factory=asyncio.Lock)
|
|
|
|
|
|
def prepare_input_files(query, agent_input):
|
|
"""Retain provider inputs and issue references without downloading files.
|
|
|
|
Only platform-origin components may carry a Host-local path. A path in an
|
|
event envelope is metadata, never permission to read the Host filesystem.
|
|
"""
|
|
from langbot_plugin.api.entities.builtin.runner.input import InputAttachment
|
|
from ..agent.runner.query_entry_adapter import QueryEntryAdapter
|
|
|
|
originals = input_files(query)
|
|
if not agent_input.attachments:
|
|
agent_input.attachments = [
|
|
InputAttachment.model_validate(item)
|
|
for item in QueryEntryAdapter._build_attachments(query, [c.model_dump() for c in agent_input.contents])
|
|
]
|
|
components = []
|
|
for i, attachment in enumerate(agent_input.attachments):
|
|
kind = (attachment.type or 'file').lower()
|
|
fields = {'url': attachment.url or '', 'base64': attachment.content or ''}
|
|
cls = {'image': pm.Image, 'voice': pm.Voice}.get(kind, pm.File)
|
|
if cls is pm.File:
|
|
fields.update(name=attachment.name or '', id=attachment.id or '')
|
|
component = cls(**fields)
|
|
# Match by payload, never by list position (contents and message chains
|
|
# can describe attachments in different orders).
|
|
for original in originals:
|
|
if type(original) is not cls:
|
|
continue
|
|
if (
|
|
(attachment.url and attachment.url == original.url)
|
|
or (attachment.content and attachment.content == original.base64)
|
|
or (
|
|
attachment.id
|
|
and attachment.id
|
|
== getattr(original, 'id', getattr(original, 'image_id', getattr(original, 'voice_id', None)))
|
|
)
|
|
or (
|
|
not attachment.url
|
|
and not attachment.content
|
|
and not attachment.id
|
|
and attachment.name
|
|
and attachment.name == getattr(original, 'name', None)
|
|
)
|
|
):
|
|
component = original
|
|
break
|
|
components.append(component)
|
|
attachment.ref, attachment.path = f'attachment-{i}', None
|
|
object.__setattr__(query, '_box_inputs', components)
|
|
|
|
|
|
def input_files(query):
|
|
prepared = getattr(query, '_box_inputs', None)
|
|
if prepared is not None:
|
|
return prepared
|
|
return [c for c in query.message_chain or [] if isinstance(c, (pm.Image, pm.Voice, pm.File))]
|
|
|
|
|
|
def binding_for(query) -> RunBoxBinding:
|
|
binding = getattr(query, '_box_binding', None)
|
|
if not isinstance(binding, RunBoxBinding):
|
|
raise BoxValidationError('Runner must bind a Box before using sandbox tools or files')
|
|
return binding
|
|
|
|
|
|
def exported_message(query, file_ids: list[str], *, consume: bool = False) -> pm.MessageChain:
|
|
binding = binding_for(query)
|
|
if not isinstance(file_ids, list) or len(file_ids) > 100 or any(type(x) is not str for x in file_ids):
|
|
raise BoxValidationError('file_ids must contain at most 100 exported file IDs')
|
|
if len(set(file_ids)) != len(file_ids):
|
|
raise BoxValidationError('Duplicate exported file ID')
|
|
if any(key not in binding.exported or key in binding.submitted for key in file_ids):
|
|
raise BoxValidationError('Output file does not belong to this run or has already been submitted')
|
|
components = []
|
|
for key in file_ids:
|
|
item = binding.exported[key]
|
|
if item['type'] == 'Image':
|
|
components.append(pm.Image(base64=item['base64']))
|
|
elif item['type'] == 'Voice':
|
|
components.append(pm.Voice(base64=item['base64']))
|
|
else:
|
|
components.append(pm.File(name=item['name'], base64=item['base64']))
|
|
if consume:
|
|
binding.submitted.update(file_ids)
|
|
return pm.MessageChain(components)
|
|
|
|
|
|
class RunnerBoxService:
|
|
def __init__(self, box):
|
|
self.box = box
|
|
|
|
async def status(self, context):
|
|
status = await self.box.get_status(context)
|
|
capacity = status.get('capacity', {})
|
|
return {
|
|
'enabled': self.box.enabled,
|
|
'available': status.get('available', False),
|
|
'limit': capacity.get('limit'),
|
|
'used': capacity.get('used'),
|
|
'remaining': capacity.get('remaining'),
|
|
'required_reuse_key': 'global' if self.box.managed_admission_required else None,
|
|
'reason': status.get('connector_error'),
|
|
}
|
|
|
|
async def sessions(self, context):
|
|
# Do not hide connection failures behind an empty list.
|
|
context = await self.box.require_workspace_sandbox(context)
|
|
return await self.box.client.get_sessions(action_context=self.box._action_context(context))
|
|
|
|
@staticmethod
|
|
def public_session(item):
|
|
return {'id': item['session_id'], 'status': item.get('status', 'idle')}
|
|
|
|
async def acquire(self, context, data, query=None):
|
|
request = BoxAcquireRequest.model_validate(data)
|
|
key = request.reuse_key
|
|
if self.box.managed_admission_required:
|
|
if key != 'global':
|
|
raise BoxValidationError('This deployment requires the global Box reuse key')
|
|
session_id = 'global'
|
|
else:
|
|
session_id = 'runner-' + hashlib.sha256(key.encode()).hexdigest()
|
|
# Plugin options cannot override policy, host mounts, or execution identity.
|
|
if set(request.options) - {'image'}:
|
|
raise BoxValidationError('Only the Box image can be specified; resource limits are Host-owned')
|
|
spec = {'session_id': session_id, **request.options}
|
|
if query is not None:
|
|
spec['extra_mounts'] = self.box.build_skill_extra_mounts(query)
|
|
result = await self.box.create_session(context, spec)
|
|
return self.public_session(result)
|
|
|
|
async def bind(self, context, query, run_id, box_id):
|
|
current = getattr(query, '_box_binding', None)
|
|
if current is not None:
|
|
if current.run_id != run_id or current.session_id != box_id:
|
|
raise BoxValidationError('A run cannot change its Box after binding')
|
|
return self.binding_info(current)
|
|
sessions = await self.sessions(context)
|
|
item = next((item for item in sessions if item['session_id'] == box_id), None)
|
|
if item is None:
|
|
raise BoxValidationError('Box not found in the current Workspace')
|
|
current = getattr(query, '_box_binding', None)
|
|
if current is not None:
|
|
if current.run_id != run_id or current.session_id != box_id:
|
|
raise BoxValidationError('A run cannot change its Box after binding')
|
|
return self.binding_info(current)
|
|
fields = ('image', 'network', 'cpus', 'memory_mb', 'pids_limit', 'read_only_rootfs', 'persistent')
|
|
spec = {key: item[key] for key in fields if key in item}
|
|
spec['extra_mounts'] = self.box.build_skill_extra_mounts(query)
|
|
binding = RunBoxBinding(run_id, box_id, spec, run_id)
|
|
object.__setattr__(query, '_box_binding', binding)
|
|
return self.binding_info(binding)
|
|
|
|
@staticmethod
|
|
def binding_info(binding):
|
|
return {
|
|
'box_id': binding.session_id,
|
|
'outbox': f'/workspace/outbox/{binding.io_scope}',
|
|
}
|
|
|
|
async def import_attachments(self, query, attachment_ids):
|
|
binding = binding_for(query)
|
|
available = {f'attachment-{i}': c for i, c in enumerate(input_files(query))}
|
|
ids = list(available) if attachment_ids is None else attachment_ids
|
|
if not isinstance(ids, list) or any(type(key) is not str or key not in available for key in ids):
|
|
raise BoxValidationError('Unknown input attachment reference')
|
|
if len(ids) != len(set(ids)):
|
|
raise BoxValidationError('Duplicate input attachment reference')
|
|
async with binding.lock:
|
|
for key in ids:
|
|
if key in binding.imported:
|
|
continue
|
|
transfer = copy.copy(query)
|
|
# Each input has its own directory: repeated imports cannot erase other files.
|
|
object.__setattr__(transfer, '_box_binding', replace(binding, io_scope=f'{binding.io_scope}-{key}'))
|
|
transfer.message_chain = pm.MessageChain([available[key]])
|
|
items = await self.box.materialize_inbound_attachments(transfer)
|
|
if not items:
|
|
raise BoxValidationError(f'Failed to import input attachment {key}')
|
|
binding.imported[key] = {'id': key, **items[0]}
|
|
return {'items': [binding.imported[key] for key in ids]}
|
|
|
|
async def export_files(self, query):
|
|
binding = binding_for(query)
|
|
async with binding.lock:
|
|
items = await self.box.collect_outbound_attachments(query)
|
|
for item in items:
|
|
if len(binding.exported) >= 100:
|
|
raise BoxValidationError('At most 100 output files may be exported per run')
|
|
size = len(base64.b64decode(item['base64'].split(';base64,')[-1]))
|
|
if sum(x['size'] for x in binding.exported.values()) + size > self.box._ATTACHMENT_MAX_TOTAL_BYTES:
|
|
raise BoxValidationError('Output files exceed the per-run byte limit')
|
|
key = str(uuid.uuid4())
|
|
binding.exported[key] = {
|
|
**item,
|
|
'id': key,
|
|
'size': size,
|
|
}
|
|
return {
|
|
'items': [
|
|
{k: v for k, v in item.items() if k != 'base64'}
|
|
for key, item in binding.exported.items()
|
|
if key not in binding.submitted
|
|
]
|
|
}
|