@etazio/agent-sdk 0.1.0

package/index.js

@@ -0,0 +1,1752 @@
+// src/index.ts
+import { EventEmitter } from "node:events";
+import { io } from "socket.io-client";
+
+// ../shared/src/roles.ts
+var ASSIGNABLE_ROLES = ["admin", "member", "guest"];
+var PERMISSIONS = [
+  "workspace.delete",
+  "workspace.transfer",
+  "workspace.update",
+  "members.read",
+  "members.manage",
+  "invitations.manage",
+  "office.edit",
+  "office.publish",
+  "desk.assign",
+  "desk.editOwn",
+  /** Freien Schreibtisch selbst sichern und eigenen Platz freigeben (SPA-125) – nur wenn der Workspace es erlaubt */
+  "desk.claim",
+  "avatar.edit",
+  "meeting.join",
+  "audit.read",
+  /** KI-Agenten sehen (SPA-66) */
+  "agents.read",
+  /** KI-Agenten anlegen, Scopes setzen, Token rotieren, abschalten (SPA-66) */
+  "agents.manage"
+];
+var MATRIX = {
+  owner: new Set(PERMISSIONS),
+  admin: /* @__PURE__ */ new Set([
+    "workspace.update",
+    "members.read",
+    "members.manage",
+    "invitations.manage",
+    "office.edit",
+    "office.publish",
+    "desk.assign",
+    "desk.editOwn",
+    "desk.claim",
+    "avatar.edit",
+    "meeting.join",
+    "audit.read",
+    "agents.read",
+    "agents.manage"
+  ]),
+  member: /* @__PURE__ */ new Set(["members.read", "desk.editOwn", "desk.claim", "avatar.edit", "meeting.join", "agents.read"]),
+  guest: /* @__PURE__ */ new Set(["meeting.join"])
+};
+
+// ../shared/src/chat.ts
+import { z } from "zod";
+var CHAT_GLYPH_LIMITS = {
+  /** Eine Reaktion ist genau ein sichtbares Zeichen – Skin-Tone und ZWJ-Sequenz eingeschlossen */
+  maxClusters: 1,
+  /** Harte Klammer über die Rohlänge: eine Familien-Sequenz mit Skin-Tones ist lang, aber nicht beliebig */
+  maxChars: 80
+};
+var segmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter("de", { granularity: "grapheme" }) : null;
+function graphemeCount(s) {
+  if (segmenter) {
+    let n = 0;
+    for (const _ of segmenter.segment(s)) n++;
+    return n;
+  }
+  return [...s.replace(new RegExp("(?:\\u{FE0F}|\\u{200D}\\p{Extended_Pictographic}|\\p{Emoji_Modifier}|[\\u{1F3FB}-\\u{1F3FF}]|[\\u{E0020}-\\u{E007F}])", "gu"), "")].length || (s ? 1 : 0);
+}
+var EMOJI_ONLY = new RegExp("^(?:\\p{Extended_Pictographic}|\\p{Emoji_Component}|\\p{Regional_Indicator}|[\\u{200D}\\u{FE0F}\\u{20E3}#*0-9])+$", "u");
+function isEmojiGlyph(s) {
+  if (!s || s.length > CHAT_GLYPH_LIMITS.maxChars) return false;
+  if (!EMOJI_ONLY.test(s)) return false;
+  if (/^[#*0-9]+$/.test(s)) return false;
+  return graphemeCount(s) <= CHAT_GLYPH_LIMITS.maxClusters;
+}
+var glyphSchema = z.string().min(1).max(CHAT_GLYPH_LIMITS.maxChars).refine(isEmojiGlyph, { message: "Nur ein einzelnes Emoji" });
+var CHAT_BLOCK_LIMITS = {
+  /** Blöcke je Nachricht */
+  maxBlocks: 3,
+  maxTitle: 120,
+  maxDescription: 600,
+  maxFields: 10,
+  maxFieldLabel: 60,
+  maxFieldValue: 240,
+  maxActions: 4,
+  maxActionLabel: 40,
+  /** Weiter als das darf ein Ablaufzeitpunkt nicht in der Zukunft liegen */
+  maxTtlMs: 7 * 24 * 60 * 60 * 1e3
+};
+var CHAT_ACTION_STYLES = ["primary", "secondary", "danger"];
+var blockIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,31}$/, "Ung\xFCltige Block-ID");
+var actionIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,31}$/, "Ung\xFCltige Aktions-ID");
+var blockFieldSchema = z.object({
+  label: z.string().trim().min(1).max(CHAT_BLOCK_LIMITS.maxFieldLabel),
+  value: z.string().trim().min(1).max(CHAT_BLOCK_LIMITS.maxFieldValue)
+});
+var blockActionSchema = z.object({
+  id: actionIdSchema,
+  label: z.string().trim().min(1).max(CHAT_BLOCK_LIMITS.maxActionLabel),
+  style: z.enum(CHAT_ACTION_STYLES).default("secondary")
+});
+var confirmBlockInputSchema = z.object({
+  type: z.literal("confirm"),
+  id: blockIdSchema,
+  title: z.string().trim().min(1).max(CHAT_BLOCK_LIMITS.maxTitle),
+  description: z.string().trim().max(CHAT_BLOCK_LIMITS.maxDescription).nullish(),
+  fields: z.array(blockFieldSchema).max(CHAT_BLOCK_LIMITS.maxFields).default([]),
+  actions: z.array(blockActionSchema).min(1).max(CHAT_BLOCK_LIMITS.maxActions),
+  expiresAt: z.string().datetime().nullish()
+}).refine((b) => new Set(b.actions.map((a) => a.id)).size === b.actions.length, { message: "Aktions-IDs m\xFCssen eindeutig sein" });
+var chatBlockInputSchema = z.discriminatedUnion("type", [confirmBlockInputSchema]);
+var chatBlocksInputSchema = z.array(chatBlockInputSchema).max(CHAT_BLOCK_LIMITS.maxBlocks).refine((bs) => new Set(bs.map((b) => b.id)).size === bs.length, { message: "Block-IDs m\xFCssen eindeutig sein" });
+var chatActionSchema = z.object({
+  blockId: blockIdSchema,
+  actionId: actionIdSchema
+});
+
+// ../shared/src/schemas.ts
+import { z as z2 } from "zod";
+var emailSchema = z2.string().trim().toLowerCase().email().max(254);
+var passwordSchema = z2.string().min(10, "Mindestens 10 Zeichen").max(200);
+var displayNameSchema = z2.string().trim().min(1).max(60);
+var registerSchema = z2.object({
+  email: emailSchema,
+  password: passwordSchema,
+  displayName: displayNameSchema
+});
+var loginSchema = z2.object({
+  email: emailSchema,
+  password: z2.string().min(1).max(200)
+});
+var magicLinkRequestSchema = z2.object({ email: emailSchema });
+var magicLinkConsumeSchema = z2.object({ token: z2.string().min(20).max(200) });
+var slugSchema = z2.string().trim().toLowerCase().regex(/^[a-z0-9](?:[a-z0-9-]{1,38}[a-z0-9])?$/, "Nur Kleinbuchstaben, Ziffern und Bindestriche (3\u201340 Zeichen)");
+var createWorkspaceSchema = z2.object({
+  name: z2.string().trim().min(2).max(80),
+  slug: slugSchema.optional(),
+  /** Start-Office: leer (Default-Office) oder eine Generator-Vorlage (ID aus OFFICE_TEMPLATES) */
+  template: z2.string().regex(/^[a-z0-9_]{1,40}$/).optional()
+});
+var updateWorkspaceSchema = z2.object({
+  name: z2.string().trim().min(2).max(80).optional(),
+  /** Mitglieder dürfen freie Schreibtische selbst sichern (SPA-125) */
+  deskSelfClaim: z2.boolean().optional()
+}).refine((v) => v.name !== void 0 || v.deskSelfClaim !== void 0, { message: "Keine \xC4nderung angegeben" });
+var assignableRoleSchema = z2.enum(ASSIGNABLE_ROLES);
+var createInvitationSchema = z2.object({
+  email: emailSchema,
+  role: assignableRoleSchema.default("member")
+});
+var acceptInvitationSchema = z2.object({ token: z2.string().min(20).max(200) });
+var updateMemberRoleSchema = z2.object({ role: assignableRoleSchema });
+var transferOwnershipSchema = z2.object({ userId: z2.string().min(1) });
+var objectIdSchema = z2.string().regex(/^[a-f0-9]{24}$/, "Ung\xFCltige ID");
+var worldCoord = z2.number().finite().min(-1e3).max(1e3);
+var worldMoveSchema = z2.object({
+  seq: z2.number().int().min(0).max(1e12),
+  x: worldCoord,
+  z: worldCoord,
+  rotY: z2.number().finite(),
+  anim: z2.enum(["idle", "walk", "run"]),
+  t: z2.number().finite().optional()
+});
+var worldJoinSchema = z2.object({
+  workspaceId: objectIdSchema,
+  participantId: z2.string().regex(/^[a-zA-Z0-9_-]{8,64}$/).optional()
+});
+var worldSitSchema = z2.object({ seatId: z2.string().regex(/^[a-zA-Z0-9_-]{1,64}(:[a-z0-9_]{1,32})?$/) });
+var opIdSchema = z2.string().regex(/^[a-zA-Z0-9_-]{8,64}$/);
+var applyOpEnvelopeSchema = z2.object({
+  baseVersion: z2.number().int().min(0),
+  opId: opIdSchema,
+  op: z2.unknown()
+});
+var publishSchema = z2.object({
+  baseVersion: z2.number().int().min(0).optional(),
+  note: z2.string().trim().max(200).optional()
+});
+var lockSchema = z2.object({ force: z2.boolean().optional() });
+var deskAssignmentSchema = z2.object({ userId: objectIdSchema.nullable() });
+var deskIdSchema = z2.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var DESK_LIMITS = {
+  /** Gegenstände je Schreibtisch (Objektbudget, Roadmap §6) */
+  maxItems: 12,
+  /** Versatz auf der Ankerebene in Metern (je Achse; `DESK_ANCHOR_MAX_OFFSET` in scene-schema) */
+  maxOffset: 0.15,
+  /** Obergrenze für die lokale Position frei abgelegter Gegenstände (`anchor: 'surface'`, SPA-95) – die Tischplatte begrenzt enger */
+  maxSurfaceOffset: 1.5,
+  maxLabel: 40
+};
+var materialOverrideDtoSchema = z2.object({
+  color: z2.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+  roughness: z2.number().min(0).max(1).optional(),
+  metalness: z2.number().min(0).max(1).optional()
+});
+var overridesSchema = z2.record(z2.string().max(64), materialOverrideDtoSchema);
+var offsetCoord = z2.number().finite().min(-DESK_LIMITS.maxSurfaceOffset).max(DESK_LIMITS.maxSurfaceOffset);
+var deskItemSchema = z2.object({
+  id: z2.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+  asset: z2.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+  /** Ankername oder `surface` = frei auf der Tischplatte (SPA-95) */
+  anchor: z2.string().regex(/^[a-z0-9_]{1,32}$/),
+  offset: z2.tuple([offsetCoord, offsetCoord]).default([0, 0]),
+  rotationY: z2.number().finite().min(-360).max(360).default(0),
+  overrides: overridesSchema.optional()
+});
+var deskCustomizationInputSchema = z2.object({
+  label: z2.string().trim().max(DESK_LIMITS.maxLabel).nullable().default(null),
+  items: z2.array(deskItemSchema).max(DESK_LIMITS.maxItems).default([]),
+  overrides: overridesSchema.default({}),
+  chair: overridesSchema.default({})
+});
+var inventoryItemIdSchema = z2.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var zoneIdSchema = z2.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var meetingTokenSchema = z2.object({ target: z2.union([z2.literal("office"), zoneIdSchema]) });
+var zoneAccessInputSchema = z2.object({ userIds: z2.array(objectIdSchema).max(200) });
+var mediaStateSchema = z2.object({ mic: z2.boolean(), cam: z2.boolean(), screen: z2.boolean(), presence: z2.enum(["frei", "fokus", "weg"]).default("frei") });
+var zoneKnockSchema = z2.object({ zoneId: zoneIdSchema });
+var zoneAdmitSchema = z2.object({ zoneId: zoneIdSchema, userId: objectIdSchema, allow: z2.boolean() });
+var CHAT_LIMITS = { maxText: 2e3, pageSize: 50 };
+var convSchema = z2.string().regex(/^(room:(office|[a-zA-Z0-9_-]{1,64})|dm:[a-f0-9]{24}:[a-f0-9]{24})$/);
+var sendMessageSchema = z2.object({
+  conv: convSchema,
+  text: z2.string().trim().min(1).max(CHAT_LIMITS.maxText),
+  parentId: objectIdSchema.optional(),
+  /** Thread-Antwort zusätzlich im Kanal zeigen (Slack-Verhalten) – nur zusammen mit `parentId` */
+  alsoToChannel: z2.boolean().optional(),
+  /** Strukturierte Blöcke; nur Agenten und der Server dürfen sie setzen (Prüfung im Chat-Dienst) */
+  blocks: chatBlocksInputSchema.optional()
+}).refine((v) => !v.alsoToChannel || !!v.parentId, { message: "Nur Thread-Antworten k\xF6nnen zus\xE4tzlich in den Kanal" });
+var reactionSchema = z2.object({ glyph: glyphSchema });
+var chatTypingSchema = z2.object({ conv: convSchema, parentId: objectIdSchema.nullish(), typing: z2.boolean() });
+var readSchema = z2.object({ conv: convSchema });
+var messagesQuerySchema = z2.object({
+  conv: convSchema,
+  before: z2.string().datetime().optional(),
+  parentId: objectIdSchema.optional(),
+  limit: z2.coerce.number().int().min(1).max(200).default(CHAT_LIMITS.pageSize)
+});
+var OBJECT_LIMITS = {
+  /** Objektzustand als JSON, Bytes */
+  maxStateBytes: 2048,
+  /** Zustandsänderungen je Teilnehmer und Sekunde */
+  statePerSecond: 5,
+  /** Aktionen je Teilnehmer und Sekunde */
+  actionsPerSecond: 3,
+  /** Reaktionen (Glyph über dem Kopf) je Sekunde */
+  reactPerSecond: 1
+};
+var stateValueSchema = z2.union([z2.string().max(1024), z2.number().finite(), z2.boolean(), z2.null()]);
+var worldObjectIdSchema = z2.string().regex(/^[a-zA-Z0-9_-]{1,64}(:[a-zA-Z0-9_-]{1,64})?$/);
+var objectStateSchema = z2.object({
+  placementId: worldObjectIdSchema,
+  state: z2.record(z2.string().max(32), stateValueSchema).refine((s) => JSON.stringify(s).length <= OBJECT_LIMITS.maxStateBytes, { message: "Zustand zu gro\xDF" })
+});
+var objectActionSchema = z2.object({
+  placementId: deskIdSchema,
+  action: z2.string().regex(/^[a-z][a-z0-9_]{0,31}$/),
+  data: z2.record(z2.string().max(32), stateValueSchema).optional()
+});
+var reactSchema = z2.object({ glyph: glyphSchema });
+
+// ../shared/src/events.ts
+var SOCKET_EVENTS = {
+  // Client → Server
+  workspaceJoin: "workspace:join",
+  workspaceLeave: "workspace:leave",
+  worldJoin: "world:join",
+  worldLeave: "world:leave",
+  worldMove: "world:move",
+  worldSit: "world:sit",
+  worldStand: "world:stand",
+  /** Winken (Phase 4): Server verteilt world:emote */
+  worldWave: "world:wave",
+  /** Eigener Medienstatus (Phase 5): Server verteilt world:media */
+  worldMedia: "world:media",
+  /** An einer privaten Zone klopfen (Phase 5) – Hosts in der Zone bekommen zone:knocked */
+  zoneKnock: "zone:knock",
+  /** Host lässt einen Klopfenden ein oder lehnt ab (Phase 5) */
+  zoneAdmit: "zone:admit",
+  /** Reaktion über dem Kopf (Phase 7): Server verteilt world:emote mit Glyph */
+  worldReact: "world:react",
+  // Phase 7: interaktive Objekte
+  /** Objektzustand setzen (Client → Server mit Ack) und verteilen (Server → Client), Payload: ObjectStatePayload */
+  objectState: "object:state",
+  /** Einmalige Aktion an einem Objekt (Client → Server mit Ack) und verteilen (Server → Client), Payload: ObjectActionPayload */
+  objectAction: "object:action",
+  /** Whiteboard-Operation (Client → Server mit Ack {version}) und verteilen (Server → Client), Payload: BoardOpPayload */
+  boardOp: "board:op",
+  /** Whiteboard laden (Client → Server mit Ack BoardSyncPayload) */
+  boardSync: "board:sync",
+  /** Zeigerposition auf einem Whiteboard (flüchtig, ohne Ack, beide Richtungen), Payload: BoardCursorPayload */
+  boardCursor: "board:cursor",
+  // Phase 7f: Web-Anzeige am Fernseher (Server-Browser)
+  /** Web-Anzeige eines TVs abonnieren/abbestellen (Client → Server mit Ack WebStatusPayload), Payload: WebWatchPayload */
+  webWatch: "web:watch",
+  /** Steuerung übernehmen/abgeben (Client → Server mit Ack WebControlPayload), Payload: { placementId, take } */
+  webControl: "web:control",
+  /** Eingabe an den Server-Browser (Client → Server, ohne Ack), Payload: { placementId, event } */
+  webInput: "web:input",
+  /** Navigation im Server-Browser (Client → Server mit Ack), Payload: { placementId, action, url? } */
+  webNavigate: "web:navigate",
+  /** Sichtfeld des Server-Browsers an die Anzeigegröße des Steuernden angleichen (Client → Server mit Ack), Payload: WebResizePayload */
+  webResize: "web:resize",
+  // SPA-66: KI-Agenten
+  /** Handshake eines Agenten (Agent → Server mit Ack AgentHelloResult), Payload: AgentHelloInput */
+  agentHello: "agent:hello",
+  /** Laufbefehl mit serverseitiger Wegfindung (Agent → Server mit Ack), Payload: AgentGoToInput */
+  agentGoTo: "agent:goTo",
+  /** LiveKit-Token für den Raum, in dem der Agent steht (Agent → Server mit Ack MeetingTokenDto) */
+  agentMeetingToken: "agent:meetingToken",
+  /** Mensch spricht einen Agenten an (Browser → Server mit Ack), Payload: agentInvokeSchema */
+  agentInvoke: "agent:invoke",
+  // SPA-83: Sprachschleife
+  /** Der Agent meldet, was er gerade tut (Agent → Server mit Ack), Payload: agentVoiceStateSchema */
+  agentVoiceState: "agent:voice:state",
+  /** Mensch beendet das Sprachgespräch (Browser → Server mit Ack), Payload: voiceCloseSchema */
+  voiceClose: "voice:close",
+  /** Chat-Nachricht senden (Client → Server mit Ack ChatMessageDto), Payload: sendMessageSchema – der Weg für Agenten */
+  chatSend: "chat:send",
+  /** „Schreibt gerade“ melden (Client → Server, ohne Ack), Payload: chatTypingSchema – Menschen und Agenten (SPA-133) */
+  chatTyping: "chat:typing",
+  // Server → Client
+  presenceJoined: "presence:joined",
+  presenceLeft: "presence:left",
+  sessionRevoked: "session:revoked",
+  worldTick: "world:tick",
+  worldParticipantJoined: "world:participantJoined",
+  worldParticipantLeft: "world:participantLeft",
+  worldPresence: "world:presence",
+  /** Dieselbe Person ist woanders beigetreten – diese Verbindung wird abgelöst (SPA-104) */
+  worldSuperseded: "world:superseded",
+  worldSeat: "world:seat",
+  worldCorrect: "world:correct",
+  /** Neue Office-Revision veröffentlicht (Payload: OfficePublishedPayload) */
+  officePublished: "office:published",
+  /** Arbeitsplatzzuweisungen geändert (Payload: { assignments: DeskAssignmentDto[] }) */
+  officeAssignments: "office:assignments",
+  /** Entwurf geändert (Payload: OfficeDraftChangedPayload) – für parallel geöffnete Editoren */
+  officeDraftChanged: "office:draftChanged",
+  /** Avatar-Profil eines Teilnehmers geändert (Payload: WorldAvatarPayload) */
+  worldAvatar: "world:avatar",
+  /** Einmalige Geste eines Teilnehmers (Payload: WorldEmotePayload) */
+  worldEmote: "world:emote",
+  /** Persönliche Einrichtung eines Schreibtischs geändert (Payload: OfficeDeskPayload) */
+  officeDesk: "office:desk",
+  /** Inventar eines Mitglieds geändert (Payload: { workspaceId, userId }) – Client lädt sein Inventar neu */
+  officeInventory: "office:inventory",
+  // Phase 5: Zonen, Medien, Chat
+  /** Zone eines Teilnehmers geändert (Payload: WorldZonePayload) */
+  worldZone: "world:zone",
+  /** Es klopft an einer privaten Zone (Payload: ZoneKnockedPayload) – nur an Hosts in der Zone */
+  zoneKnocked: "zone:knocked",
+  /** Antwort auf das eigene Klopfen (Payload: ZoneAdmittedPayload) */
+  zoneAdmitted: "zone:admitted",
+  /** Dauerhafte oder sitzungsweite Freigaben einer Zone geändert (Payload: ZoneAccessPayload) */
+  zoneAccess: "zone:access",
+  /** Neue Chat-Nachricht (Payload: ChatMessagePayload) */
+  chatMessage: "chat:message",
+  /** Reaktionen einer Nachricht geändert (Payload: ChatReactionPayload) */
+  chatReaction: "chat:reaction",
+  /** Jemand schreibt gerade bzw. nicht mehr (Payload: ChatTypingPayload) – verfällt beim Empfänger nach CHAT_TYPING_TTL_MS */
+  chatTypingUpdate: "chat:typingUpdate",
+  /** Der Nutzer wurde aus dem Workspace entfernt (Payload: { workspaceId }) – Client verlässt das Office */
+  workspaceRemoved: "workspace:removed",
+  /** Workspace-Einstellungen geändert (Payload: WorkspaceSettingsPayload, SPA-125) */
+  workspaceSettings: "workspace:settings",
+  /** Fortschritt eines KI-Generator-Jobs (Payload: GeneratorProgressPayload) – an den Workspace-Raum */
+  generatorProgress: "generator:progress",
+  /** Neues Bild der Web-Anzeige (Payload: WebFramePayload) – nur an Abonnenten */
+  webFrame: "web:frame",
+  /** Zustand der Web-Anzeige (Payload: WebStatusPayload) – Laden, Fehler, Adresse, Steuerung */
+  webStatus: "web:status",
+  /** Jemand spricht den Agenten an (Payload: AgentAddressPayload) – nur an den betroffenen Agenten */
+  agentAddress: "agent:address",
+  /** Der Agent wurde gedrosselt (Payload: AgentThrottledPayload) */
+  agentThrottled: "agent:throttled",
+  /** Token rotiert, Agent deaktiviert oder gelöscht (Payload: AgentRevokedPayload) – Verbindung endet danach */
+  agentRevoked: "agent:revoked",
+  /** Sprachgespräch eröffnet oder beendet (Payload: AgentVoicePayload) – nur an den betroffenen Agenten (SPA-83) */
+  agentVoice: "agent:voice",
+  /** Gesprächszustand für die Oberfläche (Payload: VoiceSessionPayload) – an den Workspace-Raum (SPA-83) */
+  voiceSession: "voice:session"
+};
+var CHAT_TYPING_REFRESH_MS = 3e3;
+
+// ../shared/src/avatar.ts
+import { z as z3 } from "zod";
+var AVATAR_RIG_VERSION = 2;
+var AVATAR_BODIES = ["slim", "standard", "broad"];
+var AVATAR_HEIGHTS = ["short", "medium", "tall"];
+var AVATAR_HAIRS = ["none", "short", "long", "bun"];
+var AVATAR_TOPS = ["tshirt", "longsleeve", "hoodie"];
+var AVATAR_ACCESSORIES = ["glasses", "headphones", "cap"];
+var hex = z3.string().regex(/^#[0-9a-fA-F]{6}$/, "Farbe als #rrggbb");
+var avatarProfileSchema = z3.object({
+  rigVersion: z3.literal(AVATAR_RIG_VERSION).default(AVATAR_RIG_VERSION),
+  body: z3.enum(AVATAR_BODIES).default("standard"),
+  height: z3.enum(AVATAR_HEIGHTS).default("medium"),
+  hair: z3.enum(AVATAR_HAIRS).default("short"),
+  top: z3.enum(AVATAR_TOPS).default("tshirt"),
+  accessories: z3.array(z3.enum(AVATAR_ACCESSORIES)).max(AVATAR_ACCESSORIES.length).default([]),
+  colors: z3.object({
+    skin: hex.default("#deae8c"),
+    hair: hex.default("#402b1f"),
+    shirt: hex.default("#386b9e"),
+    pants: hex.default("#333642"),
+    shoes: hex.default("#1f1f21"),
+    accent: hex.default("#d97340")
+  }).prefault({})
+}).transform((p) => ({ ...p, accessories: [...new Set(p.accessories)] })).refine((p) => !(p.accessories.includes("cap") && p.accessories.includes("headphones")), { message: "Kappe und Kopfh\xF6rer passen nicht zusammen" });
+
+// ../shared/src/agents.ts
+import { z as z4 } from "zod";
+var AGENT_PROTOCOL = "agent-protocol/v1";
+var AGENT_SCOPES = [
+  "office.read",
+  "world.presence",
+  "world.move",
+  "world.seat",
+  "world.react",
+  "chat.read",
+  "chat.write",
+  "object.state",
+  "object.action",
+  "board.write",
+  "tv.control",
+  "zone.knock",
+  "meeting.audio",
+  "voice.listen",
+  "voice.speak",
+  "tools.use"
+];
+var AGENT_DEFAULT_SCOPES = ["office.read", "world.presence", "world.move", "chat.read", "chat.write"];
+function hasScope(scopes, scope) {
+  return !!scopes && scopes.includes(scope);
+}
+var AGENT_LIMITS = {
+  /** Agenten je Workspace */
+  perWorkspace: 10,
+  /** Gleichzeitige Verbindungen je Agent */
+  connections: 4,
+  /** Chat-Nachrichten je Minute */
+  chatPerMinute: 30,
+  /** Bewegungsbefehle (`agent:goTo`) je Minute */
+  goToPerMinute: 20,
+  /** Objektzustände je Sekunde */
+  statePerSecond: 10,
+  /** Objektaktionen je Sekunde */
+  actionsPerSecond: 5,
+  /** Reaktionen je Sekunde */
+  reactPerSecond: 2,
+  /** Ereignisse insgesamt je Sekunde (harte Klammer über allem) */
+  eventsPerSecond: 40,
+  /** So oft darf ein Agent gedrosselt werden, bevor die Verbindung fällt */
+  throttleStrikes: 5,
+  /** Ohne Lebenszeichen gilt eine Verbindung als hängend (ms) */
+  idleMs: 10 * 6e4,
+  maxName: 60,
+  maxDescription: 400,
+  /** Zonen, auf die ein Agent hören kann */
+  maxZones: 20,
+  // --- Sprache (SPA-83) ---
+  /** Gleichzeitige Sprachsitzungen je Agent */
+  voiceSessions: 3,
+  /** Gleichzeitige Sprachsitzungen je Workspace (über alle Agenten) */
+  voiceSessionsPerWorkspace: 6,
+  /** Gesprochene Sekunden je Minute und Agent – darüber wird gedrosselt */
+  voiceSecondsPerMinute: 45,
+  /** Stille im Gespräch, nach der der Server die Sitzung beendet (ms) */
+  voiceIdleMs: 45e3,
+  /** Harte Obergrenze für eine einzelne Sprachsitzung (ms) */
+  voiceMaxSessionMs: 15 * 6e4,
+  /** Zustandsmeldungen des Agenten je Sekunde (`agent:voice:state`) */
+  voiceStatePerSecond: 10,
+  /** Externe Werkzeugaufrufe je Minute und Agent */
+  toolCallsPerMinute: 20,
+  /** Aufrufe desselben externen Werkzeugs je Minute und Agent */
+  toolCallsPerToolPerMinute: 10,
+  /** Verbindungen, die ein Workspace verwalten darf */
+  connectionsPerWorkspace: 20
+};
+var AGENT_CAPABILITIES = ["chat", "voice", "board", "tv", "move"];
+var AGENT_CONNECTION_KINDS = ["mcp-http", "notion", "google"];
+var AGENT_TOOL_ACCESS = ["read", "read-write"];
+var AGENT_CONNECTION_AUTH = ["none", "token", "oauth"];
+var agentNameSchema = z4.string().trim().min(1).max(AGENT_LIMITS.maxName);
+var agentScopeSchema = z4.enum(AGENT_SCOPES);
+var agentCapabilitySchema = z4.enum(AGENT_CAPABILITIES);
+var zoneRef = z4.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var agentAddressingSchema = z4.object({
+  mention: z4.boolean().default(true),
+  proximity: z4.boolean().default(true),
+  zones: z4.array(zoneRef).max(AGENT_LIMITS.maxZones).default([]),
+  desk: z4.boolean().default(false)
+});
+var agentEndpointSchema = z4.string().url().max(500).refine((u) => u.startsWith("https://"), { message: "Nur https" });
+var createAgentSchema = z4.object({
+  name: agentNameSchema,
+  description: z4.string().trim().max(AGENT_LIMITS.maxDescription).default(""),
+  /** Standard ist der Kundenserver: mitgelieferte Agenten legt unser eigener Dienst an, nicht das UI */
+  operator: z4.enum(["intern", "extern"]).default("extern"),
+  endpointUrl: agentEndpointSchema.nullable().default(null),
+  scopes: z4.array(agentScopeSchema).max(AGENT_SCOPES.length).default([...AGENT_DEFAULT_SCOPES]),
+  capabilities: z4.array(agentCapabilitySchema).max(AGENT_CAPABILITIES.length).default(["chat"]),
+  addressing: agentAddressingSchema.prefault({}),
+  avatar: avatarProfileSchema.optional(),
+  homeDeskId: z4.string().regex(/^[a-zA-Z0-9_-]{1,64}$/).nullable().default(null)
+});
+var updateAgentSchema = createAgentSchema.partial().extend({
+  status: z4.enum(["active", "disabled"]).optional()
+});
+var workspaceAgentSettingsSchema = z4.object({
+  /** Kill-Switch für alle Fremdagenten des Workspaces */
+  externalAgentsDisabled: z4.boolean()
+});
+var toolNameSchema = z4.string().trim().min(1).max(160).regex(/^[a-zA-Z0-9_.:/-]+$/);
+var headerNameSchema = z4.string().trim().min(1).max(120).regex(/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/, "Ung\xFCltiger Headername");
+var headerValueSchema = z4.string().max(4e3).refine((value) => !/[\u0000-\u001f\u007f]/.test(value), "Steuerzeichen sind nicht erlaubt");
+var connectionHeadersSchema = z4.record(headerNameSchema, headerValueSchema).refine(
+  (headers) => Object.keys(headers).length <= 20,
+  { message: "H\xF6chstens 20 Kopfzeilen" }
+);
+var createAgentConnectionSchema = z4.object({
+  kind: z4.enum(AGENT_CONNECTION_KINDS).default("mcp-http"),
+  name: z4.string().trim().min(1).max(80),
+  // Protokoll und private Ziele prüft die API mit DNS-Auflösung und Allowlist; eine reine
+  // startsWith-Prüfung würde ausdrücklich erlaubte interne http-MCP-Server blockieren.
+  url: z4.string().url().max(1e3),
+  auth: z4.enum(AGENT_CONNECTION_AUTH).default("token"),
+  /** Bearer-/OAuth-Token; wird nie zurückgegeben und verschlüsselt gespeichert. */
+  token: z4.string().max(8e3).nullable().optional(),
+  /** Zusätzliche feste Auth-Header; Werte werden nie zurückgegeben. */
+  headers: connectionHeadersSchema.optional(),
+  status: z4.enum(["active", "disabled"]).default("active")
+});
+var updateAgentConnectionSchema = createAgentConnectionSchema.partial();
+var agentToolGrantSchema = z4.object({
+  access: z4.enum(AGENT_TOOL_ACCESS).default("read"),
+  tools: z4.array(toolNameSchema).max(200).default([])
+});
+var agentHelloSchema = z4.object({
+  protocol: z4.literal(AGENT_PROTOCOL),
+  workspaceId: objectIdSchema.optional(),
+  capabilities: z4.array(agentCapabilitySchema).max(AGENT_CAPABILITIES.length).default([]),
+  client: z4.object({ name: z4.string().trim().max(80).default("unbekannt"), version: z4.string().trim().max(40).default("0") }).prefault({}),
+  /** Bei Reconnect: bisherige Teilnehmer-ID, um Position und Sitzplatz zu behalten */
+  participantId: z4.string().regex(/^[a-zA-Z0-9_-]{8,64}$/).optional()
+});
+var agentGoToSchema = z4.union([
+  z4.object({ x: z4.number().finite().min(-1e3).max(1e3), z: z4.number().finite().min(-1e3).max(1e3) }),
+  z4.object({ zoneId: zoneRef }),
+  z4.object({ participantId: z4.string().min(8).max(64) })
+]);
+var agentMeetingTokenSchema = z4.object({ target: z4.union([z4.literal("office"), zoneRef]).default("office") });
+var agentInvokeSchema = z4.object({
+  agentParticipantId: z4.string().min(8).max(64),
+  text: z4.string().trim().max(2e3).optional(),
+  /** Gespräch per Sprache eröffnen (SPA-83). Ohne das bleibt es beim Chat wie bisher. */
+  voice: z4.boolean().default(false)
+});
+var AGENT_VOICE_STATES = ["idle", "listening", "thinking", "speaking"];
+var agentVoiceStateSchema = z4.object({
+  sessionId: z4.string().min(8).max(64),
+  state: z4.enum(AGENT_VOICE_STATES),
+  /** Was zuletzt verstanden bzw. gesagt wurde – nur für Anzeige und Protokoll, optional */
+  text: z4.string().trim().max(2e3).optional()
+});
+var voiceCloseSchema = z4.object({ agentParticipantId: z4.string().min(8).max(64) });
+
+// ../shared/src/view.ts
+import { z as z5 } from "zod";
+var VIEW_PRESETS = ["auto", "top", "iso", "third"];
+var CAMERA_FOLLOW = ["follow", "loose", "free"];
+var CAMERA_ROTATE = ["auto", "fixed", "snap90", "free"];
+var WALL_MODES = ["auto", "cutaway", "transparent", "cap", "never"];
+var CEILING_MODES = ["auto", "show", "hide"];
+var CLICK_MOVE = ["double", "single", "off"];
+var KEY_AXES = ["auto", "camera", "world"];
+var RUN_MODES = ["shift", "toggle", "always"];
+var DETAIL_LEVELS = ["auto", "low", "high"];
+var ZOOM_RANGE = {
+  auto: [1.2, 40],
+  top: [6, 40],
+  iso: [4, 20],
+  third: [1.2, 12]
+};
+var ZOOM_DEFAULT = { auto: 9, top: 14, iso: 9, third: 5 };
+var zoom = (preset) => z5.number().finite().min(ZOOM_RANGE[preset][0]).max(ZOOM_RANGE[preset][1]).default(ZOOM_DEFAULT[preset]);
+var viewSettingsSchema = z5.object({
+  preset: z5.enum(VIEW_PRESETS).default("auto"),
+  /** Gemerkter Abstand je Preset */
+  zoom: z5.object({ auto: zoom("auto"), top: zoom("top"), iso: zoom("iso"), third: zoom("third") }).prefault({}),
+  follow: z5.enum(CAMERA_FOLLOW).default("loose"),
+  /** Nachführ-Härte 0…1 (weich … direkt) */
+  smoothing: z5.number().min(0).max(1).default(0.5),
+  rotate: z5.enum(CAMERA_ROTATE).default("auto"),
+  walls: z5.enum(WALL_MODES).default("auto"),
+  ceiling: z5.enum(CEILING_MODES).default("auto"),
+  clickMove: z5.enum(CLICK_MOVE).default("double"),
+  keyAxes: z5.enum(KEY_AXES).default("auto"),
+  run: z5.enum(RUN_MODES).default("shift"),
+  detail: z5.enum(DETAIL_LEVELS).default("auto"),
+  /**
+   * Konturen um Objekte und Avatare (SPA-89). Wirkt nur im Office-Stil `toon` – dort entscheidet der
+   * Admin über den Stil, der Nutzer über die Konturen, weil sie je Rechner spürbar Leistung kosten
+   * (eine zusätzliche Rückseiten-Hülle je Mesh).
+   */
+  outlines: z5.boolean().default(true)
+});
+
+// ../shared/src/board.ts
+import { z as z6 } from "zod";
+var BOARD_LIMITS = {
+  /** Punkte je Strich (inkl. Verlängerungen) */
+  maxPoints: 500,
+  /** Punkte je Operation (Segment beim Live-Zeichnen) */
+  maxSegment: 120,
+  maxText: 200,
+  /** Operationen im Log je Board; darüber verlangt der Server einen Snapshot */
+  maxOps: 5e3,
+  /** Nach so vielen Operationen seit dem Snapshot lädt der Client ein neues Snapshot-PNG hoch */
+  snapshotEvery: 200,
+  /** Snapshot-PNG als Base64, Bytes */
+  maxSnapshotBytes: 15e5,
+  /** Operationen je Teilnehmer und Sekunde */
+  opsPerSecond: 30,
+  /** Zeigerpositionen je Sekunde */
+  cursorHz: 10
+};
+var unit = z6.number().min(-0.05).max(1.05);
+var point = z6.tuple([unit, unit]);
+var boardId = z6.string().regex(/^[a-zA-Z0-9_-]{4,40}$/);
+var color = z6.string().regex(/^#[0-9a-fA-F]{6}$/);
+var boardOpSchema = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("stroke"), id: boardId, color, width: z6.number().min(1).max(24), points: z6.array(point).min(1).max(BOARD_LIMITS.maxSegment) }),
+  /** Weitere Punkte an einen Strich hängen (Live-Zeichnen in Segmenten) */
+  z6.object({ type: z6.literal("extend"), id: boardId, points: z6.array(point).min(1).max(BOARD_LIMITS.maxSegment) }),
+  z6.object({ type: z6.literal("note"), id: boardId, x: unit, y: unit, text: z6.string().trim().min(1).max(BOARD_LIMITS.maxText), color }),
+  z6.object({ type: z6.literal("move"), id: boardId, x: unit, y: unit }),
+  z6.object({ type: z6.literal("erase"), id: boardId }),
+  z6.object({ type: z6.literal("clear") })
+]);
+var boardOpEnvelopeSchema = z6.object({
+  placementId: z6.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+  opId: z6.string().regex(/^[a-zA-Z0-9_-]{8,64}$/),
+  baseVersion: z6.number().int().min(0),
+  op: boardOpSchema
+});
+var boardSyncRequestSchema = z6.object({ placementId: z6.string().regex(/^[a-zA-Z0-9_-]{1,64}$/) });
+var boardCursorSchema = z6.object({
+  placementId: z6.string().regex(/^[a-zA-Z0-9_-]{1,64}$/),
+  x: unit.nullable(),
+  y: unit.nullable()
+});
+var boardSnapshotSchema = z6.object({
+  /** Version, bis zu der das PNG alle Operationen enthält */
+  version: z6.number().int().min(1),
+  /** data:image/png;base64,… */
+  png: z6.string().regex(/^data:image\/png;base64,[A-Za-z0-9+/=]+$/).max(BOARD_LIMITS.maxSnapshotBytes)
+});
+
+// ../shared/src/tv.ts
+import { z as z8 } from "zod";
+
+// ../shared/src/images.ts
+import { z as z7 } from "zod";
+var IMAGE_LIMITS = {
+  /** Rohbytes je Bild (der Upload kommt als Base64 in JSON – der Body darf ~4/3 davon groß sein) */
+  maxBytes: 6 * 1024 * 1024,
+  /** Kantenlänge und Gesamtfläche (Schutz gegen Dekomprimierungsbomben) */
+  maxDimension: 8e3,
+  maxPixels: 4e7,
+  /** Bilder je Workspace */
+  maxPerWorkspace: 300,
+  maxNameLength: 80
+};
+var SLIDESHOW_IMAGE_PREFIX = "img:";
+var imageId = z7.string().regex(/^[0-9a-f]{24}$/);
+var imageName = z7.string().trim().min(1).max(IMAGE_LIMITS.maxNameLength);
+var imageUploadSchema = z7.object({
+  name: imageName,
+  /** data:image/png;base64,… */
+  data: z7.string().regex(/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/).max(Math.ceil(IMAGE_LIMITS.maxBytes * 4 / 3) + 100)
+});
+var imageRenameSchema = z7.object({ name: imageName });
+
+// ../shared/src/tv.ts
+var TV_SOURCES = ["auto", "off", "share", "video", "embed", "channel", "web"];
+var TV_CHANNELS = ["clock", "dashboard", "slideshow"];
+var TV_LIMITS = {
+  /** URL-Länge in Zeichen */
+  maxUrl: 1024,
+  maxTitle: 120,
+  /** Hosts, die als `embed` erlaubt sind */
+  embedHosts: ["youtube.com", "www.youtube.com", "m.youtube.com", "youtu.be", "vimeo.com", "www.vimeo.com", "player.vimeo.com"],
+  defaultVolume: 0.8,
+  /** Hörweite des Fernsehers in Metern (wie SCREEN_RANGE der Bindung) */
+  earshot: 6,
+  /** Diashow: Wechsel in Sekunden */
+  slideSeconds: 8,
+  /** `web`: Länge der Kanalliste (Rotation) in Zeichen */
+  maxWeb: 520
+};
+function parseUrl(u) {
+  const m = /^(?:([a-z][a-z0-9+.-]*):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?/i.exec(u.trim());
+  if (!m) return null;
+  const protocol = (m[1] ?? "").toLowerCase();
+  const host = (m[2] ?? "").toLowerCase().replace(/^[^@]*@/, "").replace(/:\d+$/, "");
+  const path = m[3] ?? "";
+  if (!protocol && !u.startsWith("/")) return null;
+  if (!protocol && u.startsWith("//")) return null;
+  const query = {};
+  for (const part of (m[4] ?? "").split("&")) {
+    if (!part) continue;
+    const [k, v = ""] = part.split("=");
+    try {
+      query[decodeURIComponent(k)] = decodeURIComponent(v);
+    } catch {
+    }
+  }
+  return { protocol, host, path, query };
+}
+var httpsUrl = z8.string().max(TV_LIMITS.maxUrl).refine((u) => {
+  if (u.trim().startsWith(SLIDESHOW_IMAGE_PREFIX)) return true;
+  const p = parseUrl(u);
+  return !!p && (p.protocol === "https" || p.protocol === "http" || p.protocol === "" && u.startsWith("/"));
+}, { message: "Nur https-Adressen oder Bilder aus der Mediathek" });
+var tvStateSchema = z8.object({
+  source: z8.enum(TV_SOURCES),
+  sharer: z8.string().min(1).max(64).optional(),
+  url: httpsUrl.optional(),
+  title: z8.string().max(TV_LIMITS.maxTitle).optional(),
+  playing: z8.boolean().optional(),
+  position: z8.number().min(0).max(1e7).optional(),
+  at: z8.number().min(0).optional(),
+  by: z8.string().max(64).optional(),
+  volume: z8.number().min(0).max(1).optional(),
+  channel: z8.enum(TV_CHANNELS).optional(),
+  loop: z8.boolean().optional(),
+  web: z8.string().max(TV_LIMITS.maxWeb).regex(/^[a-zA-Z0-9_,-]*$/).optional(),
+  rotate: z8.number().int().min(10).max(3600).optional()
+}).strict().superRefine((s, ctx) => {
+  if (s.source === "share" && !s.sharer) ctx.addIssue({ code: "custom", message: "share braucht sharer", path: ["sharer"] });
+  if ((s.source === "video" || s.source === "embed") && !s.url) ctx.addIssue({ code: "custom", message: "video/embed brauchen url", path: ["url"] });
+  if (s.source === "embed" && s.url && !embedInfo(s.url)) ctx.addIssue({ code: "custom", message: "embed: nur YouTube oder Vimeo", path: ["url"] });
+  if (s.source !== "web" && s.url && parseUrl(s.url)?.protocol === "http") ctx.addIssue({ code: "custom", message: "Nur https-Adressen", path: ["url"] });
+  if (s.source === "channel" && !s.channel) ctx.addIssue({ code: "custom", message: "channel braucht channel", path: ["channel"] });
+  if (s.source === "web" && !s.web && !s.url) ctx.addIssue({ code: "custom", message: "web braucht einen Kanal oder eine Adresse", path: ["web"] });
+  if (s.source !== "web" && (s.web || s.rotate)) ctx.addIssue({ code: "custom", message: "web/rotate nur bei source web", path: ["web"] });
+});
+function embedInfo(url) {
+  const u = parseUrl(url);
+  if (!u) return null;
+  const host = u.host;
+  if (!TV_LIMITS.embedHosts.includes(host)) return null;
+  if (host.includes("youtu")) {
+    let id = null;
+    if (host === "youtu.be") id = u.path.slice(1).split("/")[0] ?? null;
+    else if (u.path === "/watch") id = u.query.v ?? null;
+    else {
+      const m2 = u.path.match(/^\/(?:embed|shorts|live|v)\/([\w-]{6,})/);
+      id = m2 ? m2[1] : null;
+    }
+    if (!id || !/^[\w-]{6,20}$/.test(id)) return null;
+    return { provider: "youtube", id, poster: `https://i.ytimg.com/vi/${id}/hqdefault.jpg`, embedUrl: `https://www.youtube.com/embed/${id}?enablejsapi=1&playsinline=1&rel=0` };
+  }
+  const m = u.path.match(/\/(?:video\/)?(\d{5,})/);
+  if (!m) return null;
+  return { provider: "vimeo", id: m[1], poster: null, embedUrl: `https://player.vimeo.com/video/${m[1]}?api=1&playsinline=1` };
+}
+
+// ../shared/src/generator.ts
+import { z as z9 } from "zod";
+var GENERATOR_LIMITS = {
+  maxPrompt: 2e3,
+  /** Jobs je Tag und Workspace (Default; Server: GENERATOR_DAILY_LIMIT) */
+  dailyDefault: 20,
+  /** Verlauf: letzte Jobs */
+  historySize: 20
+};
+var GENERATOR_FILE_LIMITS = {
+  maxFiles: 6,
+  maxBytes: 10 * 1024 * 1024,
+  /** PDF: so viele Seiten werden höchstens betrachtet */
+  maxPdfPages: 20,
+  /** Lange Kante nach der Normalisierung */
+  maxEdge: 2048,
+  /** Uploads je Nutzer und Stunde */
+  perHour: 30,
+  maxName: 120
+};
+var GENERATOR_FILE_ROLES = ["floorplan", "style"];
+var generatorFileUploadSchema = z9.object({
+  name: z9.string().trim().min(1).max(GENERATOR_FILE_LIMITS.maxName),
+  data: z9.string().min(16).max(Math.ceil(GENERATOR_FILE_LIMITS.maxBytes * 4 / 3) + 128).regex(/^data:[a-z]+\/[a-z0-9.+-]+;base64,/)
+});
+var generatorFileIdSchema = z9.string().regex(/^[a-f0-9]{24}$/);
+var generatorFileRefSchema = z9.object({
+  id: generatorFileIdSchema,
+  role: z9.enum(GENERATOR_FILE_ROLES),
+  /** PDF: Seite mit dem Grundriss (1-basiert) */
+  page: z9.number().int().min(1).max(GENERATOR_FILE_LIMITS.maxPdfPages).optional(),
+  /** Grundriss: „Längste Seite in Metern“ (leer = KI schätzt) */
+  scaleMeters: z9.number().min(2).max(500).optional()
+});
+var generatorParamsSchema = z9.object({
+  seats: z9.number().int().min(0).max(200).optional(),
+  meetingRooms: z9.number().int().min(0).max(8).optional(),
+  lounge: z9.boolean().optional(),
+  fun: z9.boolean().optional(),
+  kitchen: z9.boolean().optional(),
+  focus: z9.boolean().optional(),
+  outdoor: z9.boolean().optional(),
+  style: z9.enum(["skandinavisch", "industrial", "bunt", "minimal", "homeoffice"]).optional(),
+  sky: z9.enum(["day", "evening", "night"]).optional(),
+  size: z9.enum(["kompakt", "normal", "grosszuegig"]).optional()
+});
+var createGenerationJobSchema = z9.object({
+  /** Freie Beschreibung; bei `template` optional */
+  prompt: z9.string().trim().max(GENERATOR_LIMITS.maxPrompt).default(""),
+  params: generatorParamsSchema.default({}),
+  /** Feste Vorlage (ID aus OFFICE_TEMPLATES) – dann kein LLM für den Brief */
+  template: z9.string().regex(/^[a-z0-9_]{1,40}$/).optional(),
+  /** `neu` ersetzt den Entwurf (Rollback über Revisionen); `ergaenzen` folgt in G4 */
+  mode: z9.enum(["neu"]).default("neu"),
+  /** Brief-Schritt überspringen („Direkt bauen“) */
+  skipBrief: z9.boolean().default(false),
+  seed: z9.number().int().min(0).max(2147483647).optional(),
+  /** Referenzen (G2/G3): höchstens 6, davon höchstens ein Grundriss */
+  files: z9.array(generatorFileRefSchema).max(GENERATOR_FILE_LIMITS.maxFiles).default([]).refine((f) => f.filter((x) => x.role === "floorplan").length <= 1, "H\xF6chstens ein Grundriss").refine((f) => new Set(f.map((x) => x.id)).size === f.length, "Jede Datei nur einmal")
+});
+var confirmBriefSchema = z9.object({
+  /** Bearbeiteter Brief (OfficeBrief aus @huddle/scene-schema) */
+  brief: z9.unknown(),
+  answers: z9.record(z9.string().max(32), z9.string().max(200)).optional()
+});
+var applyGenerationSchema = z9.object({ baseVersion: z9.number().int().min(0) });
+var revertGenerationSchema = z9.object({ baseVersion: z9.number().int().min(0) });
+var generationJobIdSchema = z9.string().regex(/^[a-f0-9]{24}$/);
+
+// ../shared/src/web.ts
+import { z as z10 } from "zod";
+var WEB_LIMITS = {
+  maxUrl: 1024,
+  maxName: 60,
+  maxCss: 4096,
+  /** Kanäle je Workspace */
+  maxChannels: 12,
+  /** Kanäle gleichzeitig offen je Renderer-Instanz */
+  maxContexts: 3,
+  /** Bildabstand im Standbildmodus (Sekunden) */
+  minRefresh: 2,
+  maxRefresh: 300,
+  defaultRefresh: 10,
+  /** Sichtfenster des Server-Browsers */
+  minViewport: 480,
+  maxViewport: 2560,
+  defaultViewport: { w: 1280, h: 720 },
+  /** Zoom der Seite */
+  minZoom: 0.25,
+  maxZoom: 3,
+  /** Steuerung: Dauer der exklusiven Übernahme ohne Eingabe (ms) */
+  controlTtlMs: 5 * 6e4,
+  /** Eingabeereignisse je Sekunde und Teilnehmer */
+  inputPerSecond: 60,
+  /** Zeichen, die auf einmal eingefügt werden dürfen (Zwischenablage) */
+  maxPaste: 8192,
+  /** Ohne Zuschauer: pausieren nach … ms, Seite schließen nach … ms */
+  idlePauseMs: 6e4,
+  idleCloseMs: 10 * 6e4,
+  /** Bildgröße (Bytes, base64) */
+  maxFrameBytes: 15e5,
+  /** Rotation mehrerer Kanäle: Sekunden je Kanal */
+  minRotate: 10,
+  maxRotate: 3600,
+  /** Bildrate im Bewegtbildmodus */
+  maxLiveFps: 10
+};
+var WEB_MODES = ["still", "live"];
+var WEB_BUTTONS = ["left", "right", "middle"];
+var unit2 = z10.number().min(0).max(1);
+var modifiers = z10.number().int().min(0).max(15).optional();
+var webInputEventSchema = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("mouse"),
+    type: z10.enum(["move", "down", "up", "click"]),
+    x: unit2,
+    y: unit2,
+    button: z10.enum(WEB_BUTTONS).optional(),
+    clickCount: z10.number().int().min(1).max(3).optional(),
+    modifiers
+  }),
+  z10.object({ kind: z10.literal("wheel"), x: unit2, y: unit2, dx: z10.number().min(-5e3).max(5e3), dy: z10.number().min(-5e3).max(5e3), modifiers }),
+  z10.object({
+    kind: z10.literal("key"),
+    type: z10.enum(["down", "up", "char"]),
+    key: z10.string().min(1).max(32),
+    code: z10.string().max(32).optional(),
+    text: z10.string().max(8).optional(),
+    modifiers
+  }),
+  /**
+   * Text einfügen, ohne eine Taste nachzubauen (CDP `Input.insertText`): layoutunabhängig und damit
+   * der einzig verlässliche Weg für Satzzeichen, Umlaute, `@` – und für die Zwischenablage.
+   */
+  z10.object({ kind: z10.literal("text"), text: z10.string().min(1).max(WEB_LIMITS.maxPaste) })
+]);
+var webNavigateSchema = z10.object({
+  action: z10.enum(["url", "back", "forward", "reload", "home"]),
+  url: z10.string().max(WEB_LIMITS.maxUrl).optional()
+});
+var webWatchSchema = z10.object({ placementId: z10.string().max(64), watch: z10.boolean() });
+var webControlSchema = z10.object({ placementId: z10.string().max(64), take: z10.boolean() });
+var webInputSchema = z10.object({ placementId: z10.string().max(64), event: webInputEventSchema });
+var webNavigateRequestSchema = z10.object({ placementId: z10.string().max(64) }).and(webNavigateSchema);
+var webResizeSchema = z10.object({
+  placementId: z10.string().max(64),
+  w: z10.number().int().min(WEB_LIMITS.minViewport).max(WEB_LIMITS.maxViewport),
+  h: z10.number().int().min(WEB_LIMITS.minViewport).max(WEB_LIMITS.maxViewport)
+});
+var viewport = z10.object({
+  w: z10.number().int().min(WEB_LIMITS.minViewport).max(WEB_LIMITS.maxViewport),
+  h: z10.number().int().min(WEB_LIMITS.minViewport).max(WEB_LIMITS.maxViewport)
+});
+var webChannelInputSchema = z10.object({
+  name: z10.string().trim().min(1).max(WEB_LIMITS.maxName),
+  url: z10.string().min(1).max(WEB_LIMITS.maxUrl),
+  viewport: viewport.optional(),
+  mode: z10.enum(WEB_MODES).optional(),
+  refreshSeconds: z10.number().int().min(WEB_LIMITS.minRefresh).max(WEB_LIMITS.maxRefresh).optional(),
+  zoom: z10.number().min(WEB_LIMITS.minZoom).max(WEB_LIMITS.maxZoom).optional(),
+  scroll: z10.object({ x: z10.number().min(0).max(1e5), y: z10.number().min(0).max(1e5) }).optional(),
+  css: z10.string().max(WEB_LIMITS.maxCss).optional(),
+  /** Feste Kopfzeilen (verschlüsselt abgelegt); leeres Objekt löscht sie */
+  headers: z10.record(z10.string().min(1).max(64), z10.string().max(1024)).optional(),
+  basicAuth: z10.object({ user: z10.string().max(128), password: z10.string().max(256) }).nullable().optional()
+});
+var webChannelIdSchema = z10.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+
+// ../shared/src/sso.ts
+import { z as z11 } from "zod";
+var domainSchema = z11.string().trim().toLowerCase().max(253).regex(/^(?=.{1,253}$)(?!-)[a-z0-9-]{1,63}(?<!-)(\.(?!-)[a-z0-9-]{1,63}(?<!-))+$/, "Keine g\xFCltige Domain");
+var updateWorkspaceAuthSchema = z11.object({
+  password: z11.boolean(),
+  magicLink: z11.boolean(),
+  google: z11.object({ enabled: z11.boolean(), allowedDomains: z11.array(domainSchema).max(20) }).partial(),
+  oidcEnabled: z11.boolean(),
+  autoJoin: z11.boolean()
+}).partial();
+var scopeSchema = z11.string().trim().regex(/^[\x21\x23-\x5b\x5d-\x7e]{1,100}$/, "Ung\xFCltiger Scope");
+var oidcConnectionSchema = z11.object({
+  issuer: z11.string().trim().url().max(500),
+  clientId: z11.string().trim().min(1).max(300),
+  /** Leer lassen = bisheriges Secret behalten */
+  clientSecret: z11.string().max(2e3).optional(),
+  scopes: z11.array(scopeSchema).max(20).default(["openid", "email", "profile"]),
+  label: z11.string().trim().min(1).max(40).default("Mit SSO anmelden")
+});
+var addDomainSchema = z11.object({ domain: domainSchema });
+var ssoDiscoverSchema = z11.object({ email: z11.string().trim().toLowerCase().email().max(254) });
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/audio.ts
+function resample(pcm, from, to) {
+  if (from === to) return pcm;
+  const ratio = from / to;
+  const out = new Int16Array(Math.max(1, Math.floor(pcm.length / ratio)));
+  for (let i = 0; i < out.length; i++) {
+    const src = i * ratio;
+    const a = Math.floor(src);
+    const b = Math.min(a + 1, pcm.length - 1);
+    const t = src - a;
+    out[i] = (pcm[a] ?? 0) * (1 - t) + (pcm[b] ?? 0) * t | 0;
+  }
+  return out;
+}
+function rms(pcm) {
+  if (pcm.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < pcm.length; i++) {
+    const v = pcm[i] / 32768;
+    sum += v * v;
+  }
+  return Math.sqrt(sum / pcm.length);
+}
+var Vad = class {
+  sampleRate;
+  silenceMs;
+  minSpeechMs;
+  preRollMs;
+  maxSpeechMs;
+  baseThreshold;
+  /** Gleitender Grundpegel der Stille */
+  noise = 5e-3;
+  speaking = false;
+  speechChunks = [];
+  speechSamples = 0;
+  silenceSamples = 0;
+  preRoll = [];
+  preRollSamples = 0;
+  constructor(options) {
+    this.sampleRate = options.sampleRate;
+    this.baseThreshold = options.threshold ?? 0.02;
+    this.silenceMs = options.silenceMs ?? 700;
+    this.minSpeechMs = options.minSpeechMs ?? 300;
+    this.preRollMs = options.preRollMs ?? 300;
+    this.maxSpeechMs = options.maxSpeechMs ?? 2e4;
+  }
+  get active() {
+    return this.speaking;
+  }
+  /** Aktuelle Auslöseschwelle – Grundrauschen plus Abstand, nie unter dem Grundwert. */
+  get threshold() {
+    return Math.max(this.baseThreshold, this.noise * 3);
+  }
+  /** Einen Block einspeisen. Liefert die Ereignisse, die dieser Block ausgelöst hat. */
+  push(pcm) {
+    const events = [];
+    const level = rms(pcm);
+    const loud = level > this.threshold;
+    if (!this.speaking) {
+      this.noise = this.noise * 0.95 + level * 0.05;
+      this.preRoll.push(pcm);
+      this.preRollSamples += pcm.length;
+      const keep = this.preRollMs / 1e3 * this.sampleRate;
+      while (this.preRollSamples > keep && this.preRoll.length > 1) {
+        this.preRollSamples -= this.preRoll.shift().length;
+      }
+      if (loud) {
+        this.speaking = true;
+        this.speechChunks = [...this.preRoll];
+        this.speechSamples = this.preRollSamples;
+        this.silenceSamples = 0;
+        this.preRoll = [];
+        this.preRollSamples = 0;
+        events.push({ type: "start" });
+      }
+      return events;
+    }
+    this.speechChunks.push(pcm);
+    this.speechSamples += pcm.length;
+    this.silenceSamples = loud ? 0 : this.silenceSamples + pcm.length;
+    const silenceReached = this.silenceSamples / this.sampleRate * 1e3 >= this.silenceMs;
+    const tooLong = this.speechSamples / this.sampleRate * 1e3 >= this.maxSpeechMs;
+    if (silenceReached || tooLong) events.push(this.finish());
+    return events;
+  }
+  /** Laufende Äußerung sofort abschließen (Gesprächsende, Abbruch). */
+  flush() {
+    if (!this.speaking) return null;
+    return this.finish();
+  }
+  finish() {
+    const pcm = concat(this.speechChunks);
+    const speechMs = (this.speechSamples - this.silenceSamples) / this.sampleRate * 1e3;
+    this.speaking = false;
+    this.speechChunks = [];
+    this.speechSamples = 0;
+    this.silenceSamples = 0;
+    if (speechMs < this.minSpeechMs) return { type: "end", pcm: new Int16Array(0), durationMs: 0 };
+    return { type: "end", pcm, durationMs: pcm.length / this.sampleRate * 1e3 };
+  }
+};
+function concat(chunks) {
+  let n = 0;
+  for (const c of chunks) n += c.length;
+  const out = new Int16Array(n);
+  let at = 0;
+  for (const c of chunks) {
+    out.set(c, at);
+    at += c.length;
+  }
+  return out;
+}
+function toWav(pcm, sampleRate) {
+  const bytes = pcm.length * 2;
+  const buf = new ArrayBuffer(44 + bytes);
+  const view = new DataView(buf);
+  const ascii = (at, text) => {
+    for (let i = 0; i < text.length; i++) view.setUint8(at + i, text.charCodeAt(i));
+  };
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + bytes, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  ascii(36, "data");
+  view.setUint32(40, bytes, true);
+  new Int16Array(buf, 44).set(pcm);
+  return new Uint8Array(buf);
+}
+var FrameSplitter = class {
+  constructor(frameSamples) {
+    this.frameSamples = frameSamples;
+  }
+  frameSamples;
+  rest = new Int16Array(0);
+  push(pcm) {
+    const merged = concat([this.rest, pcm]);
+    const frames = [];
+    let at = 0;
+    while (at + this.frameSamples <= merged.length) {
+      frames.push(merged.slice(at, at + this.frameSamples));
+      at += this.frameSamples;
+    }
+    this.rest = merged.slice(at);
+    return frames;
+  }
+  /** Rest mit Stille auffüllen und ausgeben (Ende einer Äußerung). */
+  flush() {
+    if (this.rest.length === 0) return null;
+    const frame = new Int16Array(this.frameSamples);
+    frame.set(this.rest);
+    this.rest = new Int16Array(0);
+    return frame;
+  }
+};
+function pcmFromBytes(bytes) {
+  const even = bytes.length - bytes.length % 2;
+  const out = new Int16Array(even / 2);
+  for (let i = 0; i < out.length; i++) out[i] = (bytes[i * 2] | bytes[i * 2 + 1] << 8) << 16 >> 16;
+  return out;
+}
+
+// src/voice.ts
+var STT_RATE = 16e3;
+var FRAME_MS = 10;
+var RTC_MODULE = "@livekit/rtc-node";
+var rtcModule = null;
+async function rtc() {
+  if (rtcModule) return rtcModule;
+  try {
+    rtcModule = await import(RTC_MODULE);
+    return rtcModule;
+  } catch {
+    throw new Error("F\xFCr Sprache fehlt @livekit/rtc-node \u2013 `npm i @livekit/rtc-node` im Agenten-Projekt");
+  }
+}
+var EtazioVoice = class {
+  agent;
+  options;
+  live = /* @__PURE__ */ new Map();
+  started = false;
+  constructor(agent, options) {
+    this.agent = agent;
+    this.options = options;
+  }
+  /** An die Sprachereignisse des Agenten hängen. Ab hier laufen Gespräche von selbst. */
+  start() {
+    if (this.started) return this;
+    this.started = true;
+    this.agent.on("voice", (payload) => {
+      if (payload.kind === "open") void this.open(payload).catch((err) => this.fail(err));
+      else void this.close(payload.sessionId);
+    });
+    this.agent.on("disconnect", () => void this.closeAll());
+    this.agent.on("revoked", () => void this.closeAll());
+    return this;
+  }
+  /** Laufende Gespräche (für Diagnose und geordnetes Herunterfahren). */
+  get sessions() {
+    return [...this.live.values()].map((l) => l.session);
+  }
+  async stop() {
+    await this.closeAll();
+  }
+  // -------------------------------------------------------------------------
+  async open(session) {
+    if (this.live.has(session.sessionId)) return;
+    const mod = await rtc();
+    const token = await this.agent.meetingToken(session.target);
+    const room = new mod.Room();
+    await room.connect(token.url, token.token, { autoSubscribe: false, dynacast: true });
+    const source = new mod.AudioSource(this.options.tts.sampleRate, 1);
+    const track = mod.LocalAudioTrack.createAudioTrack("agent-voice", source);
+    const publication = await room.localParticipant.publishTrack(
+      track,
+      new mod.TrackPublishOptions({ source: mod.TrackSource.SOURCE_MICROPHONE ?? 1 })
+    );
+    const entry = {
+      session,
+      room,
+      source,
+      trackSid: publication?.sid ?? null,
+      vad: new Vad({ sampleRate: STT_RATE, silenceMs: this.options.silenceMs, threshold: this.options.threshold }),
+      turn: null,
+      speaking: false,
+      closed: false,
+      stream: null
+    };
+    this.live.set(session.sessionId, entry);
+    const wanted = session.human.identity;
+    const subscribe = (participant) => {
+      if (participant.identity !== wanted) return;
+      for (const pub of participant.trackPublications.values()) pub.setSubscribed(true);
+    };
+    for (const p of room.remoteParticipants.values()) subscribe(p);
+    room.on(mod.RoomEvent.TrackPublished ?? "trackPublished", ((_pub, participant) => {
+      subscribe(participant);
+    }));
+    room.on(mod.RoomEvent.TrackSubscribed ?? "trackSubscribed", ((audioTrack, _pub, participant) => {
+      if (participant.identity !== wanted) return;
+      void this.listen(entry, audioTrack, mod).catch((err) => this.fail(err));
+    }));
+    await this.agent.voiceState(session.sessionId, "listening").catch(() => void 0);
+  }
+  /** Ton des Menschen lesen, in Äußerungen schneiden und beantworten. */
+  async listen(entry, audioTrack, mod) {
+    const stream = new mod.AudioStream(audioTrack, { sampleRate: STT_RATE, numChannels: 1 });
+    entry.stream = stream;
+    for await (const frame of stream) {
+      if (entry.closed) break;
+      const pcm = frame.sampleRate === STT_RATE ? frame.data : resample(frame.data, frame.sampleRate, STT_RATE);
+      for (const event of entry.vad.push(pcm)) {
+        if (event.type === "start" && entry.speaking) this.bargeIn(entry);
+        if (event.type === "end" && event.pcm.length > 0) void this.turn(entry, event.pcm).catch((err) => this.fail(err));
+      }
+    }
+    stream.close();
+  }
+  /** Ein Gesprächszug: verstehen → antworten → sprechen. Jeder Schritt kann unterbrochen werden. */
+  async turn(entry, pcm) {
+    const controller = new AbortController();
+    entry.turn = controller;
+    try {
+      await this.state(entry, "thinking");
+      const text = await this.options.stt.transcribe(pcm, STT_RATE, controller.signal);
+      if (!text || controller.signal.aborted || entry.closed) return void await this.state(entry, "listening");
+      this.options.onTranscript?.(text, entry.session);
+      const answer = await this.options.reply({ text, session: entry.session, signal: controller.signal });
+      if (!answer || controller.signal.aborted || entry.closed) return void await this.state(entry, "listening");
+      if (this.options.subtitles !== false) {
+        await this.agent.say(entry.session.conv, answer).catch(() => void 0);
+      }
+      await this.say(entry, answer, controller.signal);
+    } catch (err) {
+      if (!controller.signal.aborted) this.fail(err);
+    } finally {
+      if (entry.turn === controller) entry.turn = null;
+      if (!entry.closed && !controller.signal.aborted) await this.state(entry, "listening");
+    }
+  }
+  /** Text sprechen: Blöcke gehen raus, sobald sie da sind – wer die ganze Datei abwartet, wartet zu lang. */
+  async say(entry, text, signal) {
+    const mod = await rtc();
+    const rate = this.options.tts.sampleRate;
+    const splitter = new FrameSplitter(Math.round(rate * FRAME_MS / 1e3));
+    entry.speaking = true;
+    await this.state(entry, "speaking", text);
+    try {
+      for await (const chunk of this.options.tts.speak(text, signal)) {
+        if (signal.aborted || entry.closed) break;
+        for (const frame of splitter.push(chunk)) {
+          if (signal.aborted || entry.closed) break;
+          await entry.source.captureFrame(new mod.AudioFrame(frame, rate, 1, frame.length));
+        }
+      }
+      const rest = splitter.flush();
+      if (rest && !signal.aborted && !entry.closed) {
+        await entry.source.captureFrame(new mod.AudioFrame(rest, rate, 1, rest.length));
+      }
+      if (!signal.aborted && !entry.closed) await entry.source.waitForPlayout();
+    } finally {
+      entry.speaking = false;
+    }
+  }
+  /**
+   * Barge-in: der Mensch redet dazwischen. Der laufende Zug wird abgebrochen **und** die schon in
+   * LiveKit liegende Warteschlange geleert – ohne das Zweite redet der Agent noch sekundenlang weiter.
+   */
+  bargeIn(entry) {
+    entry.turn?.abort();
+    entry.turn = null;
+    entry.speaking = false;
+    entry.source.clearQueue();
+    void this.state(entry, "listening");
+  }
+  async state(entry, state, text) {
+    if (entry.closed) return;
+    await this.agent.voiceState(entry.session.sessionId, state, text).catch(() => void 0);
+  }
+  async close(sessionId) {
+    const entry = this.live.get(sessionId);
+    if (!entry) return;
+    this.live.delete(sessionId);
+    entry.closed = true;
+    entry.turn?.abort();
+    entry.vad.flush();
+    entry.stream?.close();
+    entry.source.clearQueue();
+    try {
+      if (entry.trackSid) await entry.room.localParticipant.unpublishTrack(entry.trackSid).catch(() => void 0);
+      await entry.source.close?.();
+      await entry.room.disconnect();
+    } catch (err) {
+      this.fail(err);
+    }
+  }
+  async closeAll() {
+    await Promise.all([...this.live.keys()].map((id) => this.close(id)));
+  }
+  fail(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (this.options.onError) this.options.onError(error);
+  }
+};
+function attachVoice(agent, options) {
+  return new EtazioVoice(agent, options).start();
+}
+
+// src/speech.ts
+var OPENAI_BASE = "https://api.openai.com/v1";
+var OPENAI_TTS_RATE = 24e3;
+function openAiStt(options) {
+  const base = (options.baseUrl ?? OPENAI_BASE).replace(/\/$/, "");
+  const model = options.sttModel ?? "gpt-4o-mini-transcribe";
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  return {
+    async transcribe(pcm, sampleRate, signal) {
+      if (pcm.length === 0) return "";
+      const form = new FormData();
+      form.append("file", new Blob([toWav(pcm, sampleRate)], { type: "audio/wav" }), "speech.wav");
+      form.append("model", model);
+      form.append("response_format", "text");
+      if (options.language) form.append("language", options.language);
+      const res = await fetch(`${base}/audio/transcriptions`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${options.apiKey}` },
+        body: form,
+        signal: signal ?? AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) throw new Error(`Erkennung fehlgeschlagen: HTTP ${res.status}`);
+      return (await res.text()).trim();
+    }
+  };
+}
+function openAiTts(options) {
+  const base = (options.baseUrl ?? OPENAI_BASE).replace(/\/$/, "");
+  const model = options.ttsModel ?? "gpt-4o-mini-tts";
+  const voice = options.voice ?? "alloy";
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  return {
+    sampleRate: OPENAI_TTS_RATE,
+    async *speak(text, signal) {
+      const res = await fetch(`${base}/audio/speech`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+        body: JSON.stringify({ model, voice, input: text, response_format: "pcm" }),
+        signal: signal ?? AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok || !res.body) throw new Error(`Stimme fehlgeschlagen: HTTP ${res.status}`);
+      let carry = null;
+      for await (const chunk of res.body) {
+        let bytes = chunk;
+        if (carry !== null) {
+          const merged = new Uint8Array(bytes.length + 1);
+          merged[0] = carry;
+          merged.set(bytes, 1);
+          bytes = merged;
+          carry = null;
+        }
+        if (bytes.length % 2 === 1) {
+          carry = bytes[bytes.length - 1];
+          bytes = bytes.subarray(0, bytes.length - 1);
+        }
+        if (bytes.length > 0) yield pcmFromBytes(bytes);
+      }
+    }
+  };
+}
+
+// src/index.ts
+var EtazioAgentError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "EtazioAgentError";
+    this.code = code;
+  }
+};
+var DEFAULT_ACK_TIMEOUT_MS = 15e3;
+var EtazioAgent = class {
+  options;
+  bus = new EventEmitter();
+  socket = null;
+  helloResult = null;
+  /** Über Reconnects hinweg festgehalten: damit Position und Sitzplatz erhalten bleiben */
+  lastParticipantId = null;
+  /** Wer sitzt gerade wo – nur so lässt sich beim Aufstehen der richtige Platz wieder freigeben */
+  seatOf = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(options) {
+    this.options = options;
+    this.bus.setMaxListeners(50);
+  }
+  /** Ergebnis des letzten Handshakes (Scopes, Welt-Digest, Teilnehmer-ID). */
+  get hello() {
+    return this.helloResult;
+  }
+  get scopes() {
+    return this.helloResult?.scopes ?? [];
+  }
+  /** Weltbeschreibung des letzten Handshakes – Räume, Objekte, Sitzplätze, wer da ist. */
+  get world() {
+    return this.helloResult?.world ?? null;
+  }
+  /** Teilnehmer-ID des Agenten in der Welt (null, solange kein Handshake lief). */
+  get participantId() {
+    return this.lastParticipantId;
+  }
+  get connected() {
+    return !!this.socket?.connected && !!this.helloResult;
+  }
+  /** Darf der Agent das? Spart den Server-Roundtrip für Dinge, die ohnehin abgelehnt würden. */
+  can(scope) {
+    return hasScope(this.scopes, scope);
+  }
+  on(event, listener) {
+    this.bus.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.bus.off(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.bus.once(event, listener);
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Verbindung
+  /** Verbindet und führt den Handshake aus; das Ergebnis ist danach auch als `agent.hello` verfügbar. */
+  async connect() {
+    if (this.socket) throw new EtazioAgentError("conflict", "Bereits verbunden");
+    this.closed = false;
+    const socket = io(this.options.url, {
+      auth: { token: this.options.token },
+      transports: ["websocket", "polling"],
+      reconnection: this.options.autoReconnect !== false,
+      // Backoff: schnell beim Schluckauf, geduldig beim Ausfall – und gestreut, damit nicht alle
+      // Agenten eines Workspaces gleichzeitig wieder anklopfen.
+      reconnectionDelay: 500,
+      reconnectionDelayMax: 1e4,
+      randomizationFactor: 0.5
+    });
+    this.socket = socket;
+    this.wire(socket);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        void this.close();
+        reject(new EtazioAgentError("timeout", "Keine Antwort auf agent:hello"));
+      }, this.options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS);
+      const onReady = (result) => {
+        cleanup();
+        resolve(result);
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.bus.off("ready", onReady);
+        this.bus.off("error", onError);
+      };
+      this.bus.once("ready", onReady);
+      this.bus.once("error", onError);
+    });
+  }
+  /**
+   * Handshake erneut ausführen. Nötig nur, wenn sich das Office selbst geändert hat
+   * (`office:published`) – wer kommt, geht oder sich setzt, wird ohnehin laufend nachgepflegt.
+   *
+   * Achtung: Der Server behandelt das wie ein Verlassen und erneutes Betreten der Welt; der Agent
+   * steht danach wieder am Startpunkt. Ist er der einzige Teilnehmer, wird die Welt dabei entladen
+   * und alle weiteren Befehle scheitern mit `not_found` (SPA-78).
+   */
+  async refresh() {
+    return this.sayHello();
+  }
+  /** Verbindung bewusst beenden (kein Reconnect mehr). */
+  close() {
+    this.closed = true;
+    this.socket?.disconnect();
+    this.socket = null;
+    this.helloResult = null;
+  }
+  wire(socket) {
+    socket.on("connect", () => {
+      this.sayHello().catch((err) => this.fireError(err));
+    });
+    socket.on("connect_error", (err) => {
+      const code = err.message === "unauthenticated" || err.message === "rate_limited" ? err.message : "unavailable";
+      this.fire("error", new EtazioAgentError(code, err.message));
+    });
+    socket.on("disconnect", (reason) => {
+      this.helloResult = null;
+      this.fire("disconnect", reason);
+    });
+    socket.on(SOCKET_EVENTS.agentAddress, (p) => this.fire("address", p));
+    socket.on(SOCKET_EVENTS.agentVoice, (p) => this.fire("voice", p));
+    socket.on(SOCKET_EVENTS.chatMessage, (p) => this.fire("chat", p));
+    socket.on(SOCKET_EVENTS.worldParticipantJoined, (p) => {
+      this.trackJoined(p);
+      this.fire("participantJoined", p);
+    });
+    socket.on(SOCKET_EVENTS.worldParticipantLeft, (p) => {
+      this.trackLeft(p.participantId);
+      this.fire("participantLeft", p);
+    });
+    socket.on(SOCKET_EVENTS.worldZone, (p) => {
+      this.trackZone(p);
+      this.fire("zone", p);
+    });
+    socket.on(SOCKET_EVENTS.worldSeat, (p) => {
+      this.trackSeat(p);
+      this.fire("seat", p);
+    });
+    socket.on(SOCKET_EVENTS.worldTick, (p) => this.trackTick(p));
+    socket.on(SOCKET_EVENTS.worldEmote, (p) => this.fire("emote", p));
+    socket.on(SOCKET_EVENTS.objectState, (p) => this.fire("objectState", p));
+    socket.on(SOCKET_EVENTS.objectAction, (p) => this.fire("objectAction", p));
+    socket.on(SOCKET_EVENTS.agentThrottled, (p) => this.fire("throttled", p));
+    socket.on(SOCKET_EVENTS.agentRevoked, (p) => {
+      this.closed = true;
+      socket.io.opts.reconnection = false;
+      this.fire("revoked", p);
+    });
+  }
+  async sayHello() {
+    const input = {
+      protocol: AGENT_PROTOCOL,
+      capabilities: this.options.capabilities ?? [],
+      client: { name: this.options.client?.name ?? "etazio-agent-sdk", version: this.options.client?.version ?? SDK_VERSION },
+      ...this.options.workspaceId ? { workspaceId: this.options.workspaceId } : {},
+      ...this.lastParticipantId ? { participantId: this.lastParticipantId } : {}
+    };
+    const result = await this.call(SOCKET_EVENTS.agentHello, input);
+    this.helloResult = result;
+    this.seatOf.clear();
+    this.lastParticipantId = result.participantId;
+    this.fire("ready", result);
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Helfer (jeweils ein Server-Ereignis mit Ack)
+  /** Chat-Nachricht in eine Konversation (`room:office`, `room:<zoneId>`, `dm:<a>:<b>`). */
+  async say(conv, text, parentId) {
+    const data = await this.call(SOCKET_EVENTS.chatSend, { conv, text, ...parentId ? { parentId } : {} });
+    return data.message;
+  }
+  /**
+   * „Schreibt gerade“ im Chat anzeigen (SPA-133). Die Anzeige verfällt beim Empfänger nach ~6 s –
+   * für längere Arbeit `typingWhile()` nutzen, das selbst auffrischt. Mit `say()` endet sie ohnehin.
+   */
+  typing(conv, on = true, parentId) {
+    this.socket?.emit(SOCKET_EVENTS.chatTyping, { conv, parentId: parentId ?? null, typing: on });
+  }
+  /** `typing()` halten, solange `work` läuft – danach wieder aus. */
+  async typingWhile(conv, work, parentId) {
+    this.typing(conv, true, parentId);
+    const timer = setInterval(() => this.typing(conv, true, parentId), CHAT_TYPING_REFRESH_MS);
+    try {
+      return await work();
+    } finally {
+      clearInterval(timer);
+      this.typing(conv, false, parentId);
+    }
+  }
+  /**
+   * Fragen, die man anklickt statt abtippt (SPA-117): eine Bestätigungs-Karte in den Chat stellen.
+   * `text` bleibt Pflicht und trägt dieselbe Frage in Worten – für Suche, Vorschau und alle, die
+   * die Karte nicht sehen können. Die Antwort kommt als `agent:address` mit `kind: 'card.decision'`
+   * zurück, nicht als Rückgabewert: entschieden wird, wann jemand mag.
+   */
+  async ask(conv, text, block, parentId) {
+    const data = await this.call(SOCKET_EVENTS.chatSend, {
+      conv,
+      text,
+      blocks: [{ type: "confirm", ...block }],
+      ...parentId ? { parentId } : {}
+    });
+    return data.message;
+  }
+  /** Hingehen mit serverseitiger Wegfindung – kein Teleport, der Agent läuft wie ein Mensch. */
+  async goTo(target) {
+    return this.call(SOCKET_EVENTS.agentGoTo, target);
+  }
+  async sit(seatId) {
+    return this.call(SOCKET_EVENTS.worldSit, { seatId });
+  }
+  async stand() {
+    return this.call(SOCKET_EVENTS.worldStand, {});
+  }
+  /** Objektzustand setzen (Lampe, Fernseher, …). Der Zustand ist flach und ≤ 2 KB. */
+  async setState(placementId, state) {
+    return this.call(SOCKET_EVENTS.objectState, { placementId, state });
+  }
+  /** Einmalige Objektaktion auslösen (Kicker, Automat, …). */
+  async action(placementId, action, data) {
+    return this.call(SOCKET_EVENTS.objectAction, { placementId, action, ...data ? { data } : {} });
+  }
+  /** Bequemer Weg zum Fernseher: der TV-Kanal ist nur ein besonderer Objektzustand. */
+  async setTv(placementId, state) {
+    const flat = {};
+    for (const [key, value] of Object.entries(state)) {
+      if (value !== void 0) flat[key] = value;
+    }
+    return this.setState(placementId, flat);
+  }
+  /** Reaktion über dem Kopf (Glyph). */
+  async react(glyph) {
+    await this.call(SOCKET_EVENTS.worldReact, { glyph });
+  }
+  async wave() {
+    await this.call(SOCKET_EVENTS.worldWave, {});
+  }
+  /** LiveKit-Token für den Raum, in dem der Agent laut Welt gerade steht (Scope `meeting.audio`). */
+  async meetingToken(target = "office") {
+    return this.call(SOCKET_EVENTS.agentMeetingToken, { target });
+  }
+  /**
+   * Sprechzustand melden (Scope `voice.speak`, SPA-83). Das ist zweierlei zugleich: die Anzeige am
+   * Avatar für alle im Raum und das Lebenszeichen der Sitzung – bleibt es aus, beendet der Server
+   * das Gespräch wegen Stille.
+   */
+  async voiceState(sessionId, state, text) {
+    return this.call(SOCKET_EVENTS.agentVoiceState, { sessionId, state, ...text ? { text } : {} });
+  }
+  /** Whiteboard-Operation (Scope `board.write`); `baseVersion` kommt aus `board:sync`. */
+  async boardOp(envelope) {
+    return this.call(SOCKET_EVENTS.boardOp, envelope);
+  }
+  // -------------------------------------------------------------------------
+  // Innereien
+  /** Ein Ereignis mit Ack: jede Ablehnung des Servers wird hier zu einem Fehler mit Code. */
+  call(event, payload) {
+    const socket = this.socket;
+    if (!socket || !socket.connected) return Promise.reject(new EtazioAgentError("unavailable", "Nicht verbunden"));
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(new EtazioAgentError("timeout", `Keine Antwort auf ${event}`));
+      }, this.options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS);
+      socket.emit(event, payload, (ack) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (!ack?.ok) return reject(new EtazioAgentError(ack?.error?.code ?? "internal", ack?.error?.message ?? `${event} fehlgeschlagen`));
+        resolve(ack.data);
+      });
+    });
+  }
+  // Der Welt-Digest aus dem Handshake ist eine Momentaufnahme. Die beweglichen Teile werden aus den
+  // laufenden Ereignissen nachgepflegt – sonst müsste ein Agent für jede Frage „wer ist da?“ einen
+  // neuen Handshake schicken, und das Office bekäme jedes Mal ein Kommen und Gehen zu sehen.
+  trackJoined(p) {
+    const world = this.helloResult?.world;
+    if (!world || world.participants.some((x) => x.id === p.id)) return;
+    world.participants.push({ id: p.id, name: p.displayName, kind: p.kind ?? "user", zoneId: p.zoneId, x: p.x, z: p.z });
+    if (p.seatId) {
+      this.seatOf.set(p.id, p.seatId);
+      this.markSeat(p.seatId, true);
+    }
+  }
+  trackLeft(participantId) {
+    const world = this.helloResult?.world;
+    if (!world) return;
+    world.participants = world.participants.filter((x) => x.id !== participantId);
+    const seatId = this.seatOf.get(participantId);
+    if (seatId) {
+      this.seatOf.delete(participantId);
+      this.markSeat(seatId, false);
+    }
+  }
+  trackZone(payload) {
+    const p = this.helloResult?.world.participants.find((x) => x.id === payload.participantId);
+    if (p) p.zoneId = payload.zoneId;
+  }
+  trackSeat(payload) {
+    const previous = this.seatOf.get(payload.participantId);
+    if (previous && previous !== payload.seatId) this.markSeat(previous, false);
+    if (payload.seatId) {
+      this.seatOf.set(payload.participantId, payload.seatId);
+      this.markSeat(payload.seatId, true);
+    } else {
+      this.seatOf.delete(payload.participantId);
+    }
+    const p = this.helloResult?.world.participants.find((x) => x.id === payload.participantId);
+    if (p) {
+      p.x = payload.x;
+      p.z = payload.z;
+    }
+  }
+  markSeat(seatId, taken) {
+    const seat = this.helloResult?.world.seats.find((s) => s.id === seatId);
+    if (seat) seat.taken = taken;
+  }
+  trackTick(payload) {
+    const world = this.helloResult?.world;
+    if (!world) return;
+    for (const [id, x, z12] of payload.u) {
+      const p = world.participants.find((entry) => entry.id === id);
+      if (p) {
+        p.x = x;
+        p.z = z12;
+      }
+    }
+  }
+  fire(event, ...args) {
+    if (event === "error" && this.bus.listenerCount("error") === 0) return;
+    this.bus.emit(event, ...args);
+  }
+  fireError(err) {
+    if (this.closed) return;
+    this.fire("error", err instanceof EtazioAgentError ? err : new EtazioAgentError("internal", err instanceof Error ? err.message : "Fehler"));
+  }
+};
+async function connect(options) {
+  const agent = new EtazioAgent(options);
+  await agent.connect();
+  return agent;
+}
+export {
+  AGENT_PROTOCOL,
+  EtazioAgent,
+  EtazioAgentError,
+  EtazioVoice,
+  FrameSplitter,
+  SDK_VERSION,
+  Vad,
+  attachVoice,
+  concat,
+  connect,
+  openAiStt,
+  openAiTts,
+  pcmFromBytes,
+  resample,
+  rms,
+  toWav
+};
+//# sourceMappingURL=index.js.map