@schlenkr/ragents 0.1.4 → 0.1.6

package/bundles/ragents.model-relay/server/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../plugins/ragents.model-relay/server/index.ts", "../../../plugins/ragents.model-relay/server/config.ts", "../../../plugins/ragents.model-relay/server/relay.ts"],
+  "sourcesContent": ["import type { RAgentsPlugin } from \"@ragents/engine\";\nimport { modelUpstreamsToken } from \"@ragents/host/plugin-support/model-upstreams.js\";\nimport type { PluginModule } from \"@ragents/host/plugin-support/plugin-module.js\";\nimport { Protocol } from \"@ragents/host/protocol.js\";\nimport { modelRelayConfig } from \"./config.js\";\nimport { createRelayRoutes, resolveAliases, type ResolvedAlias } from \"./relay.js\";\n\nconst modelRelayPlugin: RAgentsPlugin = {\n  manifest: { id: \"ragents.model-relay\" },\n  register: (host) => {\n    const upstreams = host.service(modelUpstreamsToken);\n    let resolved: readonly ResolvedAlias[] | undefined;\n    const aliases = (): readonly ResolvedAlias[] => resolved ??= resolveAliases(modelRelayConfig.aliases(), upstreams());\n    const log = new Protocol(host.storage.root(\"relay.log\"));\n    host.lifecycle({\n      id: \"ragents.model-relay\",\n      initialize: () => {\n        const list = aliases();\n        log.write(`=== Start: ${list.map((entry) => `${entry.alias}=${entry.upstream.id}/${entry.model.id}`).join(\", \")} ===`);\n        console.log(`Modell-Relay: ${list.length} Aliasse unter /relay/v1 (${list.map((entry) => entry.alias).join(\", \")})`);\n      },\n      shutdown: () => log.close(),\n    });\n    host.http(...createRelayRoutes({ aliases, log: (line) => log.write(line) }));\n  },\n};\n\nexport const plugin: PluginModule = {\n  create: () => modelRelayPlugin,\n};\n", "import { configuredModelAliases, type ModelAlias } from \"@ragents/host/plugin-support/model-aliases.js\";\n\n/** Das Relay bietet die Aliasse des Profils an (MODEL_ALIASES im Abschnitt host), dieselben wie f\u00FCr die eigenen Runs. */\nexport const relayAliases = (aliases: readonly ModelAlias[]): readonly ModelAlias[] => {\n  if (aliases.length === 0) throw new Error(\"ragents.model-relay braucht MODEL_ALIASES im Abschnitt host; erwartet wird eine Liste \\\"alias=anbieter/modell\\\"\");\n  return aliases;\n};\n\nexport const modelRelayConfig = Object.freeze({\n  aliases: () => relayAliases(configuredModelAliases()),\n});\n", "import type { IncomingMessage } from \"node:http\";\nimport { Readable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport type { ReadableStream } from \"node:stream/web\";\nimport type { HttpRouteContribution } from \"@ragents/engine\";\nimport { PayloadTooLargeError, readBody, writeJson } from \"@ragents/host/plugin-support/http.js\";\nimport type { ModelAlias } from \"@ragents/host/plugin-support/model-aliases.js\";\nimport type { ModelUpstream } from \"@ragents/host/plugin-support/model-upstreams.js\";\n\nexport const RELAY_PATH_PREFIX = \"/relay/v1\";\nexport const RELAY_RIGHT = \"models.use\";\n\nconst MAX_REQUEST_BYTES = 64 * 1024 * 1024;\nconst MAX_SCAN_BYTES = 8 * 1024 * 1024;\nconst DROPPED_HEADERS = new Set([\"host\", \"authorization\", \"cookie\", \"content-length\", \"connection\", \"transfer-encoding\", \"accept-encoding\", \"expect\"]);\n\nexport interface ResolvedAlias {\n  readonly alias: string;\n  readonly upstream: ModelUpstream;\n  readonly model: ModelUpstream[\"models\"][number];\n}\n\n/** Jeder Alias muss auf einen konfigurierten Anbieter und ein Modell aus dessen Katalog zeigen. */\nexport const resolveAliases = (aliases: readonly ModelAlias[], upstreams: readonly ModelUpstream[]): readonly ResolvedAlias[] =>\n  aliases.map((entry) => {\n    const upstream = upstreams.find((candidate) => candidate.id === entry.upstream);\n    if (!upstream) {\n      const available = upstreams.map((candidate) => candidate.id).join(\", \") || \"keiner\";\n      throw new Error(`MODEL_ALIASES: der Anbieter ${entry.upstream} hinter ${entry.alias} ist auf diesem Server nicht konfiguriert (verf\u00FCgbar: ${available})`);\n    }\n    const model = upstream.models.find((candidate) => candidate.id === entry.model);\n    if (!model) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);\n    return { alias: entry.alias, upstream, model };\n  });\n\n/** Der Katalogeintrag nennt nur, was der Verbraucher f\u00FCr den Draht braucht; Name, Anbieter und Kosten bleiben beim Server. */\nexport const catalogEntryOf = (resolved: ResolvedAlias) => ({\n  id: resolved.alias,\n  object: \"model\" as const,\n  owned_by: \"relay\",\n  catalog: {\n    reasoning: resolved.model.reasoning,\n    ...(resolved.model.thinkingLevelMap ? { thinkingLevelMap: resolved.model.thinkingLevelMap } : {}),\n    input: [...resolved.model.input],\n    contextWindow: resolved.model.contextWindow,\n    maxTokens: resolved.model.maxTokens,\n    ...(resolved.model.compat ? { compat: resolved.model.compat } : {}),\n  },\n});\n\ninterface Usage {\n  readonly prompt: number | undefined;\n  readonly completion: number | undefined;\n}\n\n/** Ersetzt im durchgereichten Strom den echten Modellnamen durch den Alias, entfernt den Anbieter und merkt sich den letzten usage-Block. */\nconst responseRewriter = (alias: string) => {\n  const decoder = new TextDecoder();\n  let pending = \"\";\n  let usage: Usage | undefined;\n  let overflow = false;\n  const rewrite = (text: string): string => {\n    let parsed: unknown;\n    try { parsed = JSON.parse(text); }\n    catch { return text; }\n    if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) return text;\n    const body = parsed as { model?: unknown; provider?: unknown; usage?: { prompt_tokens?: unknown; completion_tokens?: unknown } };\n    if (body.usage && typeof body.usage === \"object\") {\n      const number = (value: unknown) => typeof value === \"number\" ? value : undefined;\n      usage = { prompt: number(body.usage.prompt_tokens), completion: number(body.usage.completion_tokens) };\n    }\n    if (typeof body.model !== \"string\" && body.provider === undefined) return text;\n    const rest = Object.fromEntries(Object.entries(body).filter(([key]) => key !== \"provider\"));\n    return JSON.stringify(typeof body.model === \"string\" ? { ...rest, model: alias } : rest);\n  };\n  const line = (text: string): string => text.startsWith(\"data: \") ? `data: ${rewrite(text.slice(6))}` : text;\n  return {\n    feed: (chunk: Buffer): string => {\n      const text = decoder.decode(chunk, { stream: true });\n      if (overflow) return text;\n      pending += text;\n      const lines = pending.split(\"\\n\");\n      pending = lines.pop() ?? \"\";\n      const forwarded = lines.map((entry) => `${line(entry)}\\n`).join(\"\");\n      if (pending.length <= MAX_SCAN_BYTES) return forwarded;\n      overflow = true;\n      const remainder = pending;\n      pending = \"\";\n      return `${forwarded}${remainder}`;\n    },\n    finish: (): string => {\n      const rest = overflow || !pending.trim() ? pending : pending.startsWith(\"data: \") ? line(pending) : rewrite(pending);\n      pending = \"\";\n      return rest;\n    },\n    usage: (): Usage | undefined => usage,\n  };\n};\n\nconst openAiError = (message: string, type: string) => ({ error: { message, type } });\n\nconst forwardedHeaders = (request: IncomingMessage, apiKey: string): Record<string, string> => {\n  const headers: Record<string, string> = {};\n  for (const [name, value] of Object.entries(request.headers)) {\n    if (DROPPED_HEADERS.has(name) || value === undefined) continue;\n    headers[name] = Array.isArray(value) ? value.join(\", \") : value;\n  }\n  headers[\"content-type\"] = \"application/json\";\n  headers.authorization = `Bearer ${apiKey}`;\n  return headers;\n};\n\nexport interface RelayRouteOptions {\n  aliases: () => readonly ResolvedAlias[];\n  log: (line: string) => void;\n  fetch?: typeof fetch;\n}\n\nconst modelsPath = `${RELAY_PATH_PREFIX}/models`;\nconst completionsPath = `${RELAY_PATH_PREFIX}/chat/completions`;\n\nexport const createRelayRoutes = (options: RelayRouteOptions): HttpRouteContribution[] => {\n  const fetchImpl = options.fetch ?? fetch;\n  return [\n    {\n      id: \"ragents.model-relay.models\",\n      isApiPath: (pathname) => pathname.startsWith(`${RELAY_PATH_PREFIX}/`),\n      matches: (request, url) => request.method === \"GET\" && url.pathname === modelsPath,\n      requiredRights: [RELAY_RIGHT],\n      handle: ({ response }) => {\n        writeJson(response, 200, { object: \"list\", data: options.aliases().map(catalogEntryOf) });\n      },\n    },\n    {\n      id: \"ragents.model-relay.completions\",\n      isApiPath: (pathname) => pathname.startsWith(`${RELAY_PATH_PREFIX}/`),\n      matches: (request, url) => request.method === \"POST\" && url.pathname === completionsPath,\n      requiredRights: [RELAY_RIGHT],\n      handle: async ({ request, response, access }) => {\n        const user = access.user?.id ?? \"anonym\";\n        let text: string;\n        try {\n          text = await readBody(request, MAX_REQUEST_BYTES);\n        } catch (error) {\n          if (!(error instanceof PayloadTooLargeError)) throw error;\n          writeJson(response, 413, openAiError(error.message, \"invalid_request_error\"));\n          return;\n        }\n        let parsed: unknown;\n        try { parsed = JSON.parse(text); }\n        catch { parsed = undefined; }\n        if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n          writeJson(response, 400, openAiError(\"Der Anfragek\u00F6rper ist kein JSON-Objekt\", \"invalid_request_error\"));\n          return;\n        }\n        const alias = (parsed as { model?: unknown }).model;\n        if (typeof alias !== \"string\" || !alias) {\n          writeJson(response, 400, openAiError(\"Die Anfrage nennt kein Modell\", \"invalid_request_error\"));\n          return;\n        }\n        const resolved = options.aliases().find((candidate) => candidate.alias === alias);\n        if (!resolved) {\n          writeJson(response, 404, openAiError(`Das Modell ${alias} ist auf diesem Relay unbekannt`, \"invalid_request_error\"));\n          return;\n        }\n        const controller = new AbortController();\n        response.once(\"close\", () => controller.abort());\n        const target = `${resolved.upstream.baseUrl}/chat/completions`;\n        let upstream: Response;\n        try {\n          upstream = await fetchImpl(target, {\n            method: \"POST\",\n            headers: forwardedHeaders(request, resolved.upstream.apiKey),\n            body: JSON.stringify({ ...parsed, model: resolved.model.id }),\n            signal: controller.signal,\n          });\n        } catch (error) {\n          if (controller.signal.aborted) return;\n          const reason = error instanceof Error ? error.message : String(error);\n          options.log(`${user} ${alias} -> ${resolved.upstream.id}/${resolved.model.id}: nicht erreichbar (${reason})`);\n          writeJson(response, 502, openAiError(`Der Anbieter hinter ${alias} ist nicht erreichbar`, \"server_error\"));\n          return;\n        }\n        response.writeHead(upstream.status, {\n          \"Content-Type\": upstream.headers.get(\"content-type\") ?? \"application/octet-stream\",\n          \"Cache-Control\": \"no-store\",\n        });\n        const rewriter = responseRewriter(alias);\n        if (upstream.body) {\n          const source = Readable.fromWeb(upstream.body as ReadableStream<Uint8Array>);\n          try {\n            await pipeline(source, async function* (chunks: AsyncIterable<Buffer>) {\n              for await (const chunk of chunks) {\n                const forwarded = rewriter.feed(chunk);\n                if (forwarded) yield forwarded;\n              }\n              const rest = rewriter.finish();\n              if (rest) yield rest;\n            }, response);\n          } catch (error) {\n            if (!controller.signal.aborted) throw error;\n          }\n        } else {\n          response.end();\n        }\n        const usage = rewriter.usage();\n        const tokens = usage ? ` tokens in=${usage.prompt ?? \"?\"} out=${usage.completion ?? \"?\"}` : \"\";\n        options.log(`${user} ${alias} -> ${resolved.upstream.id}/${resolved.model.id}: ${upstream.status}${tokens}`);\n      },\n    },\n  ];\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/bundles/ragents.orchestration/orchestration.hbs

@@ -0,0 +1,106 @@
+# Orchestration through TypeScript
+
+You coordinate this conversation and carry out the user's requested work. The user describes
+an outcome; discover the available functions and choose the implementation yourself. A task
+or skill start prompt need not prescribe actors, subscriptions, packages or a technical workflow.
+
+## The shared API
+
+Use `typescript_api` to discover the available functions and obtain their exact input and
+result types. Use `typescript_eval` to run a small TypeScript snippet: `code` is the body of an
+async function with `context` and an optional `return`; `path` executes an existing source file
+through the same path. Call registered functions as `context.functions.<name>(input)`.
+Keep dependent calls and returned references together in code. Do not retype IDs or infer
+result shapes from event names. Type errors identify a disagreement with the contract; fix
+the assumption instead of hiding it with `any` or a double assertion.
+
+A snippet can inspect data, call extension functions, create participants and arrange a run.
+It needs no actor package, persistent setup actor or invented tests. Local variables end with
+that execution. Use an actor program when later messages, events, persistent state or a view
+are needed. Snippets and actor programs use the same registered functions and contracts.
+Use the registered file functions for editing sources, with a root alias such as `@actors/`
+instead of copied physical paths; `bash` takes such an alias path as `cwd`.
+
+A snippet acts as its caller. A TypeScript actor's `onInput` acts as that actor. An actor
+function owns its actor's state but invokes run functions as its caller: calling another
+actor's function does not become that actor. In particular, `event_subscribe` subscribes the
+acting caller. To let a persistent actor receive later events, arrange its subscription in
+its own `onInput`; send it an ordinary input to begin that work.
+
+Already completed function calls are not rolled back if a later call fails. Before retrying,
+inspect the existing actors, programs and subscriptions and resume the missing work. A failed
+snippet is not evidence that its earlier operations had no effect.
+
+## Actors and messages
+
+A run contains actors, inputs, turns, events, subscriptions and artifacts. Actors are the user,
+LLM agents or TypeScript actors. `actor_input` delivers ordinary text and explicitly attached
+artifacts. The recipient does not receive your context.
+Only LLM agents interpret arbitrary natural-language tasks. A TypeScript actor executes its
+programmed input protocol; inspect its program or documented functions before addressing it.
+Prefer its published functions for actions. A primary actor can be a TypeScript program;
+primary does not mean conversational. Enqueueing confirms delivery to the queue, not processing
+or task completion. Unknown program commands must fail explicitly instead of returning silently.
+
+Use `actor_list` before creating participants. A prepared run or another actor may already
+have created the required roles. Reuse suitable active actors even when they are not your
+children. Reusing a name in `agent_spawn` creates another actor with a suffix; it does not
+select the existing one. Inspect an unclear role before deciding to create another.
+
+Do the work yourself unless a separate role, context or independent task has a concrete
+benefit, or the user requests participants. Multiple files, languages or steps alone do not
+require more actors. Pure deterministic forwarding and persistent bookkeeping belong in
+TypeScript; `context.std.mediators.route` supports existing routing patterns. Use model
+judgment where the task needs it, not for unchanged message forwarding.
+
+Read `model_list` before the first spawn and select an actual profile or model from its
+result. A new agent does not inherit your model. Pass its profile or model explicitly and
+choose `tools` explicitly: `[]` for plain conversation, a named function selection for a
+bounded task, or `null` for the full available function inventory. Tools are not a role label:
+a critic who must inspect files needs the corresponding access; a plain advisor may need none.
+Agents inherit the engine capabilities you may pass on. Use `withoutCapabilities` only when
+an ability must deliberately be absent from a whole subtree.
+
+`agent_spawn` creates an idle actor. Its prompt describes the lasting role and output rules;
+its concrete assignment is an `actor_input`. Give it a `description` of a few words, such as
+"checks the comment rule"; people pick addressees by it in a tree of who created whom. Prepare participants, required programs, views
+and subscriptions before sending the first assignments. Subscribe to a needed reply before
+requesting it. Never assume a failed creation produced an actor.
+
+## Events and turn boundaries
+
+Ordinary model output, reasoning and function calls are journaled automatically. A subscription
+observes matching new events and delivers each as a later ActorInput to its subscriber.
+Inputs arriving during a turn wait for the next turn. A consumed input is not automatically
+repeated after interruption. An actor program receives the structured source in `input.event`;
+the event's `type` belongs to the event itself, not its payload.
+
+Once subscriptions and assignments are in place, end the turn. Do not poll `event_query`, run
+sleep loops or keep a snippet alive waiting for future model answers. A new matching input
+starts the next turn. Use `event_query` for intentional history inspection or recovery, with
+focused filters and a small limit. `event_subscription_list` lists subscriptions;
+`event_unsubscribe` removes those no longer needed.
+
+Subscribe to `model.output.completed` for answer text, or `turn.finished` when completion
+status is sufficient. Subscribe to failures, interruption and stops only where the flow
+needs an independent reaction. Combining answer and finish events routinely produces two
+inputs for one result; when both are necessary, correlate by turn and act only once.
+Keep `includeSelf` off unless an intentional self-trigger requires it.
+
+LLM event inputs show a readable header and text, plus active subscription information.
+TypeScript programs receive structured events. An actor remains addressable after a turn;
+`actor_stop` stops it and the actors it spawned.
+The primary actor can use `run_stop` to stop all work in its own run, including tools and plugin services. Use it immediately when the user requests a complete stop. It also interrupts the calling turn; no final reply is required. The conversation and files remain available.
+
+## Results for the user
+
+Verify the actual outcome against the user's requirements. A successful typecheck or tests
+written alongside the implementation do not prove the requested behavior. Keep meaningful
+checks of output, state and effects; fix implementation errors rather than changing an
+expectation merely to obtain a passing test.
+
+Your model answer is already the user chat. Report concrete results and meaningful phase
+changes; do not add a filler waiting message after assigning work. State only what happened,
+never describe an unperformed step as done. Respect prescribed output formats. Use meaningful
+actor names and keep the run's task list current when useful. Technical IDs and environment
+variables belong in code, not in explanations to the user.

package/bundles/ragents.orchestration/ragents-bundle.json

@@ -0,0 +1,194 @@
+{
+  "format": 3,
+  "id": "ragents.orchestration",
+  "api": 6,
+  "hostNames": {
+    "server": {
+      "@ragents/engine": [
+        "DomainError",
+        "ScriptDriver",
+        "actorByHandle",
+        "actorInputSchema",
+        "defineRunFunction",
+        "defineToolAvailability",
+        "enqueueActorInput",
+        "eventResultSchemaOf",
+        "holdsUsable"
+      ],
+      "@ragents/engine/src/http/contracts": [
+        "handleKey"
+      ],
+      "@ragents/host/plugin-support/actor-programs/contract": [
+        "ACTOR_PROGRAMS_STATE_ID",
+        "resolveActorView"
+      ],
+      "@ragents/host/plugin-support/agent-tool": [
+        "toolDescriptorFrom"
+      ],
+      "@ragents/host/plugin-support/plugin-folder": [
+        "pluginAsset"
+      ],
+      "@ragents/host/plugin-support/prompt": [
+        "boundToTools",
+        "handlebarsPrompt"
+      ],
+      "@ragents/host/ragents/global-chat": [
+        "runManagementToken"
+      ],
+      "@ragents/host/ragents/host-services": [
+        "runtimeProviderToken"
+      ],
+      "typebox": [
+        "Type"
+      ]
+    },
+    "web": {
+      "@ragents/engine/src/http/contracts": [
+        "handleKey",
+        "runContracts"
+      ],
+      "@ragents/web/AccessContext": [
+        "useAccess"
+      ],
+      "@ragents/web/actor-conversation": [
+        "actorChatMessages",
+        "actorInputLabel"
+      ],
+      "@ragents/web/api": [
+        "interruptActorTurn",
+        "sendActorMessage"
+      ],
+      "@ragents/web/chat-view-settings": [
+        "ChatViewSwitches",
+        "useChatViewSettings"
+      ],
+      "@ragents/web/chat/chat-target": [
+        "programChatNotice",
+        "runIsWorking"
+      ],
+      "@ragents/web/chat/StoppedActorNotice": [
+        "StoppedActorNotice"
+      ],
+      "@ragents/web/chat/useAttachmentCapabilities": [
+        "useAttachmentCapabilities"
+      ],
+      "@ragents/web/lib/format": [
+        "formatBytes"
+      ],
+      "@ragents/web/lib/labels": [
+        "thinkingLabel"
+      ],
+      "@ragents/web/lib/local-storage-setting": [
+        "createLocalStorageSetting"
+      ],
+      "@ragents/web/PluginRegistry": [
+        "SurfaceControllerProvider",
+        "useActionRenderer",
+        "useSurfaceController",
+        "useToolRenderer"
+      ],
+      "@ragents/web/rpc": [
+        "rpc"
+      ],
+      "@ragents/web/run-panel/host": [
+        "useCenterElements",
+        "useRunPanelHost"
+      ],
+      "@ragents/web/run-view": [
+        "actorTone",
+        "chatPrimaryId",
+        "isPendingRunActorInput",
+        "runActorFrom",
+        "runArtifactContentUrl",
+        "runViewFrom"
+      ],
+      "@ragents/web/SourceCode": [
+        "SourceCode"
+      ],
+      "@ragents/web/StatusGroup": [
+        "StatusGroup"
+      ],
+      "@ragents/web/Toolbar": [
+        "ToolbarCopy",
+        "ToolbarItem",
+        "ToolbarLabel",
+        "ToolbarText"
+      ],
+      "@ragents/web/ui": [
+        "Alert",
+        "AlertDescription",
+        "Badge",
+        "Button",
+        "Empty",
+        "EmptyDescription",
+        "EmptyHeader",
+        "EmptyTitle",
+        "Input",
+        "Popover",
+        "PopoverContent",
+        "SectionLabel",
+        "Select",
+        "SelectContent",
+        "SelectItem",
+        "SelectTrigger",
+        "SelectValue",
+        "Spinner",
+        "StartupNotice",
+        "StopGlyph",
+        "Tabs",
+        "TabsContent",
+        "TabsList",
+        "TabsTrigger",
+        "cn"
+      ],
+      "quassel": [
+        "ChatInputToolbar",
+        "ChatMessages",
+        "ChatPanel"
+      ],
+      "react": [
+        "createContext",
+        "createElement",
+        "forwardRef",
+        "memo",
+        "useCallback",
+        "useContext",
+        "useEffect",
+        "useId",
+        "useLayoutEffect",
+        "useMemo",
+        "useRef",
+        "useState",
+        "useSyncExternalStore"
+      ],
+      "react-dom": [
+        "createPortal"
+      ],
+      "react/jsx-runtime": [
+        "Fragment",
+        "jsx",
+        "jsxs"
+      ]
+    }
+  },
+  "stand": "04d3cd3b2394dc698c36386e4e24a5f551d75207db44ceb6295e6b0aa688656d",
+  "sourceStand": "5a6693e08ee33318be87be978178ea0676191bc1ff8a60e0a26ff951ebc1ff11",
+  "server": "server/index.js",
+  "web": {
+    "entry": "web/index.js",
+    "classes": "web/classes.json"
+  },
+  "exports": {
+    "server": {},
+    "web": {
+      "web/surface-entities": "web/exports/web/surface-entities.js",
+      "web/program-slot": "web/exports/web/program-slot.js",
+      "web/tile-docking": "web/exports/web/tile-docking.js"
+    }
+  },
+  "uses": [],
+  "assets": [
+    "orchestration.hbs",
+    "surface.hbs"
+  ]
+}

package/bundles/ragents.orchestration/server/index.js

@@ -0,0 +1,277 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+
+// server/index.ts
+import {
+  actorInputSchema,
+  enqueueActorInput,
+  eventResultSchemaOf,
+  ScriptDriver
+} from "@ragents/engine";
+import { runtimeProviderToken } from "@ragents/host/ragents/host-services.js";
+import { pluginAsset } from "@ragents/host/plugin-support/plugin-folder.js";
+import { boundToTools, handlebarsPrompt } from "@ragents/host/plugin-support/prompt.js";
+
+// server/surface-tool.ts
+import { Type } from "typebox";
+import {
+  DomainError,
+  actorByHandle,
+  defineRunFunction,
+  defineToolAvailability,
+  holdsUsable
+} from "@ragents/engine";
+import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
+import { ACTOR_PROGRAMS_STATE_ID, resolveActorView } from "@ragents/host/plugin-support/actor-programs/contract.js";
+
+// contract.ts
+import { handleKey } from "@ragents/engine/src/http/contracts";
+
+// tiled-layout.ts
+var MAX_SURFACE_TILE_DEPTH = 16;
+var MAX_SURFACE_TILES = 64;
+var surfaceTileNodeOf = (input) => {
+  const entities = /* @__PURE__ */ new Set();
+  const parse = (value, where, depth) => {
+    if (depth > MAX_SURFACE_TILE_DEPTH) throw new Error(`${where}: h\xF6chstens ${MAX_SURFACE_TILE_DEPTH} verschachtelte Teilungen sind erlaubt`);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${where} muss eine Kachel oder Teilung sein`);
+    const node = value;
+    if (Object.hasOwn(node, "entity")) {
+      if (Object.keys(node).some((key2) => key2 !== "entity" && key2 !== "chatInput")) throw new Error(`${where}: eine Kachel tr\xE4gt nur entity und chatInput; eine Teilung direction, weights und children`);
+      if (typeof node.entity !== "string") throw new Error(`${where}.entity muss @handle oder app:<name>/<view> sein`);
+      const entity = surfaceEntityOf(node.entity);
+      const key = surfaceEntityKey(entity);
+      if (node.chatInput !== void 0 && (entity.kind !== "actor" || typeof node.chatInput !== "boolean")) {
+        throw new Error(`${where}.chatInput ist nur f\xFCr Actors als Wahrheitswert erlaubt`);
+      }
+      if (entities.has(key)) throw new Error(`${where}: ${key} ist mehr als einmal als Kachel platziert`);
+      entities.add(key);
+      if (entities.size > MAX_SURFACE_TILES) throw new Error(`H\xF6chstens ${MAX_SURFACE_TILES} Kacheln sind erlaubt`);
+      return node.chatInput === void 0 ? { entity: key } : { entity: key, chatInput: node.chatInput };
+    }
+    if (Object.keys(node).some((key) => !["direction", "weights", "children"].includes(key))) throw new Error(`${where}: eine Teilung tr\xE4gt nur direction, weights und children`);
+    if (node.direction !== "horizontal" && node.direction !== "vertical") throw new Error(`${where}.direction muss horizontal oder vertical sein`);
+    if (!Array.isArray(node.weights) || node.weights.length !== 2 || node.weights.some((weight) => typeof weight !== "number" || !Number.isFinite(weight) || weight <= 0)) {
+      throw new Error(`${where}.weights muss genau zwei endliche positive Zahlen enthalten`);
+    }
+    if (!Array.isArray(node.children) || node.children.length !== 2) throw new Error(`${where}.children muss genau zwei Kacheln oder Teilungen enthalten`);
+    return {
+      direction: node.direction,
+      weights: [node.weights[0], node.weights[1]],
+      children: [parse(node.children[0], `${where}.children[0]`, depth + 1), parse(node.children[1], `${where}.children[1]`, depth + 1)]
+    };
+  };
+  return parse(input, "root", 0);
+};
+var surfaceTileEntities = (root) => !root ? [] : "entity" in root ? [root.entity] : root.children.flatMap(surfaceTileEntities);
+var mapSurfaceTileEntities = (root, resolve) => "entity" in root ? { ...root, entity: resolve(root.entity) } : {
+  ...root,
+  children: [mapSurfaceTileEntities(root.children[0], resolve), mapSurfaceTileEntities(root.children[1], resolve)]
+};
+
+// contract.ts
+var ORCHESTRATION_PLUGIN_ID = "ragents.orchestration";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var surfaceEntityOf = (text) => {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("@")) {
+    const handle = handleKey(trimmed);
+    if (!handle || /\s/.test(handle)) throw new Error(`Entit\xE4t ${JSON.stringify(text)}: nach dem @ fehlt ein Handle`);
+    return { kind: "actor", handle };
+  }
+  const match = /^app:(.+)$/s.exec(trimmed);
+  if (!match) {
+    throw new Error(`Entit\xE4t ${JSON.stringify(text)}: erwartet @handle oder app:<id>`);
+  }
+  const id = match[1].trim();
+  if (!id) throw new Error(`Entit\xE4t ${JSON.stringify(text)}: die ID nach dem Doppelpunkt ist leer`);
+  return { kind: "app", id };
+};
+var surfaceEntityKey = (entity) => entity.kind === "actor" ? `@${entity.handle}` : `app:${entity.id}`;
+var LEGACY_KEYS = ["nodes", "shapes", "lines", "mode"];
+var surfaceLayoutOf = (value) => {
+  if (!isRecord(value)) throw new Error("Die Anordnung muss ein Objekt mit root sein");
+  const legacy = LEGACY_KEYS.filter((key) => key in value);
+  if (legacy.length > 0) {
+    throw new Error(`Die Programmanordnung stammt aus der entfernten freien Fl\xE4che (${legacy.join(", ")}); canvas_layout_replace mit root setzt sie als Kachelaufteilung neu`);
+  }
+  if (!("root" in value)) throw new Error("root fehlt; erwartet wird eine Kachel, eine Teilung oder null");
+  return { root: value.root === null ? null : surfaceTileNodeOf(value.root) };
+};
+
+// server/surface-tool.ts
+var surfaceToolMetadata = {
+  name: "canvas_layout_replace",
+  label: "Replace Surface Layout",
+  description: "Arrange actors and mini-apps as tiles on the viewport-filling work surface, using a binary tree of weighted splits.",
+  longDescription: "root is the whole arrangement and replaces the stored one. A tile is {entity:'@helper'} or {entity:'app:@workspace/main'}; a split is {direction:'horizontal',weights:[1,1],children:[tile,tile]}. horizontal means left/right, vertical means top/bottom, and weights give the ratio of the two children. App left, chat right at 50:50: {root:{direction:'horizontal',weights:[1,1],children:[{entity:'app:@workspace/main'},{entity:'@helper'}]}}. One tile above two tiles at 2:1: {root:{direction:'vertical',weights:[2,1],children:[{entity:'@lead'},{direction:'horizontal',weights:[1,1],children:[{entity:'@first'},{entity:'@second'}]}]}}. root:null clears the surface. Dividers are draggable, so do not resend a layout to fight a personal arrangement. Participants you do not place stay reachable through the run header."
+};
+var canDesignSurface = defineToolAvailability({
+  availability: "conditional",
+  availabilityDetail: "Nur f\xFCr Agenten und TypeScript-Actors mit der Capability plugin.state.write.",
+  requiredCapabilities: ["plugin.state.write"]
+}, (actor) => actor.kind !== "human" && holdsUsable(actor, "plugin.state.write"));
+var tileSchema = Type.Cyclic({
+  SurfaceTile: Type.Union([
+    Type.Object({
+      entity: Type.String({ minLength: 1, description: "Actor @handle or activated mini-app app:@handle/view-key or app:program-name/view-key; the server resolves the view ID" }),
+      chatInput: Type.Optional(Type.Boolean({ description: "Actor tiles only: false hides the chat composer in the tile; default true. Does not change permissions or the inspector" }))
+    }, { additionalProperties: false }),
+    Type.Object({
+      direction: Type.Union([Type.Literal("horizontal"), Type.Literal("vertical")]),
+      weights: Type.Tuple([Type.Number({ exclusiveMinimum: 0 }), Type.Number({ exclusiveMinimum: 0 })]),
+      children: Type.Tuple([Type.Ref("SurfaceTile"), Type.Ref("SurfaceTile")])
+    }, { additionalProperties: false })
+  ])
+}, "SurfaceTile");
+var surfaceLayoutSchema = Type.Object({
+  root: Type.Union([tileSchema, Type.Null()], { description: "The whole arrangement: a tile or a binary split. Maximum 64 unique tiles and 16 nested splits. null clears the surface" })
+});
+var invalid = (message) => new DomainError("invalid-surface-layout", message, 400);
+var parsedLayout = (input) => {
+  try {
+    return surfaceLayoutOf(input);
+  } catch (caught) {
+    throw invalid(caught instanceof Error ? caught.message : String(caught));
+  }
+};
+var isStopped = (actor) => actor.kind !== "human" && actor.lifecycle.kind === "stopped";
+var surfaceActorOf = (view, reference, where) => {
+  const entity = surfaceEntityOf(reference);
+  if (entity.kind !== "actor") throw invalid(`${where}: ${reference} ist kein Actor`);
+  const handle = entity.handle;
+  const found = actorByHandle(view.actors, handle);
+  if (!found) {
+    const known = view.actors.filter((actor) => actor.kind !== "human").map((actor) => `@${actor.handle}`);
+    throw invalid(`${where}: @${handle} ist kein Actor dieses Runs. Vorhanden: ${known.join(", ") || "keine"}`);
+  }
+  if (found.kind === "human") {
+    throw invalid(`${where}: @${handle} ist der Mensch im Chat; der Chat liegt fest links neben der Fl\xE4che`);
+  }
+  return found;
+};
+var isActorReference = (reference) => surfaceEntityOf(reference).kind === "actor";
+var resolveAppReferences = (view, layout) => {
+  const programs = view.pluginStates.flatMap((entry) => {
+    if (entry.pluginId !== ACTOR_PROGRAMS_STATE_ID || entry.scope.kind !== "actor") return [];
+    const actorId = entry.scope.actorId;
+    const actor = view.actors.find((candidate) => candidate.id === actorId);
+    if (!actor || actor.kind === "human" || isStopped(actor)) return [];
+    const { program } = entry.state;
+    return program ? [program] : [];
+  });
+  const resolve = (reference, where) => {
+    const entity = surfaceEntityOf(reference);
+    if (entity.kind !== "app") return reference;
+    try {
+      return `app:${resolveActorView(programs, entity.id).view.id}`;
+    } catch (error) {
+      throw invalid(`${where}: ${reference}: ${error instanceof Error ? error.message : String(error)} Fl\xE4chenentit\xE4ten erhalten das Pr\xE4fix app:.`);
+    }
+  };
+  return parsedLayout({ root: layout.root ? mapSurfaceTileEntities(layout.root, (entity) => resolve(entity, "root")) : null });
+};
+var checkLayoutAgainstRun = (view, input) => {
+  const layout = resolveAppReferences(view, input);
+  for (const reference of surfaceTileEntities(layout.root)) {
+    if (isActorReference(reference)) surfaceActorOf(view, reference, "root");
+  }
+  return layout;
+};
+var createSurfaceTool = () => defineRunFunction({
+  ...surfaceToolMetadata,
+  schema: surfaceLayoutSchema,
+  resultSchema: Type.Null(),
+  available: canDesignSurface,
+  run: ({ runtime, caller, context }, toolCallId, input) => {
+    const view = runtime.view(caller.runId);
+    const layout = checkLayoutAgainstRun(view, parsedLayout(input));
+    runtime.replacePluginState(context(toolCallId), caller.runId, {
+      pluginId: ORCHESTRATION_PLUGIN_ID,
+      scope: { kind: "run" },
+      state: layout
+    });
+    return null;
+  }
+});
+var createSurfaceToolContributor = () => ({
+  name: "ragents.orchestration.surface",
+  descriptors: [toolDescriptorFrom(surfaceToolMetadata, canDesignSurface)],
+  tools: () => [createSurfaceTool()]
+});
+
+// server/run-stop-tool.ts
+import { Type as Type2 } from "typebox";
+import { defineRunFunction as defineRunFunction2, defineToolAvailability as defineToolAvailability2, holdsUsable as holdsUsable2 } from "@ragents/engine";
+import { toolDescriptorFrom as toolDescriptorFrom2 } from "@ragents/host/plugin-support/agent-tool.js";
+var available = defineToolAvailability2({
+  availability: "conditional",
+  availabilityDetail: "F\xFCr den Primary-Actor mit execution.stopOwned im eigenen Run.",
+  requiredCapabilities: ["execution.stopOwned"]
+}, (actor, view) => actor.kind !== "human" && actor.id === view.primaryActorId && holdsUsable2(actor, "execution.stopOwned"));
+var createRunStopContributor = (stop, onError) => {
+  const definition = defineRunFunction2({
+    name: "run_stop",
+    label: "Run stoppen",
+    description: "Leitet den vollst\xE4ndigen Stopp des eigenen Runs ein: laufende Turns, Werkzeuge, Unteragenten und Plugin-Dienste. Gespr\xE4ch und Dateien bleiben erhalten. Bricht auch den eigenen Turn ab; die Annahme ist keine Best\xE4tigung abgeschlossener Bereinigung. Bei Benutzerwunsch nach vollst\xE4ndigem Abbruch sofort verwenden, keine Abbruchnachricht an besch\xE4ftigte Agenten senden.",
+    schema: Type2.Object({}, { additionalProperties: false }),
+    resultSchema: Type2.Object({ requested: Type2.Literal(true) }, { additionalProperties: false }),
+    available,
+    run: ({ caller, signal }) => {
+      signal?.throwIfAborted();
+      void stop(caller.runId).catch(onError);
+      return { requested: true };
+    }
+  });
+  return {
+    name: "ragents.orchestration.run-stop",
+    descriptors: [toolDescriptorFrom2(definition, available)],
+    tools: () => [definition]
+  };
+};
+
+// server/index.ts
+import { runManagementToken } from "@ragents/host/ragents/global-chat.js";
+var orchestrationPlugin = {
+  manifest: { id: "ragents.orchestration" },
+  register: (host) => {
+    host.functions(createSurfaceToolContributor());
+    host.functions(createRunStopContributor(
+      (runId) => host.service(runManagementToken)().stop(runId),
+      (error) => console.error("Run-Stopp durch den Koordinator fehlgeschlagen", error)
+    ));
+    host.operations({
+      id: "actor_input",
+      label: "Actor-Input einreihen",
+      description: "Reiht f\xFCr einen Actor einen normalen Texteingang unter der gebundenen Identit\xE4t ein - als Agent oder, aus einer App-Aktion, als Besitzer des Runs. Best\xE4tigt nur das Einreihen. TypeScript-Actors verstehen ausschlie\xDFlich ihr programmiertes Eingabeprotokoll, keine freien Auftr\xE4ge.",
+      schema: actorInputSchema,
+      resultSchema: eventResultSchemaOf("actor.input.enqueued"),
+      operator: "direct",
+      execute: (context, input) => enqueueActorInput(host.service(runtimeProviderToken)(), {
+        actorId: context.principal.actorId,
+        commandId: context.invocationId,
+        ...context.principal.kind === "agent" && context.principal.turnId ? { turnId: context.principal.turnId } : {},
+        correlationId: context.invocationId,
+        causationId: context.invocationId
+      }, context.runId, input)
+    });
+    host.script({
+      id: "typescript",
+      create: (context) => ({
+        driver: new ScriptDriver({ runtime: context.runtime })
+      })
+    });
+    host.prompts(
+      handlebarsPrompt("ragents.orchestration.prompt", 600, pluginAsset("ragents.orchestration", "orchestration.hbs")),
+      boundToTools(
+        handlebarsPrompt("ragents.orchestration.surface", 650, pluginAsset("ragents.orchestration", "surface.hbs")),
+        "canvas_layout_replace"
+      )
+    );
+  }
+};
+var plugin = { create: () => orchestrationPlugin };
+export {
+  plugin
+};
+//# sourceMappingURL=index.js.map