@asterism-app/builtin-api 0.0.0-stage → 0.19.1

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Chien Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,21 @@
-# Temporary Holding Version
+# Built-in public API
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This package exposes domain contracts and extension capabilities shared by Asterism's built-in implementation and external plugins.
+
+It lets a plugin interact with existing Agent behavior, offer creation capabilities, or contribute Agent presentation without importing the implementation.
+
+Public declarations retain their identity across consumers. The package is a shared domain boundary, not a second installed plugin and not a grant of private object access.
+
+General hosting facilities belong to the SDK. Built-in-specific behavior belongs here only when it is intentionally public.
+
+## Installation
+
+Install the testing releases with `npm install --save-dev --save-exact @asterism-app/sdk@next @asterism-app/builtin-api@next`. Declare both packages as peer dependencies with `"*"` in the plugin package.
+
+The package ships TypeScript source. Asterism supplies the built-in public API at runtime, preserving shared declaration identity. Use development versions compatible with the target application; installing these packages does not install or update the built-in implementation.
+
+## Authoring material
+
+The source package includes `docs/` for built-in domain development guides and `examples/` for agent input, input preparation, resource creation, and agent UI extensions. These examples are fragments to compose into a plugin with compatible SDK and built-in API dependencies. They participate in repository type checking.
+
+The application's manual exposes these directories directly. Generic plugin development material and the complete starter package belong to `@asterism-app/sdk`.

package/docs/agents.md

@@ -0,0 +1,31 @@
+# Extend built-in agents
+
+The built-in public API lets plugins interact with Asterism's existing agents through shared action contracts and UI extension points. The contributing plugin owns its business state; the built-in implementation owns the agent's input handling and execution.
+
+## Declare the dependency
+
+Declare `@asterism-app/builtin-api` and `@asterism-app/sdk` in `peerDependencies` with `"*"`; the running application provides the public package instances, and the host does not gate loading on these ranges. For local development, source-package dependencies supply editor types. Import public contracts from the domain package so every participant uses the same declarations.
+
+Examples are TypeScript and TSX fragments for a plugin's backend or renderer. They use public packages; install additional libraries imported by the chosen example, such as Nano ID for submission identities, in the plugin project. A plugin still supplies its manifest and composition entry points.
+
+## Submit input and cancel work
+
+A backend plugin can obtain a session executor from its plugin context and submit input to an agent resource reference. This also works from external event callbacks; a tool invocation is not required. Use a resource's attachment lifetime for an object-owned connection, and pass its cancellation signal into ongoing submissions.
+
+A bridge resource can query a fresh session snapshot for resources directly linked to itself, select agent references, and invoke their public input action. Link direction expresses which resources the receiver can work with. The reverse relationship is independent, and observing a relationship does not expose another plugin's private state.
+
+Each input submission has a submission identity, parts, a delivery mode, and a sender. Reuse the submission identity when retrying the same input. `steer` delivers pending input at a request boundary; `follow` delivers it at a turn boundary. An idle agent starts execution after input admission. A successful submission call means input handling has completed, not that the agent has finished responding.
+
+File parts use content references with explicit read eligibility. Pass the appropriate content source with the action when forwarding files. Cancellation of the submission is separate from cancellation of the agent's independent execution, which has its own public action.
+
+## Prepare incoming input
+
+An external preparer can inspect, replace, or reject input using the original built-in action contract. Its replacement supplies raw action input that will be parsed again. Preparation has read capabilities and does not commit session mutations.
+
+Keep a preparer's scope tied to its business purpose. It does not replace the agent implementation or acquire a private agent executor.
+
+## Extend presentation
+
+Register agent UI extensions during frontend preparation and bind registration to its cancellation signal. Extensions can present controls, supplemental content, overlays, or modal interaction using the built-in presentation components.
+
+The plugin supplies business state for the associated agent and callbacks for user actions. A component becoming invisible does not complete or cancel waiting backend work. Remounting should reread current state, and each submission entry owns its pending and error state.

package/docs/resource-creation.md

@@ -0,0 +1,9 @@
+# Offer resource creation to agents
+
+A plugin can expose its resource's public creation contract through the built-in agent creation mechanism. The plugin still owns the resource type, initial data, projection, and lifetime. The built-in domain integration supplies the model-facing creation entry.
+
+Declare creation once and pass that original contract to the integration. A straightforward entry accepts the creation contract's input directly. A specialized entry can define a smaller model-facing input and transform it into the same creation input, such as turning a short note into a titled document.
+
+Creation participates in the host's resource and history operations. The created object links to the invoking agent. Optional initial resources remain within the request's captured resource scope. Explicit self-exposure supplies the reverse relationship; a new resource does not inherit every link or capability of its creator.
+
+Use descriptions and schemas that explain what the resulting resource means and what inputs the model should supply. Creating another agent is also an explicit domain operation with its own configuration and initial links.

package/examples/agent-input.ts

@@ -0,0 +1,24 @@
+import { nanoid } from "nanoid";
+import { SubmitAgentInput, CancelAgent, type AgentMessageSender } from "@asterism-app/builtin-api/contracts";
+import type { ModelInputPart } from "@asterism-app/sdk/contracts";
+import type { PluginContext, ResourceRef, ResourceActionOptions } from "@asterism-app/sdk/runtime";
+
+/** Backend plugins submit complete input using a resource reference; returning means acceptance, while the Agent maintains its own execution state. */
+export async function steerAgent(plugin: PluginContext, agent: ResourceRef, parts: ModelInputPart[], options?: ResourceActionOptions) {
+  await plugin.session(agent.sessionId).invoke(SubmitAgentInput, agent, {
+    submissionId: nanoid(16), mode: "steer", parts,
+  }, options);
+}
+
+/** Relay adapters provide their own resource address and the agent name on that resource, leaving the body unchanged. */
+export async function deliverAgentMessage(plugin: PluginContext, agent: ResourceRef,
+  sender: Extract<AgentMessageSender, { kind: "agent" }>, parts: ModelInputPart[], options?: ResourceActionOptions) {
+  await plugin.session(agent.sessionId).invoke(SubmitAgentInput, agent, {
+    submissionId: nanoid(16), mode: "steer", sender, parts,
+  }, options);
+}
+
+/** The Agent's independent execution is canceled through a resource action, separately from cancellation of the submission request itself. */
+export async function stopAgent(plugin: PluginContext, agent: ResourceRef) {
+  await plugin.session(agent.sessionId).invoke(CancelAgent, agent, {});
+}

package/examples/agent-ui.tsx

@@ -0,0 +1,62 @@
+import { useState } from "react";
+import type { ResourceRef } from "@asterism-app/sdk/contracts";
+import { AgentModal, AgentOverlay, AgentScrollArea, agentUI, type AgentOverlayPosition } from "@asterism-app/builtin-api/renderer";
+import { useRendererObject, type RendererModule } from "@asterism-app/sdk/renderer";
+
+/** Plugins provide business state and submission callbacks for the associated Agent; the UI only consumes this interface. */
+export interface AgentUIState {
+  question: { id: string; text: string; answer(value: string): Promise<void> } | null;
+  todos: readonly string[];
+  todoPosition: AgentOverlayPosition;
+  preview: { title: string; url: string } | null;
+  closePreview(): void;
+}
+
+/** useStateForAgent is provided by the plugin, which can subscribe to its own business service and reread the current state on remount. */
+export function questionAndTodoViews(
+  useStateForAgent: (agent: ResourceRef) => AgentUIState,
+): RendererModule {
+  function Extension() {
+    const object = useRendererObject();
+    const state = useStateForAgent(object.ref);
+    return <>
+      {!!state.todos.length && <AgentOverlay position={state.todoPosition}>
+        <ul>{state.todos.map((text, index) => <li key={index}>{text}</li>)}</ul>
+      </AgentOverlay>}
+      {state.question && <AgentOverlay position="bottom" hideComposer>
+        <Question key={state.question.id} question={state.question} />
+      </AgentOverlay>}
+      <AgentModal open={!!state.preview} title={state.preview?.title ?? "Preview"}
+        onOpenChange={open => { if (!open) state.closePreview(); }}>
+        {state.preview && <img src={state.preview.url} alt={state.preview.title} />}
+      </AgentModal>
+    </>;
+  }
+  return {
+    resources: [], cards: [], tools: [],
+    async prepare({ signal }) {
+      agentUI.register({ id: "example.questions/agent-ui", Component: Extension }, { signal });
+    },
+  };
+}
+
+function Question({ question }: { question: NonNullable<AgentUIState["question"]> }) {
+  const [answer, setAnswer] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Third-party authors can use their own control libraries; this example depends only on public packages and React.
+  return <form onSubmit={event => {
+    event.preventDefault();
+    if (busy) return;
+    setBusy(true); setError(null);
+    void question.answer(answer).catch(error => {
+      setError(error instanceof Error ? error.message : String(error));
+    }).finally(() => { setBusy(false); });
+  }}>
+    <AgentScrollArea style={{ maxHeight: "16rem" }}>
+      <label>{question.text}<input value={answer} disabled={busy} onChange={event => setAnswer(event.target.value)} /></label>
+    </AgentScrollArea>
+    <button type="submit" disabled={busy}>Answer</button>
+    {error && <p role="alert">{error}</p>}
+  </form>;
+}

package/examples/input-review.ts

@@ -0,0 +1,17 @@
+import { SubmitAgentInput } from "@asterism-app/builtin-api/contracts";
+import { pluginNamespace } from "@asterism-app/sdk/contracts";
+import { defineModule, definePlugin, implementPreparer } from "@asterism-app/sdk/runtime";
+
+/** External plugins consume built-in action declarations; they neither declare a second Agent type nor import its implementation directory. */
+export default definePlugin({
+  namespace: pluginNamespace("example.input-review"),
+  modules: [defineModule(plugin => ({
+    preparers: [implementPreparer(SubmitAgentInput, {
+      id: "review-input",
+      prepare(input, { object }) {
+        plugin.log.info(`Preparing ${input.parts.length} input parts for agent ${object.ref.id}.`);
+        return { action: "accept" };
+      },
+    })],
+  }))],
+});

package/examples/resource-creation.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { defineCreation, pluginNamespace } from "@asterism-app/sdk/contracts";
+import { definePlugin, implementCreation, implementResource } from "@asterism-app/sdk/runtime";
+import { defineAgentCreation } from "@asterism-app/builtin-api/runtime";
+
+const ns = pluginNamespace("example.documents");
+const Document = ns.resource("document", z.object({ text: z.string() }));
+const View = ns.data("view", z.object({ text: z.string() }));
+export const CreateDocument = defineCreation(Document, { id: ns.name("create"),
+  schema: z.object({ title: z.string().min(1), text: z.string().default("") }),
+});
+
+export default definePlugin({
+  namespace: ns,
+  setup() {
+    return {
+      resources: [implementResource(Document, View, {
+        creation: implementCreation(CreateDocument, { create: input => ({ title: input.title, data: { text: input.text } }) }),
+        project: data => data,
+        inspect: async data => data,
+      })],
+      modules: [
+        // Reuse the creation contract directly without copying the schema.
+        defineAgentCreation({ id: ns.name("document"), description: "Create a document.", creation: CreateDocument }),
+        // The same resource type can provide another model entry point that hides or transforms internal parameters.
+        defineAgentCreation({
+          id: ns.name("quick-note"), description: "Create a document from a short note.", creation: CreateDocument,
+          inputSchema: z.object({ note: z.string().min(1).describe("The note text.") }),
+          toInput: ({ note }) => ({ title: note.slice(0, 60), text: note }),
+        }),
+      ],
+    };
+  },
+});

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@asterism-app/builtin-api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.19.1",
+  "description": "Public domain contracts and extensions for Asterism built-in features",
+  "license": "MIT",
+  "author": "Chien Zhang",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/d3ara1n/asterism.git",
+    "directory": "packages/builtin-api"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "exports": {
+    "./contracts": "./src/contracts.ts",
+    "./renderer": "./src/renderer.ts",
+    "./runtime": "./src/runtime.ts"
+  },
+  "peerDependencies": {
+    "@asterism-app/sdk": "*",
+    "react": "^19.3.0",
+    "zod": "^4.6.5"
+  },
+  "peerDependenciesMeta": {
+    "react": { "optional": true }
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "docs",
+    "examples",
+    "README.md"
+  ]
+}

package/src/agent.ts

@@ -0,0 +1,37 @@
+import { defineCreation, defineAction } from "@asterism-app/sdk/contracts";
+import { z } from "zod";
+import { builtin } from "./identity.ts";
+import { userInputPartsSchema } from "./input.ts";
+import { agentSelectionSchema } from "./configuration.ts";
+import { agentMessageSenderSchema } from "./messaging.ts";
+
+/** Agents are ordinary resources: creation events record only identity; mutable data such as model selection belongs to private resource state. */
+export const Agent = builtin.resource("agent", z.object({}));
+/** The built-in agent preset selected by default when starting from the home page. */
+export const defaultAgentPreset = "worker";
+/** The host draft target for the first submission from the home page; this is not an action routable to an existing object. */
+export const startAgentContentTarget = { contractId: builtin.name("session.start"), resourceKind: Agent.kind } as const;
+/** Pending input is delivered at request or turn boundaries; execution starts immediately when idle. */
+export const agentInputModeSchema = z.enum(["steer", "follow"]);
+/** Submissions and drafts share a 16-character Nano ID identity. */
+export const submissionIdSchema = z.string().regex(/^[A-Za-z0-9_-]{16}$/u);
+/** title is optional; when omitted, the creation entry point generates a random display name. */
+export const agentCreateSchema = z.strictObject({
+  selection: agentSelectionSchema,
+  title: z.string().trim().min(1).max(160).optional().describe("Display title for the new Agent. When omitted, a random adjective-and-noun name such as HardStone is generated."),
+}).describe("Agent configuration and title.");
+
+export const CreateAgent = defineCreation(Agent, { id: builtin.name("agent.create"), schema: agentCreateSchema });
+export const SubmitAgentInput = defineAction(Agent, {
+  id: builtin.name("agent.submit"),
+  schema: z.strictObject({
+    submissionId: submissionIdSchema, parts: userInputPartsSchema, mode: agentInputModeSchema,
+    sender: agentMessageSenderSchema.default({ kind: "user" }),
+  }),
+});
+export type SubmitAgentInputData = z.infer<typeof SubmitAgentInput.schema>;
+export const ContinueAgent = defineAction(Agent, { id: builtin.name("agent.continue"), schema: z.strictObject({}) });
+export const ConfigureAgent = defineAction(Agent, {
+  id: builtin.name("agent.configure"), schema: z.strictObject({ selection: agentSelectionSchema }),
+});
+export const CancelAgent = defineAction(Agent, { id: builtin.name("agent.cancel"), schema: z.strictObject({}) });

package/src/catalogs.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { modelCostSchema, modelReference, resolveModelSelection, thinkingSchema } from "@asterism-app/sdk/contracts";
+import { agentSchema, type AgentSelection } from "./configuration.ts";
+import { builtin } from "./identity.ts";
+
+/** Catalogs projected by the application for built-in plugins; excludes configuration file formats, credentials, connection tests, and override editing state. */
+export const AgentConfigurations = builtin.data("agent.configurations", z.array(agentSchema));
+const modelProviderSchema = z.object({ id: z.string(), name: z.string(), enabled: z.boolean() });
+const modelSchema = z.object({
+  providerId: z.string(), modelId: z.string(), name: z.string(), enabled: z.boolean(),
+  contextWindow: z.number().nullable(), cost: modelCostSchema.nullable(),
+  generation: z.object({ maxOutputTokens: z.number().nullable() }),
+  capabilities: z.object({ reasoning: z.boolean(), tools: z.boolean(), thinkingLevels: z.array(thinkingSchema) }),
+});
+const roleSchema = z.object({ id: z.string(), enabled: z.boolean(), model: z.string().nullable(), thinking: thinkingSchema.nullable() });
+export const ModelConfiguration = builtin.data("model.configuration", z.object({
+  modelProviders: z.array(modelProviderSchema), models: z.array(modelSchema), roles: z.array(roleSchema), agents: z.array(agentSchema),
+}));
+export type ModelConfigurationSnapshot = z.infer<typeof ModelConfiguration.schema>;
+export type CatalogModel = z.infer<typeof modelSchema>;
+
+export function resolveCatalogModel<M extends CatalogModel>(snapshot: Omit<ModelConfigurationSnapshot, "models"> & { models: M[] }, reference: string | null): M | null {
+  return snapshot.models.find(model => model.enabled && modelReference(model) === reference
+    && snapshot.modelProviders.some(provider => provider.id === model.providerId && provider.enabled)) ?? null;
+}
+export function resolveAgentModel<M extends CatalogModel>(snapshot: Omit<ModelConfigurationSnapshot, "models"> & { models: M[] }, selection: { agent: string | null; model: string | null }): M | null {
+  return resolveAgentModelSelection(snapshot, { ...selection, thinking: null }).model;
+}
+
+/** Display resolution against the current catalogs; preserves raw overrides and invalid references, while requests independently use the configuration at their boundaries. */
+export function resolveAgentModelSelection<M extends CatalogModel>(
+  snapshot: Omit<ModelConfigurationSnapshot, "models"> & { models: M[] },
+  selection: Omit<AgentSelection, "agent"> & { agent: string | null },
+) {
+  const agent = snapshot.agents.find(item => item.id === selection.agent && item.enabled);
+  const role = snapshot.roles.find(item => item.id === (agent?.modelRole ?? "default"));
+  const resolved = resolveModelSelection(role, selection);
+  return {
+    reference: resolved.model,
+    model: agent && role?.enabled ? resolveCatalogModel(snapshot, resolved.model) : null,
+    thinking: resolved.thinking,
+  };
+}

package/src/configuration.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { modelExpressionSchema, thinkingSchema } from "@asterism-app/sdk/contracts";
+const id = z.string().min(1).max(160);
+/** Configurations use readable slugs for identification by both users and models. */
+export const configurationIdSchema = z.string().trim().min(1).max(160).regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/u, "Use lowercase letters, digits, hyphens or underscores.");
+const names = z.array(id).max(200);
+const agentFieldsSchema = z.strictObject({
+  enabled: z.boolean(), description: z.string().max(20_000), systemPrompt: z.string().max(100_000),
+  modelRole: configurationIdSchema.nullable(), fallbackRole: configurationIdSchema.nullable(), examples: z.array(z.string().max(4_000)).max(50),
+  tools: names.nullable(), excludeTools: names.nullable(), subagentRoles: z.array(configurationIdSchema).max(200).nullable(),
+  maxTurns: z.number().int().positive().nullable(),
+});
+export const agentInputSchema = agentFieldsSchema.refine(value => value.tools === null || value.excludeTools === null, "Tool allowlist and denylist are mutually exclusive.");
+export const agentSchema = agentInputSchema.safeExtend({ id: configurationIdSchema, builtin: z.boolean() });
+// Blank text removes the override on save; false, null, and empty lists retain their respective business meanings.
+export const agentOverridesSchema = agentFieldsSchema.partial()
+  .refine(value => value.tools == null || value.excludeTools == null, "Tool allowlist and denylist are mutually exclusive.");
+
+export type AgentConfiguration = z.infer<typeof agentSchema>;
+export type AgentOverrides = z.infer<typeof agentOverridesSchema>;
+export const agentSelectionSchema = z.strictObject({
+  agent: configurationIdSchema.describe("ID of the configuration supplying this Agent's instructions and tool policy."),
+  model: modelExpressionSchema.nullable().describe("Model for this Agent as provider/model. Null uses the model resolved from its configuration."),
+  thinking: thinkingSchema.nullable().describe("Thinking level for this Agent. Null uses the default resolved from its configuration."),
+}).describe("The Agent's base configuration and per-instance model settings.");
+export type AgentSelection = z.infer<typeof agentSelectionSchema>;

package/src/contracts.ts

@@ -0,0 +1,13 @@
+export * from "./identity.ts";
+export * from "./agent.ts";
+export * from "./messaging.ts";
+export * from "./text.ts";
+export * from "./tools.ts";
+export * from "./search.ts";
+export * from "./configuration.ts";
+export * from "./input.ts";
+export * from "./records.ts";
+export * from "./request-context.ts";
+export * from "./naming.ts";
+export * from "./catalogs.ts";
+export * from "./creations.ts";

package/src/creations.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { defineCall } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+
+/** The public association between model-facing creation entry points and resource types; excludes instance titles and execution permissions. */
+export const ReadAgentCreations = defineCall(builtin.name("creations.read"), {
+  scope: "plugin",
+  input: z.strictObject({}),
+  output: z.array(z.strictObject({ id: z.string(), resourceKind: z.string() })),
+});

package/src/identity.ts

@@ -0,0 +1,4 @@
+import { pluginNamespace } from "@asterism-app/sdk/contracts";
+
+/** The built-in feature plugin; all built-in modules declare contributions under its namespace. */
+export const builtin = pluginNamespace("asterism.builtin");

package/src/input.ts

@@ -0,0 +1,9 @@
+import { modelInputPartsSchema, modelInputText, type ModelInputPart } from "@asterism-app/sdk/contracts";
+
+/** Business limits for a single user input; model requests accumulate history separately. */
+export const userInputPartsSchema = modelInputPartsSchema.max(128)
+  .refine(parts => parts.some(part => part.kind === "file" || part.text.trim().length > 0), "A message requires text or a file.")
+  .refine(parts => modelInputText(parts).length <= 100_000, "The message text exceeds the size limit.");
+export function inputSummary(parts: readonly ModelInputPart[]): string {
+  return modelInputText(parts).trim() || parts.flatMap(part => part.kind === "file" ? [part.filename ?? part.mediaType] : []).join(", ");
+}

package/src/manual.ts

@@ -0,0 +1,5 @@
+/** One directory exposed under a distinct relative path in the manual; files remain at their original location. */
+export interface ManualSource {
+  readonly path: string;
+  readonly directory: string;
+}

package/src/messaging.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { defineTool } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+
+/** The sender retains the communication resource and agent name; recipient addressing is declared by the resource tool implementation. */
+export const agentMessageSenderSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("user") }),
+  z.strictObject({
+    kind: z.literal("agent"),
+    resource: z.strictObject({ sessionId: z.string().min(1), id: z.string().min(1), kind: z.string().min(1) }),
+    name: z.string().min(1),
+  }),
+]);
+export type AgentMessageSender = z.infer<typeof agentMessageSenderSchema>;
+
+/** The host matches resource types; target is declared by each resource implementation. */
+export const Send = defineTool({
+  id: builtin.name("tool.send"), name: "send",
+  description: "Send a message to an Agent through a linked resource.",
+  guidelines: [
+    "resource_id selects the messaging resource. Its target schema describes recipient selection.",
+    "The runtime supplies the sender's resource address and Agent name.",
+    "Accepted messages enter the next request boundary while the recipient is running, or start execution while idle.",
+    "Acceptance confirms delivery to the input queue; the recipient processes the message independently.",
+  ],
+  argsSchema: z.strictObject({
+    message: z.string().min(1).refine(value => value.trim().length > 0, "A message must contain text.")
+      .describe("Message text for the recipient Agent."),
+  }).describe("The message to send."),
+});

package/src/naming.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { defineRecord } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+
+/**
+ * Session-level naming events: append one for each naming operation that takes effect; existing events are not rewritten.
+ * Automatic naming includes the triggering message, level, and generating model; subsequent decisions read only the latest event.
+ */
+export const SessionNamed = defineRecord(builtin.name("session.named"), {
+  schema: z.strictObject({
+    title: z.string().min(1).max(160),
+    source: z.enum(["user", "agent", "auto"]),
+    auto: z.strictObject({
+      level: z.enum(["initial", "refined"]),
+      messageId: z.string(),
+      model: z.string(),
+    }).optional(),
+  }).refine(data => (data.source === "auto") === (data.auto !== undefined), "Only automatic names carry naming metadata."),
+});
+
+export interface NamingApi {
+  nameByUser(sessionId: string, title: string): void;
+}

package/src/records.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineRecord, modelBlockSchema, modelCompletionSchema, modelInputPartsSchema } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+import { agentMessageSenderSchema } from "./messaging.ts";
+
+/** The record source of an input message is the receiving agent; the communication sender is represented independently by sender. */
+export const AgentInputMessage = defineRecord(builtin.name("agent.input-message"), {
+  schema: z.object({ parts: modelInputPartsSchema, startsTurn: z.boolean(), sender: agentMessageSenderSchema }),
+});
+export const Execution = defineRecord(builtin.name("agent.execution"), {
+  schema: z.strictObject({ type: z.literal("block"), block: modelBlockSchema }),
+});
+/** A summary replaces only the prefix of model input; keptFrom points to the first history node retained unchanged. */
+export const ContextSummary = defineRecord(builtin.name("agent.context-summary"), {
+  schema: z.strictObject({
+    summary: z.string().trim().min(1),
+    keptFrom: z.string().min(1),
+    model: z.string().min(1),
+    tokensBefore: z.number().nonnegative(),
+    completion: modelCompletionSchema,
+  }),
+});

package/src/renderer.ts

@@ -0,0 +1,112 @@
+import { createContext, createElement, useContext, type ComponentProps, type ComponentType, type ReactNode } from "react";
+import { pluginOf, pluginNamespace, type ThinkingLevel, type UiText } from "@asterism-app/sdk/contracts";
+import type { AgentSelection } from "./configuration.ts";
+import type { CatalogModel } from "./catalogs.ts";
+
+/** One instance mounts per expanded Agent card; obtains the associated object through SDK useRendererObject. */
+export interface AgentUIContribution {
+  readonly id: string;
+  readonly Component: ComponentType;
+}
+
+/** The frontend registry shared by the built-in implementation and consumers; business state remains owned by the contributing plugin. */
+function createAgentUIRegistry() {
+  let entries: readonly AgentUIContribution[] = [];
+  const listeners = new Set<() => void>();
+  const notify = () => { for (const listener of listeners) listener(); };
+  return {
+    getSnapshot: () => entries,
+    subscribe(listener: () => void) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+    /** Register in renderer.prepare; released through signal on preparation failure, timeout, or application exit. */
+    register(contribution: AgentUIContribution, { signal }: { signal: AbortSignal }): () => void {
+      signal.throwIfAborted();
+      const plugin = pluginOf(contribution.id);
+      if (!plugin) throw new Error(`Agent UI contribution needs a namespaced ID: ${contribution.id}`);
+      pluginNamespace(plugin).name(contribution.id.slice(plugin.length + 1));
+      if (entries.some(entry => entry.id === contribution.id))
+        throw new Error(`Duplicate Agent UI contribution: ${contribution.id}`);
+      const entry = Object.freeze({ ...contribution });
+      const remove = () => {
+        signal.removeEventListener("abort", remove);
+        if (!entries.includes(entry)) return;
+        entries = entries.filter(value => value !== entry);
+        notify();
+      };
+      signal.addEventListener("abort", remove, { once: true });
+      entries = [...entries, entry];
+      notify();
+      return remove;
+    },
+  };
+}
+
+export const agentUI = createAgentUIRegistry();
+
+/** The current selection and catalog resolution result; does not represent the model used by an executing request and contains no credentials. */
+export interface AgentModelSelection {
+  readonly selection: Readonly<AgentSelection> | null;
+  readonly reference: string | null;
+  readonly model: Readonly<CatalogModel> | null;
+  readonly thinking: ThinkingLevel | null;
+}
+const ModelSelection = createContext<AgentModelSelection | null>(null);
+/** The built-in Agent injects a read-only selection for the same card and all its contributions. */
+export const AgentModelSelectionProvider = ModelSelection.Provider;
+export function useAgentModelSelection(): AgentModelSelection {
+  const selection = useContext(ModelSelection);
+  if (!selection) throw new Error("Agent model selection must be read inside an Agent card.");
+  return selection;
+}
+
+export interface AgentToolbarItemProps {
+  children: ReactNode;
+}
+export type AgentOverlayPosition = "top" | "center" | "bottom";
+export interface AgentOverlayProps {
+  position: AgentOverlayPosition;
+  /** Hides and disables the input area while the UI exists; multiple requests are combined with OR. */
+  hideComposer?: boolean;
+  children: ReactNode;
+}
+export interface AgentModalProps {
+  open: boolean;
+  title: UiText;
+  description?: UiText;
+  /** Wide content, such as proposal comparisons, can explicitly use a wider standard modal. */
+  size?: "default" | "wide";
+  /** Closing is only a UI intent; the plugin decides whether to end the business wait. No close control is provided when omitted. */
+  onOpenChange?(open: boolean): void;
+  hideComposer?: boolean;
+  children: ReactNode;
+}
+/** The standard scroll viewport within an overlay/modal; the built-in implementation consistently reserves space for control focus rings. */
+export interface AgentScrollAreaProps extends ComponentProps<"div"> {
+  axis?: "vertical" | "horizontal" | "both";
+}
+
+/** The built-in Agent injects the layout implementation; the public package does not depend on implementation packages or control libraries. */
+export interface AgentUIRenderer {
+  ToolbarItem: ComponentType<AgentToolbarItemProps>;
+  Overlay: ComponentType<AgentOverlayProps>;
+  Modal: ComponentType<AgentModalProps>;
+  ScrollArea: ComponentType<AgentScrollAreaProps>;
+}
+const Renderer = createContext<AgentUIRenderer | null>(null);
+export const AgentUIRendererProvider = Renderer.Provider;
+function useAgentUIRenderer(): AgentUIRenderer {
+  const renderer = useContext(Renderer);
+  if (!renderer) throw new Error("Agent UI must be rendered inside an Agent card.");
+  return renderer;
+}
+export function AgentOverlay(props: AgentOverlayProps): ReactNode {
+  return createElement(useAgentUIRenderer().Overlay, props);
+}
+export function AgentToolbarItem(props: AgentToolbarItemProps): ReactNode {
+  return createElement(useAgentUIRenderer().ToolbarItem, props);
+}
+export function AgentModal(props: AgentModalProps): ReactNode {
+  return createElement(useAgentUIRenderer().Modal, props);
+}
+export function AgentScrollArea(props: AgentScrollAreaProps): ReactNode {
+  return createElement(useAgentUIRenderer().ScrollArea, props);
+}

package/src/request-context.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { builtin } from "./identity.ts";
+
+const characters = z.number().int().nonnegative();
+
+/** Structural measurements of a work request, saved with completion; character counts use Unicode code points. */
+export const AgentRequestContext = builtin.data("agent.request-context", z.object({
+  system: z.array(z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("system"), from: z.string(), characters }),
+    z.strictObject({ kind: z.literal("agent"), role: z.string(), characters }),
+    z.strictObject({ kind: z.literal("context"), file: z.string(), characters }),
+  ])).optional(),
+  tools: z.array(z.string()).optional(),
+}));
+export type AgentRequestContextData = z.infer<typeof AgentRequestContext.schema>;

package/src/runtime.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { belongsTo, jsonSchema, type CreationContract, type Json, type SessionDirectory } from "@asterism-app/sdk/contracts";
+import { defineModule, PluginApiError, type PluginContext, type PluginModule, type ObjectReader, type TopLevelToolContext } from "@asterism-app/sdk/runtime";
+
+export type { ManualSource } from "./manual.ts";
+
+export interface AgentCreationDescription {
+  readonly id: string;
+  readonly resourceKind: string;
+  readonly description: string;
+  readonly guidelines: readonly string[];
+  readonly input: Json;
+}
+interface Entry {
+  readonly description: AgentCreationDescription;
+  create(input: Json, context: TopLevelToolContext): ReturnType<TopLevelToolContext["session"]["create"]>;
+}
+type CreationOptions = Parameters<TopLevelToolContext["session"]["create"]>[2];
+/** Catalogs are isolated by host runtime instance; shared public exports do not mix plugin registrations from different hosts. */
+const directories = new WeakMap<SessionDirectory, Map<string, Entry>>();
+function directory(plugin: PluginContext): Map<string, Entry> {
+  plugin.lifetime.signal.throwIfAborted();
+  let entries = directories.get(plugin.sessions);
+  if (!entries) { entries = new Map(); directories.set(plugin.sessions, entries); }
+  return entries;
+}
+function entry(plugin: PluginContext, id: string): Entry {
+  const value = directory(plugin).get(id);
+  if (!value) throw new PluginApiError("not_found", "This Agent creation entry is unavailable. Read creation_list for available entries.");
+  return value;
+}
+
+/** The domain service shared by built-in creation tools and plugins; querying is not a prerequisite for creation. */
+export const agentCreations = {
+  list(plugin: PluginContext) {
+    return [...directory(plugin).values()].map(({ description: { id, resourceKind, description } }) => ({ id, resourceKind, description }));
+  },
+  inspect(plugin: PluginContext, id: string): AgentCreationDescription { return structuredClone(entry(plugin, id).description); },
+  create(plugin: PluginContext, id: string, input: Json, context: TopLevelToolContext) {
+    return entry(plugin, id).create(input, context);
+  },
+};
+
+/** Agent creation entry points are independent domain contributions; they reuse creation input directly or explicitly adapt model input. */
+export function defineAgentCreation<I, S extends Json, O extends Json, A extends Json = Json>(definition: {
+  id: string;
+  description: string;
+  guidelines?: readonly string[];
+  creation: CreationContract<I, S, O>;
+} & ({ inputSchema?: never; toInput?: never; toOptions?: never } | {
+  inputSchema: z.ZodType<A>;
+  toInput(input: A, context: { object: ObjectReader }): I & Json;
+  toOptions?(input: A, context: { object: ObjectReader }): CreationOptions;
+})): PluginModule {
+  return defineModule(plugin => {
+    if (!belongsTo(plugin.id, definition.id)) throw new PluginApiError("invalid_argument", "The Agent creation entry belongs to another plugin.");
+    if (!definition.description.trim()) throw new PluginApiError("invalid_argument", "An Agent creation entry needs a description.");
+    const entries = directory(plugin);
+    if (entries.has(definition.id)) throw new PluginApiError("conflict", `Duplicate Agent creation entry: ${definition.id}`);
+    const input = jsonSchema.parse(z.toJSONSchema(definition.inputSchema ?? definition.creation.schema, { io: "input" }));
+    const value: Entry = {
+      description: { id: definition.id, resourceKind: definition.creation.resource.kind,
+        description: definition.description, guidelines: [...definition.guidelines ?? []], input },
+      create(raw, context) {
+        plugin.lifetime.signal.throwIfAborted(); context.signal.throwIfAborted();
+        let converted: I & Json;
+        let options: CreationOptions;
+        if (definition.inputSchema) {
+          const parsed = definition.inputSchema.safeParse(raw);
+          if (!parsed.success) throw new PluginApiError("invalid_argument", parsed.error.message);
+          converted = jsonSchema.parse(definition.toInput(parsed.data, { object: context.object })) as I & Json;
+          options = definition.toOptions?.(parsed.data, { object: context.object });
+        } else converted = raw as I & Json;
+        return context.session.create(definition.creation, converted, options);
+      },
+    };
+    entries.set(definition.id, value);
+    // Remove registrations as soon as the plugin aborts: a plugin whose assembly failed must not remain publicly queryable during asynchronous cleanup.
+    plugin.lifetime.signal.addEventListener("abort", () => { if (entries.get(definition.id) === value) entries.delete(definition.id); }, { once: true });
+    return {};
+  });
+}

package/src/search.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { defineTool } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+
+const pattern = z.string().min(1).refine(value => !value.includes("\0"), "Patterns must be free of NUL characters.");
+const selection = {
+  hidden: z.boolean().optional().describe("Disable hidden-entry filtering; defaults to false. Ignore-file filtering is controlled separately by noIgnore."),
+  noIgnore: z.boolean().optional().describe("Disable ignore-file filtering; defaults to false. Hidden-entry filtering is controlled separately by hidden."),
+  limit: z.number().int().positive().max(2000).optional().describe("Maximum returned matching lines in grep content mode, or files otherwise; defaults to 500, maximum 2000. Context lines are bounded only by the output-byte budget. Matching lines with omitted content count toward the limit."),
+};
+const globGuidelines = [
+  "Globs use ripgrep semantics. A pattern without '/' such as '*.md' matches filenames at any depth.",
+  "Positive globs override hidden and ignore rules for entries they match. A directory that remains excluded is skipped with its descendants.",
+];
+
+export const Find = defineTool({
+  id: builtin.name("tool.find"), name: "find",
+  description: "Find files by glob pattern within a resource.",
+  guidelines: globGuidelines,
+  argsSchema: z.strictObject({
+    pattern: pattern.describe("File glob relative to the selected search directory, using '/' separators; for example '**/*.ts' or '**/package.json'."),
+    ...selection,
+  }).describe("A file glob and search selection options."),
+});
+
+export const Grep = defineTool({
+  id: builtin.name("tool.grep"), name: "grep",
+  description: "Search file content for a regular expression or literal text within a resource.",
+  guidelines: [
+    "content mode groups matching and context lines under a per-file heading; when context lines are present, the heading lists the matching line numbers. files mode returns matching paths; count mode returns the number of matching lines per file.",
+    "Regular expressions use ripgrep's default Rust regex syntax. Matching is line-oriented.",
+    "Complete UTF-8 content rows include LINE#HASH edit anchors by default, shared with read and edit.",
+    ...globGuidelines,
+  ],
+  argsSchema: z.strictObject({
+    pattern: pattern.describe("Regular expression to search for, or literal text when literal is true."),
+    literal: z.boolean().optional().describe("Interpret pattern as literal text; defaults to false."),
+    ignoreCase: z.boolean().optional().describe("Use case-insensitive matching; defaults to false."),
+    word: z.boolean().optional().describe("Match only at word boundaries; defaults to false."),
+    glob: z.array(pattern).optional().describe("File globs relative to the search directory. Prefix exclusions with '!'; later globs take precedence."),
+    context: z.number().int().min(0).max(20).optional().describe("Lines before and after each match in content mode; defaults to 0."),
+    outputMode: z.enum(["content", "files", "count"]).optional().describe("Result format; defaults to content. Count means matching lines, rather than regex occurrences."),
+    anchored: z.boolean().optional().describe("Include edit anchors in content mode; defaults to true."),
+    ...selection,
+  }).describe("Content pattern, file selection and output options."),
+});
+
+export type FindArgs = z.infer<typeof Find.argsSchema>;
+export type GrepArgs = z.infer<typeof Grep.argsSchema>;

package/src/text.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+export const lineAnchorSchema = z.strictObject({
+  line: z.number().int().positive().describe("1-based line number copied from an anchored read or edit result."),
+  hash: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{4}$/).describe("The exact four-character content hash after # in an anchored read or edit result."),
+}).describe("A LINE#HASH reference to the current content at one line.");
+const body = z.array(z.string().regex(/^[^\r\n]*$/).describe("One content line without a line terminator; an empty string represents a blank line."))
+  .min(1).describe("New text lines to insert or use as replacement content.");
+const anchor = lineAnchorSchema.describe("The first affected line, or the preserved line next to an insertion.");
+const end = lineAnchorSchema.optional().describe("Inclusive last line for replace/delete. Omission selects a single line. Validation checks the cited endpoints.");
+export const editOperationSchema = z.discriminatedUnion("op", [
+  z.strictObject({ op: z.literal("replace"), anchor, end, body }),
+  z.strictObject({ op: z.literal("delete"), anchor, end }),
+  z.strictObject({ op: z.literal("insert_after"), anchor, body }),
+  z.strictObject({ op: z.literal("insert_before"), anchor, body }),
+  z.strictObject({ op: z.literal("append"), body }),
+  z.strictObject({ op: z.literal("prepend"), body }),
+]).describe("Replace/delete an inclusive anchored range, insert beside a preserved anchor, or append/prepend without anchors.");
+
+export const textRowSchema = z.strictObject({
+  line: z.number().int().positive().describe("The absolute 1-based line number in the complete text."),
+  content: z.string().describe("The line content without its terminator; for an excerpt, only the excerpt window."),
+  hash: z.string().nullable().describe("LINE#HASH content hash of the complete line, also for an excerpt; null when anchors were not requested."),
+  excerpt: z.strictObject({
+    start: z.number().int().nonnegative().describe("UTF-16 offset of content within the complete line."),
+    length: z.number().int().positive().describe("UTF-16 length of the complete line."),
+  }).nullable().describe("Present when the line is too long to return in full; content is then a window of the complete line. Null for a complete line."),
+});
+export type TextRow = z.infer<typeof textRowSchema>;
+export const textReadSchema = z.strictObject({
+  totalLines: z.number().int().nonnegative().describe("Number of logical lines in the complete text; empty text has zero lines."),
+  fromLine: z.number().int().positive().describe("First requested line, counted from 1 in the complete text."),
+  rows: z.array(textRowSchema).describe("Selected lines and their available edit anchors; long lines are returned as excerpts."),
+  noFinalNewline: z.boolean().describe("Whether non-empty text lacks a final newline."),
+  nextOffset: z.number().int().positive().nullable().describe("First unread line after the returned range, or null at end of text. Use as target.offset only when this implementation supports line selection."),
+}).describe("Selected text lines and edit anchors, final-newline information and a continuation position.");
+
+export const textChangeSchema = z.strictObject({
+  changed: z.boolean().describe("Whether the target was created or its content changed."),
+  diff: z.string().describe("The actual unified diff, preserving final-newline and CRLF differences."),
+  added: z.number().int().nonnegative().describe("Number of added lines in the actual diff."),
+  removed: z.number().int().nonnegative().describe("Number of removed lines in the actual diff."),
+  anchors: z.array(textRowSchema).describe("Fresh anchors for lines produced by edit, including a line shifted into a deletion gap. Always empty for write."),
+  anchorsTruncated: z.boolean().describe("True when the fresh anchors cover a subset of the changed lines."),
+}).describe("The committed content change with an actual diff and bounded fresh edit anchors. write returns an empty anchors array.");
+export type TextRead = z.infer<typeof textReadSchema>;
+export type TextChange = z.infer<typeof textChangeSchema>;

package/src/tools.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { defineTool } from "@asterism-app/sdk/contracts";
+import { builtin } from "./identity.ts";
+import { editOperationSchema } from "./text.ts";
+
+/**
+ * Public resource tools: declarations specify only parameters and semantics; each resource implementation declares what target selects and what results contain.
+ * Third-party resources can implement the same declaration, letting models operate on different resources through the same tool name.
+ */
+export const List = defineTool({
+  id: builtin.name("tool.list"),
+  name: "list",
+  description: "List the entries in a container to discover its contents and entry types.",
+  guidelines: [
+    "target selects a container according to the resource implementation's schema. args is an empty object.",
+    "The result describes immediate entries and includes a truncation indicator.",
+  ],
+  argsSchema: z.strictObject({}).describe("Empty parameter object."),
+});
+
+export const Read = defineTool({
+  id: builtin.name("tool.read"),
+  name: "read",
+  description: "Read the selected content as text.",
+  guidelines: [
+    "target selects the content and its range according to the resource implementation's schema.",
+    "Editable text includes LINE#HASH edit anchors by default; args:{\"anchored\":false} omits them. Content that cannot be edited has no anchors.",
+    "The result reports positions and a continuation point where the implementation supports ranges.",
+  ],
+  argsSchema: z.strictObject({
+    anchored: z.boolean().optional().describe("Include edit anchors for editable text; defaults to true."),
+  }).describe("Reading behavior. Content selection and range belong to target."),
+});
+
+export const Edit = defineTool({
+  id: builtin.name("tool.edit"),
+  name: "edit",
+  description: "Apply a batch of line-anchored text edits to an existing target, and return the actual diff and fresh anchors.",
+  guidelines: [
+    "target selects existing editable text according to the resource implementation's schema. args.edits contains the operations.",
+    "Anchors contain a line number and its content hash, as returned by read or edit.",
+    "replace/delete affect the inclusive anchor..end range. An omitted end selects one line. Validation checks the cited endpoints.",
+    "insert_before/insert_after preserve the anchor line. body contains the new lines.",
+    "append/prepend take body. Each body item is one text line; an empty string represents a blank line.",
+    "All operations refer to the same pre-edit content and commit as one batch. Anchor or overlap failures preserve the original text.",
+    "Anchor mismatch results include current-line or shifted candidates. Successful results include the actual diff and fresh anchors.",
+  ],
+  argsSchema: z.strictObject({
+    edits: z.array(editOperationSchema).min(1).max(500).describe("One to 500 non-overlapping hashline operations, all referring to the same current text."),
+  }).describe("A complete batch of line-based edit operations. The target is selected separately."),
+});
+
+export const Write = defineTool({
+  id: builtin.name("tool.write"),
+  name: "write",
+  description: "Write the complete text to a target, creating it where supported or overwriting its existing content.",
+  guidelines: [
+    "args.content is the complete desired text, including line endings and final newline.",
+    "target selects the destination according to the resource implementation's schema, which states whether missing targets are created.",
+    "An existing target is overwritten. Success returns a brief confirmation and change statistics.",
+  ],
+  argsSchema: z.strictObject({
+    content: z.string().describe("The complete new UTF-8 text. Empty content clears the target."),
+  }).describe("Full replacement text. The implementation specifies its content size limit."),
+});
+
+export const See = defineTool({
+  id: builtin.name("tool.see"),
+  name: "see",
+  description: "View an image so its pixels are attached to the tool result for you to inspect.",
+  guidelines: [
+    "target selects the image according to the resource implementation's schema. args is an empty object.",
+  ],
+  argsSchema: z.strictObject({}).describe("Empty parameter object."),
+});
+
+export const Wait = defineTool({
+  id: builtin.name("tool.wait"),
+  name: "wait",
+  description: "Wait until a resource reaches its resting state, up to a timeout.",
+  guidelines: [
+    "The resource implementation defines its resting state. A resource already at rest returns immediately.",
+    "Timeout or cancellation ends only the wait; the resource continues its own work. The result reports the observed state.",
+  ],
+  argsSchema: z.strictObject({
+    timeout: z.number().positive().max(2147483).describe("Maximum wait in seconds."),
+  }).describe("A bounded wait."),
+});