@agentshouse/mdruntime-adapter 0.1.0-alpha.8 → 0.1.0-c6229cc476473

package/dist/actions.js

@@ -1,121 +1,59 @@
-import { VERSION } from '@agentshouse/mdmodel';
-import { changeBatchIdentity } from '@agentshouse/mdruntime';
+import { changeBatchIdentity, } from '@agentshouse/mdruntime';
 import { doorRefusal } from './refusal.js';
-import { PRIVATE_AUTHORITY } from './transport.js';
-export const CONVERSATION_ACTIONS = [
-    'conversation.create',
-    'conversation.send',
-    'conversation.answer',
-    'conversation.interrupt',
-    'conversation.kill',
-    'conversation.cancel',
-    'conversation.delete',
-    'conversation.history'
-];
-export const HOUSE_ACTS = [
-    'conversations/interaction/read',
-    'conversations/originals/read',
-    'apps/read',
-    'apps/customize',
-    'rooms/read',
-    'rooms/access/read',
-    'rooms/access/invitations',
-    'rooms/access/entries',
-    'rooms/access/invite',
-    'rooms/access/invitation-cancel',
-    'rooms/access/revoke',
-    'rooms/access/leave',
-    'rooms/roles/define',
-    'rooms/roles/remove',
-    'rooms/roles/assign',
-    'rooms/roles/unassign',
-    'rooms/settings/processing/read',
-    'rooms/settings/processing/write',
-    'profiles/create',
-    'profiles/read',
-    'profiles/edit',
-    'profiles/duplicate',
-    'profiles/delegate',
-    'agents/create',
-    'agents/read',
-    'routines/requests',
-    'routines/access',
-    'routines/owned',
-    'routines/granted',
-    'routines/grant',
-    'routines/send',
-    'routines/cancel',
-    'routines/start',
-    'routines/schedules',
-    'routines/schedules/create',
-    'routines/schedules/enabled',
-    'account/security/read',
-    'storage/inventory',
-    'storage/usage',
-    'usage/statement',
-    'storage/blob-store',
-    'storage/blob-store/select',
-    'storage/connections',
-    'storage/archive',
-    'storage/archive/status',
-    'environments/read',
-    'environments/create',
-    'environments/start',
-    'environments/stop',
-    'environments/delete',
-    'environments/renewals/read',
-    'environments/work/read',
-    'nodes/read'
-];
-export const HOUSE_PROVIDER_ACTIONS = [
-    ...CONVERSATION_ACTIONS,
-    ...HOUSE_ACTS
-];
-const DECLARED = new Set(HOUSE_PROVIDER_ACTIONS);
-export const HISTORY_PAGE = 100;
+import { PRIVATE_LOCATOR } from './transport.js';
+const HISTORY_PAGE = 100;
+const HISTORY_CONVERSATIONS = 64;
 const OCTET_STREAM = 'application/octet-stream';
-const CONVERSATION_ROUTES = {
-    'conversation.create': '/door/conversations/create',
-    'conversation.send': '/door/conversations/send',
-    'conversation.answer': '/door/conversations/interaction/answer',
-    'conversation.interrupt': '/door/conversations/interrupt',
-    'conversation.kill': '/door/conversations/kill',
-    'conversation.cancel': '/door/conversations/cancel',
-    'conversation.delete': '/door/conversations/delete',
-    'conversation.history': '/door/conversations/history',
-    'conversations/interaction/read': '/door/conversations/interaction/read',
-    'conversations/originals/read': '/door/conversations/originals/read'
-};
+const CONVERSATION_ROUTES = new Map([
+    ['conversation.create', '/door/conversations/create'],
+    ['conversation.send', '/door/conversations/send'],
+    ['conversation.answer', '/door/conversations/interaction/answer'],
+    ['conversation.interrupt', '/door/conversations/interrupt'],
+    ['conversation.kill', '/door/conversations/kill'],
+    ['conversation.delete', '/door/conversations/delete'],
+    ['conversation.history', '/door/conversations/history'],
+]);
 export const HOUSE_CONVERSATION_CARDS = {
-    locator: PRIVATE_AUTHORITY,
-    type: 'conversation',
+    locator: PRIVATE_LOCATOR,
+    type: 'house-conversation',
     identity: 'conversation',
-    agent: 'agent'
+    agent: 'agent',
 };
-export function declaredActions() {
-    return HOUSE_PROVIDER_ACTIONS.map((name)=>({
-            name,
-            inputShape: {},
-            resultKind: 'house'
-        }));
+export function declaredActions(routes) {
+    const mapped = new Map([...CONVERSATION_ROUTES].map(([name, route]) => [route.slice('/door/'.length), name]));
+    return routes.map((route) => ({
+        name: mapped.get(route) ?? route,
+        inputShape: {},
+        resultKind: 'house',
+    }));
 }
 export function houseAction(transport, request) {
-    if (!DECLARED.has(request.name)) {
-        return Promise.resolve({
-            kind: 'rejected',
-            code: 'action-unimplemented',
-            fields: {
-                name: request.name,
-                mdModel: VERSION
-            }
-        });
-    }
-    if (request.name === 'conversation.send') return sendAction(transport, request.input);
-    if (request.name === 'conversation.history') return historyAction(transport, request.input);
-    return carry(transport, request.name, request.input);
+    if (request.name === 'conversation.send')
+        return sendAction(transport, request.input);
+    if (request.name === 'conversation.history')
+        return historyAction(transport, request.input);
+    if (request.name === 'attachments/upload')
+        return attachAction(transport, request.input);
+    if (request.name === 'attachments/get')
+        return openAction(transport, request.input);
+    const route = routeOf(request.name);
+    if (route === null)
+        return Promise.resolve(malformed());
+    return carry(transport, route, request.name, request.input);
 }
 function routeOf(name) {
-    return CONVERSATION_ROUTES[name] ?? `/door/${name}`;
+    const mapped = CONVERSATION_ROUTES.get(name);
+    if (mapped !== undefined)
+        return mapped;
+    const parts = name.split('/');
+    if (parts.some((part) => part === '.' || part === '..'))
+        return null;
+    try {
+        return `/door/${parts.map(encodeURIComponent).join('/')}`;
+    }
+    catch {
+        return null;
+    }
 }
 function record(value) {
     return typeof value === 'object' && value !== null ? value : {};
@@ -128,31 +66,16 @@ function operationId(input) {
     return text(input, 'operation_id') ?? changeBatchIdentity();
 }
 function malformed() {
-    return {
-        kind: 'rejected',
-        code: 'invalid_request',
-        fields: {}
-    };
+    return { kind: 'rejected', code: 'invalid_request', fields: {} };
 }
 function bodyOf(name, input) {
     if (name === 'conversation.create') {
-        return {
-            agent_id: text(input, 'agent_id'),
-            operation_id: operationId(input)
-        };
-    }
-    if (name === 'conversation.interrupt' || name === 'conversation.kill' || name === 'conversation.delete') {
-        return {
-            conversation_id: text(input, 'conversation'),
-            operation_id: operationId(input)
-        };
+        return { agent_id: text(input, 'agent_id'), operation_id: operationId(input) };
     }
-    if (name === 'conversation.cancel') {
-        return {
-            conversation_id: text(input, 'conversation'),
-            message_id: text(input, 'turn'),
-            operation_id: operationId(input)
-        };
+    if (name === 'conversation.interrupt' ||
+        name === 'conversation.kill' ||
+        name === 'conversation.delete') {
+        return { conversation_id: text(input, 'conversation'), operation_id: operationId(input) };
     }
     if (name === 'conversation.answer') {
         const nested = record(record(input).answer);
@@ -160,8 +83,7 @@ function bodyOf(name, input) {
             conversation_id: text(input, 'conversation'),
             operation_id: operationId(input),
             interaction_id: text(nested, 'interaction_id'),
-            revision: nested.revision,
-            response: nested.response
+            response: nested.response,
         };
     }
     return input;
@@ -169,37 +91,25 @@ function bodyOf(name, input) {
 function withTurn(body) {
     const held = record(body);
     const turn = text(held, 'message_id');
-    return turn === undefined ? body : {
-        ...held,
-        turn
-    };
+    return turn === undefined ? body : { ...held, turn };
 }
 export function actionOutcome(answer, name) {
-    if (answer.status === 401) return {
-        kind: 'revoked-authorization'
-    };
+    if (answer.status === 401)
+        return { kind: 'revoked-authorization' };
     const refusal = doorRefusal(answer.body);
     if (refusal !== null) {
-        return {
-            kind: 'rejected',
-            code: refusal.code,
-            fields: refusal.fields
-        };
+        return { kind: 'rejected', code: refusal.code, fields: refusal.fields };
     }
-    if (answer.status === 0 || answer.status >= 400) return {
-        kind: 'transport-uncertainty'
-    };
-    if (name === 'conversation.send') return {
-        kind: 'action',
-        result: withTurn(answer.body)
-    };
-    return {
-        kind: 'action',
-        result: answer.body
-    };
+    if (answer.status === 404)
+        return { kind: 'rejected', code: 'action-unimplemented', fields: { name } };
+    if (answer.status === 0 || answer.status >= 400)
+        return { kind: 'transport-uncertainty' };
+    if (name === 'conversation.send')
+        return { kind: 'action', result: withTurn(answer.body) };
+    return { kind: 'action', result: answer.body };
 }
-async function carry(transport, name, input) {
-    const answer = await transport.door(routeOf(name), bodyOf(name, input));
+async function carry(transport, route, name, input) {
+    const answer = await transport.door(route, bodyOf(name, input));
     return actionOutcome(answer, name);
 }
 function sendFile(entry) {
@@ -207,7 +117,8 @@ function sendFile(entry) {
     const name = text(file, 'name');
     const bytes = file.byteLength;
     const sha256 = text(file, 'contentHash');
-    if (name === undefined || typeof bytes !== 'number' || sha256 === undefined) return null;
+    if (name === undefined || typeof bytes !== 'number' || sha256 === undefined)
+        return null;
     const mediaType = text(file, 'mediaType');
     const width = file.width;
     const height = file.height;
@@ -216,239 +127,235 @@ function sendFile(entry) {
         media_type: mediaType !== undefined && mediaType.length > 0 ? mediaType : OCTET_STREAM,
         bytes,
         sha256,
-        ...typeof width === 'number' && typeof height === 'number' ? {
-            dimensions: {
-                width,
-                height
-            }
-        } : {}
+        ...(typeof width === 'number' && typeof height === 'number'
+            ? { dimensions: { width, height } }
+            : {}),
     };
 }
 function sendFiles(input) {
     const files = record(input).files;
-    if (files === undefined) return [];
-    if (!Array.isArray(files)) return null;
+    if (files === undefined)
+        return [];
+    if (!Array.isArray(files))
+        return null;
     const declared = [];
-    for (const entry of files){
+    for (const entry of files) {
         const file = sendFile(entry);
-        if (file === null) return null;
+        if (file === null)
+            return null;
         declared.push(file);
     }
     return declared;
 }
 function sendBody(input) {
     const files = sendFiles(input);
-    if (files === null) return null;
+    if (files === null)
+        return null;
     const textValue = text(input, 'text');
     return {
         conversation_id: text(input, 'conversation'),
         operation_id: operationId(input),
-        ...textValue !== undefined && textValue.length > 0 ? {
-            text: textValue
-        } : {},
-        ...files.length === 0 ? {} : {
-            files
-        }
+        ...(textValue !== undefined && textValue.length > 0 ? { text: textValue } : {}),
+        ...(files.length === 0 ? {} : { files }),
     };
 }
 async function fileBytes(file) {
     const blob = record(file).blob;
-    if (blob === undefined || typeof blob !== 'object' || blob === null) return null;
-    if (!('arrayBuffer' in blob) || typeof blob.arrayBuffer !== 'function') return null;
+    if (blob === undefined || typeof blob !== 'object' || blob === null)
+        return null;
+    if (!('arrayBuffer' in blob) || typeof blob.arrayBuffer !== 'function')
+        return null;
     return new Uint8Array(await blob.arrayBuffer());
 }
+function delivered(answer, name) {
+    return answer.status === 200 ? null : actionOutcome(answer, name);
+}
 function uploadGrant(entry) {
-    if (!('upload' in record(entry))) return 'absent';
+    if (!('upload' in record(entry)))
+        return 'absent';
     const upload = record(record(entry).upload);
-    if (upload.method !== 'POST') return null;
-    if (typeof upload.operation !== 'string' || typeof upload.url !== 'string') return null;
-    return {
-        method: 'POST',
-        operation: upload.operation,
-        url: upload.url
-    };
+    if (upload.method !== 'POST')
+        return null;
+    if (typeof upload.operation !== 'string' || typeof upload.url !== 'string')
+        return null;
+    return { method: 'POST', operation: upload.operation, url: upload.url };
 }
 async function uploadOriginals(transport, input, result) {
     const originals = record(result).originals;
-    if (!Array.isArray(originals) || originals.length === 0) return null;
+    if (!Array.isArray(originals) || originals.length === 0)
+        return null;
     const files = Array.isArray(record(input).files) ? record(input).files : [];
-    for (const [index, entry] of originals.entries()){
+    for (const [index, entry] of originals.entries()) {
         const grant = uploadGrant(entry);
-        if (grant === 'absent') continue;
-        if (grant === null) return malformed();
+        if (grant === 'absent')
+            continue;
+        if (grant === null)
+            return malformed();
         const bytes = index < files.length ? await fileBytes(files[index]) : null;
         if (bytes === null) {
-            return {
-                kind: 'rejected',
-                code: 'conversation_original_descriptor_required',
-                fields: {}
-            };
+            return { kind: 'rejected', code: 'conversation_original_descriptor_required', fields: {} };
         }
-        const delivered = await transport.transfer({
+        const failed = delivered(await transport.transfer({
             act: 'conversation_original_upload',
             method: 'POST',
             url: grant.url,
+            answer: 'json',
             body: bytes,
-            operation: grant.operation
-        });
-        if (delivered.status === 200) continue;
-        return actionOutcome(delivered, 'conversation.send');
+            operation: grant.operation,
+        }), 'conversation.send');
+        if (failed !== null)
+            return failed;
     }
     return null;
 }
+async function attachAction(transport, input) {
+    const { blob, ...descriptor } = record(input);
+    const bytes = await fileBytes({ blob });
+    if (bytes === null)
+        return malformed();
+    const answer = await transport.door('/door/attachments/upload', descriptor);
+    const outcome = actionOutcome(answer, 'attachments/upload');
+    if (outcome.kind !== 'action')
+        return outcome;
+    const grant = uploadGrant(outcome.result);
+    if (grant === 'absent')
+        return outcome;
+    if (grant === null)
+        return malformed();
+    const stored = await transport.transfer({
+        act: 'original_upload',
+        method: 'POST',
+        url: grant.url,
+        answer: 'json',
+        body: bytes,
+        operation: grant.operation,
+    });
+    return delivered(stored, 'attachments/upload') ?? { kind: 'action', result: stored.body };
+}
+async function openAction(transport, input) {
+    const answer = await transport.door('/door/attachments/get', input);
+    const outcome = actionOutcome(answer, 'attachments/get');
+    if (outcome.kind !== 'action')
+        return outcome;
+    const { download, ...opened } = record(outcome.result);
+    if (download === undefined)
+        return outcome;
+    const grant = record(download);
+    if (grant.method !== 'GET' || typeof grant.url !== 'string')
+        return malformed();
+    const read = await transport.transfer({
+        act: 'original_download',
+        method: 'GET',
+        url: grant.url,
+        answer: 'bytes',
+    });
+    const failed = delivered(read, 'attachments/get');
+    if (failed !== null)
+        return failed;
+    if (!(read.body instanceof Blob))
+        return { kind: 'transport-uncertainty' };
+    return { kind: 'action', result: { ...opened, blob: read.body } };
+}
 async function sendAction(transport, input) {
     const body = sendBody(input);
-    if (body === null) return malformed();
+    if (body === null)
+        return malformed();
     const answer = await transport.door('/door/conversations/send', body);
     const outcome = actionOutcome(answer, 'conversation.send');
-    if (outcome.kind !== 'action') return outcome;
+    if (outcome.kind !== 'action')
+        return outcome;
     const uploaded = await uploadOriginals(transport, input, outcome.result);
-    if (uploaded !== null) return uploaded;
+    if (uploaded !== null)
+        return uploaded;
     return outcome;
 }
 function historyCursor(value) {
-    let parsed;
+    const acceptedAt = text(value, 'accepted_at');
+    const messageId = text(value, 'message_id');
+    if (acceptedAt === undefined || messageId === undefined)
+        return null;
+    return { accepted_at: acceptedAt, message_id: messageId };
+}
+function position(cursor) {
+    return JSON.stringify({ accepted_at: cursor.accepted_at, message_id: cursor.message_id });
+}
+function positionCursor(value) {
     try {
-        parsed = JSON.parse(value);
-    } catch  {
+        return historyCursor(JSON.parse(value));
+    }
+    catch {
         return null;
     }
-    const acceptedAt = text(parsed, 'accepted_at');
-    const messageId = text(parsed, 'message_id');
-    if (acceptedAt === undefined || messageId === undefined) return null;
-    return {
-        accepted_at: acceptedAt,
-        message_id: messageId
-    };
 }
-function turned(entry) {
-    const turn = text(entry, 'message_id');
-    if (turn === undefined) return null;
+export function acceptedMessage(entry) {
+    const cursor = historyCursor(entry);
+    if (cursor === null)
+        return null;
     return {
-        turn,
-        message: structuredClone(entry)
+        identity: cursor.message_id,
+        turn: text(entry, 'turn_id') ?? cursor.message_id,
+        position: position(cursor),
+        text: text(entry, 'text') ?? '',
+        message: structuredClone(entry),
     };
 }
-function olderCursor(entry) {
-    const acceptedAt = text(entry.message, 'accepted_at');
-    const messageId = text(entry.message, 'message_id');
-    if (acceptedAt === undefined || messageId === undefined) return null;
-    return JSON.stringify({
-        accepted_at: acceptedAt,
-        message_id: messageId
-    });
-}
-export async function readConversationHistory(transport, conversationId) {
+function historyPage(entry) {
+    const held = record(entry);
+    const conversation = text(held, 'conversation_id');
+    if (conversation === undefined || !Array.isArray(held.messages))
+        return null;
     const messages = [];
-    let after;
-    for(;;){
-        const answer = await transport.door('/door/conversations/history', {
-            conversation_id: conversationId,
-            ...after === undefined ? {} : {
-                after
-            },
-            limit: HISTORY_PAGE
-        });
-        const outcome = actionOutcome(answer, 'conversation.history');
-        if (outcome.kind !== 'action') return {
-            outcome
-        };
-        const held = record(outcome.result);
-        if (!Array.isArray(held.messages)) return {
-            outcome: {
-                kind: 'transport-uncertainty'
-            }
-        };
-        for (const entry of held.messages){
-            if (text(entry, 'message_id') === undefined) {
-                return {
-                    outcome: {
-                        kind: 'transport-uncertainty'
-                    }
-                };
-            }
-            messages.push(entry);
-        }
-        if (held.next === null || held.next === undefined) return {
-            messages
-        };
-        const next = record(held.next);
-        const acceptedAt = text(next, 'accepted_at');
-        const messageId = text(next, 'message_id');
-        if (acceptedAt === undefined || messageId === undefined) {
-            return {
-                outcome: {
-                    kind: 'transport-uncertainty'
-                }
-            };
-        }
-        after = {
-            accepted_at: acceptedAt,
-            message_id: messageId
-        };
+    for (const one of held.messages) {
+        const message = acceptedMessage(one);
+        if (message === null)
+            return null;
+        messages.push(message);
     }
+    const next = held.next === null || held.next === undefined ? undefined : historyCursor(held.next);
+    if (next === null)
+        return null;
+    return { conversation, messages, ...(next === undefined ? {} : { next: position(next) }) };
 }
-function historyPage(conversationId, messages, until) {
-    const from = Math.max(0, until - HISTORY_PAGE);
-    const page = messages.slice(from, until);
-    const first = page[0];
-    const cursor = from === 0 || first === undefined ? null : olderCursor(first);
-    if (from > 0 && cursor === null) return {
-        kind: 'transport-uncertainty'
-    };
-    return {
-        kind: 'action',
-        result: {
-            conversation_id: conversationId,
-            messages: page,
-            ...cursor === null ? {} : {
-                cursor
-            }
-        }
-    };
+function historyAsks(input) {
+    const asked = record(input).conversations;
+    if (!Array.isArray(asked) || asked.length === 0)
+        return null;
+    const asks = [];
+    for (const entry of asked) {
+        const conversationId = text(entry, 'conversation');
+        if (conversationId === undefined)
+            return null;
+        const afterValue = text(entry, 'after');
+        const after = afterValue === undefined ? undefined : positionCursor(afterValue);
+        if (after === null)
+            return null;
+        asks.push({ conversation_id: conversationId, ...(after === undefined ? {} : { after }) });
+    }
+    return asks;
 }
 async function historyAction(transport, input) {
-    const conversationId = text(input, 'conversation');
-    if (conversationId === undefined) return malformed();
-    const cursorValue = text(input, 'cursor');
-    let olderThan;
-    if (cursorValue !== undefined) {
-        const parsed = historyCursor(cursorValue);
-        if (parsed === null) {
-            return {
-                kind: 'rejected',
-                code: 'unknown-cursor',
-                fields: {
-                    cursor: cursorValue
-                }
-            };
+    const asks = historyAsks(input);
+    if (asks === null)
+        return malformed();
+    const histories = [];
+    for (let at = 0; at < asks.length; at += HISTORY_CONVERSATIONS) {
+        const answer = await transport.door('/door/conversations/history', {
+            conversations: asks.slice(at, at + HISTORY_CONVERSATIONS),
+            limit: HISTORY_PAGE,
+        });
+        const outcome = actionOutcome(answer, 'conversation.history');
+        if (outcome.kind !== 'action')
+            return outcome;
+        const answered = record(outcome.result).histories;
+        if (!Array.isArray(answered))
+            return { kind: 'transport-uncertainty' };
+        for (const entry of answered) {
+            const page = historyPage(entry);
+            if (page === null)
+                return { kind: 'transport-uncertainty' };
+            histories.push(page);
         }
-        olderThan = parsed;
-    }
-    const held = await readConversationHistory(transport, conversationId);
-    if ('outcome' in held) return held.outcome;
-    const messages = [];
-    for (const entry of held.messages){
-        const mapped = turned(entry);
-        if (mapped === null) return {
-            kind: 'transport-uncertainty'
-        };
-        messages.push(mapped);
-    }
-    if (olderThan === undefined) {
-        return historyPage(conversationId, messages, messages.length);
-    }
-    const at = messages.findIndex((entry)=>text(entry.message, 'accepted_at') === olderThan.accepted_at && text(entry.message, 'message_id') === olderThan.message_id);
-    if (at === -1) {
-        return {
-            kind: 'rejected',
-            code: 'unknown-cursor',
-            fields: {
-                cursor: cursorValue
-            }
-        };
     }
-    return historyPage(conversationId, messages, at);
+    const result = { histories };
+    return { kind: 'action', result };
 }
-
-//# sourceMappingURL=actions.js.map