@fitchmultz/pi-subagents 0.50.0 → 0.52.0

package/src/pi-intercom/broker/broker.ts

@@ -7,11 +7,12 @@ import { getBrokerRuntimeDir, prepareBrokerSocketPath } from "./paths.ts";
 import { brokerPidRecord } from "./pid.ts";
 import { assertBrokerCanStart } from "./spawn.ts";
 import { LastMessageRelay } from "./last.ts";
-import { assertMainParent, canSeeSession, findSessions } from "./targets.ts";
-import { acceptBrokerConnection } from "./server-connection.ts";
+import { canSeeSession, findSessions } from "./targets.ts";
+import { ParkedSessions, reachable, type ParkablePeer } from "./parked.ts";
+import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.ts";
+import { guardedDeliveryError } from "./guard.ts";
 import {
   compactTopicMessage,
-  isSessionRegistration,
   normalizeMessage,
   normalizeSessionInfo,
   type SessionInfo,
@@ -35,12 +36,12 @@ import {
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 
-interface ConnectedSession {
-  readonly socket: net.Socket;
+interface ConnectedSession extends ParkablePeer {
   info: SessionInfo;
   topics: TopicSnapshot;
   readonly topicFrames: boolean;
   readonly lastMessages: boolean;
+  readonly receiptReads: boolean;
 }
 
 interface PendingReplaceDelivery {
@@ -53,6 +54,7 @@ interface PendingReplaceDelivery {
 class IntercomBroker {
   private readonly sessions = new Map<string, ConnectedSession>();
   private readonly lastMessages = new LastMessageRelay(this.sessions);
+  private readonly parking = new ParkedSessions(this.sessions, this.deliverMessage.bind(this));
   private readonly pendingReplaceDeliveries = new Map<string, PendingReplaceDelivery>();
   private readonly server: net.Server;
   private shutdownTimer: NodeJS.Timeout | null = null;
@@ -95,7 +97,7 @@ class IntercomBroker {
 
     this.shutdownTimer = setTimeout(() => {
       this.shutdownTimer = null;
-      if (this.sessions.size === 0) {
+      if (this.parking.exited) {
         console.log("No sessions connected, shutting down");
         this.shutdown();
       }
@@ -129,7 +131,7 @@ class IntercomBroker {
     }
     switch (msg.type) {
       case "unregister":
-        this.removeSession(currentId);
+        this.removeSession(currentId, socket);
         setId(null);
         break;
       case "list":
@@ -139,7 +141,8 @@ class IntercomBroker {
         this.send(socket, msg, currentId);
         break;
       case "last_request":
-        this.lastMessages.request(currentId, msg);
+        // Reads never spawn a parked child.
+        this.lastMessages.request(currentId, msg, (id) => this.parking.reader(id));
         break;
       case "last_response":
         this.lastMessages.respond(currentId, msg);
@@ -147,31 +150,30 @@ class IntercomBroker {
       case "presence":
         this.presence(msg, currentId);
         break;
+      case "park":
+      case "unpark":
+        this.parking.park(socket, currentId, msg.type === "park");
+        break;
       default:
         throw new Error(`Unknown client message type: ${msg.type}`);
     }
   }
 
   private register(socket: net.Socket, msg: UnknownRecord, setId: (id: string) => void): void {
-    if (!isSessionRegistration(msg.session)) {
-      throw new Error("Invalid register message");
-    }
-    assertMainParent(msg.session, this.sessions);
-    const requestedId =
-      typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
-        ? msg.requestedId
-        : undefined;
-    const id =
-      requestedId !== undefined && !this.sessions.has(requestedId) ? requestedId : randomUUID();
-    const info: SessionInfo = { ...msg.session, id, lastSeen: msg.session.lastSeen ?? Date.now() };
+    const registered = registeredSessionInfo(msg, this.sessions);
+    const { id, resumed } = this.parking.claim(msg.requestedId, registered);
+    const info: SessionInfo = { ...registered, id };
     snapshotFrames(randomUUID(), [info], true);
     const topicFrames = msg.topicFrames === true;
     this.sessions.set(id, {
       socket,
       info: messageSender(info),
-      topics: new TopicSnapshot(info),
+      // A woken generation registers no topics; the parked identity's owner keeps them.
+      topics: resumed?.topics ?? new TopicSnapshot(info),
       topicFrames,
       lastMessages: msg.lastMessages === true,
+      parking: msg.parking === true,
+      receiptReads: msg.receiptReads === 1,
     });
     setId(id);
     if (this.shutdownTimer) {
@@ -182,19 +184,25 @@ class IntercomBroker {
       type: "registered",
       sessionId: id,
       lastMessages: true,
+      parking: msg.parking === true,
+      receiptReads: 1,
+      ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
       ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
     });
+    this.parking.registered(id, resumed);
   }
 
-  private removeSession(sessionId: string): void {
+  private removeSession(sessionId: string, socket: net.Socket): void {
     const session = this.sessions.get(sessionId);
-    if (!session) {
+    if (session?.socket !== socket) {
       return;
     }
-    this.sessions.delete(sessionId);
     this.lastMessages.disconnected(sessionId);
-    this.clearPendingReplaceDeliveries(sessionId);
-    this.broadcast({ type: "session_left", sessionId }, session.info);
+    if (!this.parking.closed(session)) {
+      this.sessions.delete(sessionId);
+      this.clearPendingReplaceDeliveries(sessionId);
+      this.broadcast({ type: "session_left", sessionId }, session.info);
+    }
     this.scheduleShutdownCheck();
   }
 
@@ -213,7 +221,7 @@ class IntercomBroker {
         continue;
       }
       const message = publicationMessage(publication, subscription.awaitRelease === true);
-      const error = this.validateDeliveryPayload(from, message, target.topicFrames);
+      const error = this.validateDeliveryPayload(from, message, target);
       if (error !== null) {
         throw new Error(error);
       }
@@ -296,6 +304,15 @@ class IntercomBroker {
     const targets = findSessions(this.sessions, msg.to, currentId);
     const target = targets[0];
     if (targets.length === 1) {
+      const guardError = guardedDeliveryError(this.sessions, msg.to, message);
+      if (guardError !== null) {
+        writeMessage(socket, {
+          type: "delivery_failed",
+          messageId: message.id,
+          reason: guardError,
+        });
+        return;
+      }
       const fromSession = this.sessions.get(currentId);
       if (!fromSession) {
         writeMessage(socket, {
@@ -343,11 +360,15 @@ class IntercomBroker {
       "lastIntercomActivity",
       "subscriptions",
       "topics",
+      "applicationGuard",
     ]) {
       if (msg[key] !== undefined) {
         update[key] = msg[key];
       }
     }
+    if (msg.applicationGuard === null) {
+      delete update.applicationGuard;
+    }
     const nextInfo = normalizeSessionInfo(update);
     if (!nextInfo) {
       throw new Error("Invalid presence update");
@@ -366,22 +387,16 @@ class IntercomBroker {
     message: Message,
   ): SendResult {
     const target = this.sessions.get(toId);
-    if (!target) {
-      return {
-        id: message.id,
-        accepted: false,
-        delivered: false,
-        reason: "Recipient disconnected before delivery",
-      };
-    }
-    if (shouldReplaceDelivery(message, target.info)) {
+    if (target && target.parked === undefined && shouldReplaceDelivery(message, target.info)) {
       return this.queueReplaceDelivery(fromId, toId, from, message);
     }
     const reason = this.deliverMessage(toId, from, message);
+    const queued = reason === null && target?.parked !== undefined;
     return {
       id: message.id,
       accepted: reason === null,
-      delivered: reason === null,
+      delivered: reason === null && !queued,
+      ...(queued ? { queued } : {}),
       ...(reason !== null ? { reason } : {}),
     };
   }
@@ -410,11 +425,7 @@ class IntercomBroker {
     from: SessionInfo,
     message: Message,
   ): SendResult {
-    const validationError = this.validateDeliveryPayload(
-      from,
-      message,
-      this.sessions.get(toId)?.topicFrames === true,
-    );
+    const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId));
     if (validationError !== null) {
       return { id: message.id, accepted: false, delivered: false, reason: validationError };
     }
@@ -450,33 +461,33 @@ class IntercomBroker {
     }
   }
 
+  /** One admission rule; retained input is checked as the uncompacted envelope any later
+   * transport generation accepts. */
   private validateDeliveryPayload(
     from: SessionInfo,
     message: Message,
-    topicFrames: boolean,
+    target: ConnectedSession | undefined,
   ): string | null {
+    const compact = target?.parked === undefined && target?.topicFrames === true;
     return (
       validateIntercomMessageSize({
         type: "message",
         from: messageSender(from),
-        message: topicFrames ? compactTopicMessage(message) : message,
+        message: compact ? compactTopicMessage(message) : message,
       })?.message ?? null
     );
   }
 
   private deliverMessage(toId: string, from: SessionInfo, message: Message): string | null {
     const target = this.sessions.get(toId);
-    if (
-      !target ||
-      target.socket.destroyed ||
-      target.socket.writableEnded ||
-      !target.socket.writable
-    ) {
-      return "Recipient disconnected before delivery";
+    const refused =
+      guardedDeliveryError(this.sessions, toId, message) ??
+      this.validateDeliveryPayload(from, message, target);
+    if (refused !== null || this.parking.retain(target, from, message)) {
+      return refused;
     }
-    const validationError = this.validateDeliveryPayload(from, message, target.topicFrames);
-    if (validationError !== null) {
-      return validationError;
+    if (!reachable(target)) {
+      return "Recipient disconnected before delivery";
     }
     this.touchActivity(toId, true);
     try {

package/src/pi-intercom/broker/client-last.ts

@@ -1,21 +1,63 @@
 import type net from "node:net";
 import { randomUUID } from "node:crypto";
 import { errorMessage, type UnknownRecord } from "../../shared/unknown.ts";
-import type { LastMessageResult } from "../types.ts";
-import { isLastMessageQuery, isLastMessageResult } from "./last.ts";
+import {
+  isNativeReadQuery,
+  isNativeReadResult,
+  isLastMessageResult,
+  isReceiptResult,
+  type NativeReadQuery,
+  type NativeReadResult,
+} from "./last.ts";
+import {
+  normalizeSessionInfo,
+  type LastMessageQuery,
+  type LastMessageResult,
+  type ReceiptQuery,
+  type ReceiptResult,
+  type SessionInfo,
+} from "../types.ts";
 import { writeMessage } from "./framing.ts";
 
+/** A peer's read of this session or, for a main, of its exited `parked` child. */
+export function lastRequest(msg: UnknownRecord): {
+  readonly requestId: string;
+  readonly from: SessionInfo;
+  readonly query: NativeReadQuery;
+  readonly parked?: SessionInfo;
+} {
+  const from = normalizeSessionInfo(msg.from);
+  if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {
+    throw new Error("Invalid last-message request");
+  }
+  return {
+    requestId: msg.requestId,
+    from,
+    query: msg.query,
+    parked: normalizeSessionInfo(msg.parked) ?? undefined,
+  };
+}
+
 export class LastMessageRequests {
+  /** Negotiated at registration; a failed connection supports neither. */
+  lastMessages = false;
+  receiptReads = false;
+  private readonly timeoutMs: number;
+  constructor(timeoutMs: number) {
+    this.timeoutMs = timeoutMs;
+  }
   private readonly pending = new Map<
     string,
     {
-      readonly resolve: (result: LastMessageResult) => void;
+      readonly resolve: (result: NativeReadResult) => void;
       readonly reject: (error: Readonly<Error>) => void;
       readonly timer: NodeJS.Timeout;
     }
   >();
 
   fail(error: Readonly<Error>): void {
+    this.lastMessages = false;
+    this.receiptReads = false;
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
@@ -24,7 +66,7 @@ export class LastMessageRequests {
   }
 
   receive(message: UnknownRecord): void {
-    if (typeof message.requestId !== "string" || !isLastMessageResult(message.result)) {
+    if (typeof message.requestId !== "string" || !isNativeReadResult(message.result)) {
       throw new Error("Invalid last-message response");
     }
     const pending = this.pending.get(message.requestId);
@@ -36,21 +78,32 @@ export class LastMessageRequests {
     pending.resolve(message.result);
   }
 
-  request(
-    socket: net.Socket,
-    to: string,
-    query: unknown,
-    timeoutMs: number,
-  ): Promise<LastMessageResult> {
-    if (!isLastMessageQuery(query)) {
+  async last(socket: net.Socket, to: string, query: LastMessageQuery): Promise<LastMessageResult> {
+    const result = await this.request(socket, to, query);
+    return isLastMessageResult(result) ? result : { error: "Invalid last-message response" };
+  }
+  async receipt(socket: net.Socket, to: string, query: ReceiptQuery): Promise<ReceiptResult> {
+    const result = await this.request(socket, to, query);
+    return isReceiptResult(result) ? result : { error: "Invalid receipt response" };
+  }
+  private request(socket: net.Socket, to: string, query: unknown): Promise<NativeReadResult> {
+    if (!this.lastMessages) {
+      return Promise.reject(
+        new Error("This broker does not support last-message reads; reload after it exits."),
+      );
+    }
+    if (!isNativeReadQuery(query)) {
       return Promise.reject(new Error("Invalid last-message query"));
     }
+    if ("messageId" in query && !this.receiptReads) {
+      return Promise.reject(new Error("publication_unavailable"));
+    }
     return new Promise((resolve, reject) => {
       const requestId = randomUUID();
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
         reject(new Error("Last-message read timeout"));
-      }, timeoutMs);
+      }, this.timeoutMs);
       timer.unref();
       this.pending.set(requestId, { resolve, reject, timer });
       try {

package/src/pi-intercom/broker/client-park.ts

@@ -0,0 +1,23 @@
+import type net from "node:net";
+import { writeMessage } from "./framing.ts";
+
+/** Parking negotiation and its single outstanding broker acknowledgement. */
+export class ParkRequests {
+  supported = false;
+  private acknowledged?: (parked: boolean) => void;
+  settle(parked: boolean): void {
+    this.acknowledged?.(parked);
+  }
+  /** True once the broker retains later input; false when it cannot or the socket closed. */
+  request(socket: () => net.Socket, on: boolean): Promise<boolean> {
+    return new Promise((resolve) => {
+      this.acknowledged = on && this.supported ? resolve : undefined;
+      if (this.supported) {
+        writeMessage(socket(), { type: on ? "park" : "unpark" });
+      }
+      if (this.acknowledged === undefined) {
+        resolve(false);
+      }
+    });
+  }
+}

package/src/pi-intercom/broker/client.ts

@@ -4,8 +4,9 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.ts";
 import { BrokerConnection, connectBrokerSocket } from "./connection.ts";
 import { SnapshotReader } from "./snapshot-reader.ts";
-import { LastMessageRequests } from "./client-last.ts";
-import { isLastMessageQuery, isLastMessageResult } from "./last.ts";
+import { LastMessageRequests, lastRequest } from "./client-last.ts";
+import { ParkRequests } from "./client-park.ts";
+import { isNativeReadResult } from "./last.ts";
 import {
   errorMessage,
   isRecord,
@@ -18,16 +19,16 @@ import {
   normalizeSessionInfo,
   type SessionInfo,
   type Message,
-  type Attachment,
   type MessageDelivery,
-  type QueueMode,
-  type HumanMessageOrigin,
   type TopicUpdate,
   type TopicChange,
   type SessionSnapshot,
   type SendResult,
   type LastMessageQuery,
   type LastMessageResult,
+  type SendOptions,
+  type ReceiptQuery,
+  type ReceiptResult,
 } from "../types.ts";
 export type { SendResult } from "../types.ts";
 
@@ -43,20 +44,6 @@ export interface IntercomClientOptions {
   readonly listTimeoutMs?: number;
 }
 
-interface SendOptions {
-  readonly text: string;
-  readonly attachments?: readonly Attachment[];
-  readonly replyTo?: string;
-  readonly expectsReply?: boolean;
-  readonly delivery?: MessageDelivery;
-  readonly queueMode?: QueueMode;
-  readonly threadId?: string;
-  readonly passive?: boolean;
-  readonly messageId?: string;
-  readonly human?: HumanMessageOrigin;
-  readonly topic?: TopicUpdate;
-}
-
 function toError(error: unknown): Error {
   return error instanceof Error ? error : new Error(errorMessage(error));
 }
@@ -78,8 +65,9 @@ export class IntercomClient extends EventEmitter {
   private connection: BrokerConnection | null = null;
   private _sessionId: string | null = null;
   private _topicsSupported = false;
-  private lastMessagesSupported = false;
-  private readonly lastRequests = new LastMessageRequests();
+  private readonly parking = new ParkRequests();
+  private guardedDeliverySupported = false;
+  private readonly lastRequests: LastMessageRequests;
   private readonly pendingSends = new Map<
     string,
     { readonly resolve: (r: SendResult) => void; readonly reject: (e: Readonly<Error>) => void }
@@ -101,6 +89,7 @@ export class IntercomClient extends EventEmitter {
     super();
     this.sendTimeoutMs = options.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
     this.listTimeoutMs = options.listTimeoutMs ?? DEFAULT_LIST_TIMEOUT_MS;
+    this.lastRequests = new LastMessageRequests(this.listTimeoutMs);
   }
 
   private failPending(error: Readonly<Error>): void {
@@ -122,6 +111,9 @@ export class IntercomClient extends EventEmitter {
   get supportsTopics(): boolean {
     return this.isConnected() && this._topicsSupported;
   }
+  get supportsGuardedDelivery(): boolean {
+    return this.isConnected() && this.guardedDeliverySupported;
+  }
   isConnected(): boolean {
     return (
       (this._sessionId ?? "").length > 0 &&
@@ -164,7 +156,8 @@ export class IntercomClient extends EventEmitter {
           this.connection = null;
           this._sessionId = null;
           this._topicsSupported = false;
-          this.lastMessagesSupported = false;
+          this.parking.settle(false);
+          this.guardedDeliverySupported = false;
           this.disconnecting = false;
           this.failPending(error);
           if (established && !expected) {
@@ -181,6 +174,9 @@ export class IntercomClient extends EventEmitter {
           requestedId,
           topicFrames: true,
           lastMessages: true,
+          parking: true,
+          receiptReads: 1,
+          guardedDelivery: 1,
         });
       } catch (error) {
         if (this.connection === connection) {
@@ -245,11 +241,15 @@ export class IntercomClient extends EventEmitter {
       case "delivery_failed":
         this.receiveDelivery(brokerMessage);
         break;
+      case "parked":
+        this.parking.settle(true);
+        break;
+      case "wake":
       case "session_left":
         if (typeof brokerMessage.sessionId !== "string") {
-          throw new Error("Invalid session_left message");
+          throw new Error(`Invalid ${type} message`);
         }
-        this.emit("session_left", brokerMessage.sessionId);
+        this.emit(type, brokerMessage.sessionId);
         break;
       default:
         throw new Error(`Unknown broker message type: ${type}`);
@@ -265,18 +265,18 @@ export class IntercomClient extends EventEmitter {
     }
     this._sessionId = msg.sessionId;
     this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
-    this.lastMessagesSupported = msg.lastMessages === true;
+    this.lastRequests.lastMessages = msg.lastMessages === true;
+    this.parking.supported = msg.parking === true;
+    this.lastRequests.receiptReads = msg.receiptReads === 1;
+    this.guardedDeliverySupported = msg.guardedDelivery === 1;
     this.connection?.confirmRegistration();
     this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
   }
 
   private receiveLastRequest(msg: UnknownRecord): void {
-    const from = normalizeSessionInfo(msg.from);
-    if (typeof msg.requestId !== "string" || !from || !isLastMessageQuery(msg.query)) {
-      throw new Error("Invalid last-message request");
-    }
-    if (!this.emit("last_request", { requestId: msg.requestId, from, query: msg.query })) {
-      this.respondLast(msg.requestId, { error: "Recipient has no last-message reader." });
+    const request = lastRequest(msg);
+    if (!this.emit("last_request", request)) {
+      this.respondLast(request.requestId, { error: "Recipient has no last-message reader." });
     }
   }
 
@@ -337,6 +337,10 @@ export class IntercomClient extends EventEmitter {
     }
   }
 
+  park(on = true): Promise<boolean> {
+    return this.parking.request(() => this.requireActiveSocket(), on);
+  }
+
   async disconnect(): Promise<void> {
     const connection = this.connection;
     if (!connection) {
@@ -351,20 +355,15 @@ export class IntercomClient extends EventEmitter {
     return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
   }
 
-  last(to: string, query: LastMessageQuery = {}): Promise<LastMessageResult> {
-    try {
-      const socket = this.requireActiveSocket();
-      if (!this.lastMessagesSupported) {
-        throw new Error("This broker does not support last-message reads; reload after it exits.");
-      }
-      return this.lastRequests.request(socket, to, query, this.listTimeoutMs);
-    } catch (error) {
-      return Promise.reject(toError(error));
-    }
+  async last(to: string, query: LastMessageQuery = {}): Promise<LastMessageResult> {
+    return await this.lastRequests.last(this.requireActiveSocket(), to, query);
+  }
+  async receipt(to: string, query: ReceiptQuery): Promise<ReceiptResult> {
+    return await this.lastRequests.receipt(this.requireActiveSocket(), to, query);
   }
 
   respondLast(requestId: string, result: unknown): void {
-    if (!isLastMessageResult(result)) {
+    if (!isNativeReadResult(result)) {
       throw new Error("Invalid last-message result");
     }
     writeMessage(this.requireActiveSocket(), { type: "last_response", requestId, result });
@@ -410,7 +409,9 @@ export class IntercomClient extends EventEmitter {
       const timeout = setTimeout(() => {
         if (this.pendingLists.has(requestId)) {
           this.pendingLists.delete(requestId);
-          wrappedReject(new Error("List sessions timeout"));
+          wrappedReject(
+            Object.assign(new Error("List sessions timeout"), { code: "list_timeout" }),
+          );
         }
       }, this.listTimeoutMs);
       timeout.unref();
@@ -434,20 +435,33 @@ export class IntercomClient extends EventEmitter {
     });
   }
 
+  private requireSendSocket(options: SendOptions): net.Socket {
+    const socket = this.requireActiveSocket();
+    if (options.guard && !this.guardedDeliverySupported) {
+      throw new Error("This broker does not support guarded delivery; no message sent.");
+    }
+    return socket;
+  }
+
   send(to: string, options: SendOptions): Promise<SendResult> {
     let socket: net.Socket;
     try {
-      socket = this.requireActiveSocket();
+      socket = this.requireSendSocket(options);
     } catch (error) {
       return Promise.reject(toError(error));
     }
 
-    const messageId = options.messageId ?? randomUUID();
+    const messageId = options.messageId ?? (options.guard ? "" : randomUUID());
+    if (this.pendingSends.has(messageId)) {
+      return Promise.reject(new Error("Message ID already has a pending send"));
+    }
     const message: Message = {
       id: messageId,
       timestamp: Date.now(),
       replyTo: options.replyTo,
       expectsReply: options.expectsReply,
+      guard: options.guard,
+      replyHint: options.replyHint,
       ...(options.human ? { human: options.human } : {}),
       ...(options.topic ? { topic: options.topic } : {}),
       delivery: messageDelivery(options),
@@ -460,6 +474,9 @@ export class IntercomClient extends EventEmitter {
       },
     };
 
+    if ((options.guard || options.replyHint) && normalizeMessage(message) === null) {
+      return Promise.reject(new Error("Invalid message format"));
+    }
     return new Promise((resolve, reject) => {
       const wrappedResolve = (result: SendResult) => {
         clearTimeout(timeout);
@@ -493,6 +510,7 @@ export class IntercomClient extends EventEmitter {
   }
 
   updatePresence(updates: {
+    readonly applicationGuard?: string | null;
     readonly name?: string;
     readonly status?: string;
     readonly model?: string;