create-relkit 0.4.0 → 0.5.0

package/dist/templates/default/v1/agent/src/hello/agents/assistant.agent.ts

@@ -1,16 +1,49 @@
 import { defineAgent } from "@relkit/app/agents";
 import { z } from "@relkit/app/schema";
+import { FakeToolCallingModel, todoListMiddleware, tool } from "langchain";
 import lookup from "@app/hello/tools/lookup.tool.js";
 
+export const uppercase = tool(async ({ text }) => text.toUpperCase(), {
+  name: "uppercase",
+  description: "Uppercase text without leaving the process",
+  schema: z.object({ text: z.string() }),
+});
+
 export default defineAgent({
   id: "hello.assistant",
 
-  input: z.object({ question: z.string().min(1) }),
+  input: z.object({ message: z.string().min(1) }),
   output: z.object({ answer: z.string() }),
 
-  model: "openai:gpt-5-mini",
-  instructions: "Answer greeting questions with the read-only lookup tool.",
-  tools: [lookup],
+  model: new FakeToolCallingModel({
+    toolCalls: [
+      [
+        {
+          name: "write_todos",
+          args: { todos: [{ content: "Answer the greeting", status: "completed" }] },
+          id: "todo-1",
+        },
+      ],
+      [
+        {
+          name: "relkit_output",
+          args: { value: { answer: "Hello from the offline LangChain model." } },
+          id: "output-1",
+        },
+      ],
+    ],
+  }),
+  instructions: "Answer greeting questions with the available tools.",
+  tools: [lookup, uppercase],
+  middleware: [todoListMiddleware()],
+  stateProfile: "default",
+  client: {
+    public: true,
+    state: ["todos"],
+    events: { notice: z.object({ message: z.string() }) },
+  },
+  chat: { input: "message", output: "answer" },
+  controls: ["stop"],
 
   limits: {
     maxSteps: 4,

package/dist/templates/default/v1/agent/src/hello/agents/review.agent.ts

@@ -0,0 +1,43 @@
+import { defineGraph, defineGraphNode } from "@relkit/app/agents";
+import { z } from "@relkit/app/schema";
+import { END, MemorySaver, START, StateSchema, interrupt } from "@langchain/langgraph";
+
+const state = new StateSchema({
+  request: z.string(),
+  approved: z.boolean().optional(),
+  result: z.string().optional(),
+});
+
+const review = defineGraphNode({
+  id: "review",
+  input: z.object({ request: z.string() }),
+  output: z.object({ approved: z.boolean() }),
+  resume: z.boolean(),
+  handler: ({ request }) => ({
+    approved: interrupt({ question: `Approve "${request}"?` }) as boolean,
+  }),
+});
+
+const finish = defineGraphNode({
+  id: "finish",
+  input: z.object({ request: z.string(), approved: z.boolean() }),
+  output: z.object({ result: z.string() }),
+  handler: ({ request, approved }) => ({
+    result: approved ? `${request} approved` : `${request} rejected`,
+  }),
+});
+
+export default defineGraph({
+  id: "hello.review",
+  state,
+  input: z.object({ request: z.string().min(1) }),
+  output: z.object({ result: z.string() }),
+  nodes: [review, finish],
+  edges: (graph) =>
+    graph.addEdge(START, "review").addEdge("review", "finish").addEdge("finish", END),
+  checkpointer: new MemorySaver(),
+  stateProfile: "default",
+  client: { public: true, state: ["approved", "result"] },
+  controls: ["stop"],
+  limits: { maxSteps: 4, maxToolCalls: 1, timeoutMs: 10_000 },
+});

package/dist/templates/default/v1/agent/src/platform/env.ts

@@ -2,6 +2,4 @@ import { defineEnv, env } from "@relkit/app/config";
 
 export default defineEnv({
   LOG_LEVEL: env.literal("trace", "debug", "info", "warn", "error").default("info"),
-  OPENAI_API_KEY: env.secret().requiredIn("production"),
-  ANTHROPIC_API_KEY: env.secret().requiredIn("production"),
 });

package/dist/templates/default/v1/agent/tests/integration/hello.route.test.ts

@@ -1,12 +1,20 @@
 import { afterAll, expect, test } from "bun:test";
-import { createTestApplication } from "@relkit/testing";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createTestAgentStateProvider,
+  createTestApplication,
+  createTestRealtimeProvider,
+} from "@relkit/testing";
 import config from "../../relkit.config.js";
 
-const model = {
-  resolveModel: (selector = "test:model") => ({ id: selector, model: {} }),
-};
+const providerRoot = await mkdtemp(join(tmpdir(), "relkit-agent-template-"));
 const testApp = await createTestApplication(config, {
-  providers: { model: { openai: model, anthropic: model } },
+  providers: {
+    "agent-state": { default: createTestAgentStateProvider(join(providerRoot, "agents")) },
+    realtime: { default: createTestRealtimeProvider(join(providerRoot, "realtime")) },
+  },
 });
 
 test("GET /hello", async () => {
@@ -15,4 +23,7 @@ test("GET /hello", async () => {
   expect(await response.json()).toEqual({ message: "Hello, Mustafa!" });
 });
 
-afterAll(() => testApp.close());
+afterAll(async () => {
+  await testApp.close();
+  await rm(providerRoot, { force: true, recursive: true });
+});

package/dist/templates/default/v1/agent/tests/unit/assistant.agent.test.ts

@@ -1,43 +1,21 @@
 import { expect, test } from "bun:test";
-import { createTestAgent, invokeFunction } from "@relkit/testing";
-import assistant from "@app/hello/agents/assistant.agent.js";
-import askAssistant from "@app/hello/functions/ask-assistant.function.js";
-import hello from "@app/hello/functions/hello.function.js";
+import { invokeAgent } from "@relkit/app/agents";
+import assistant, { uppercase } from "@app/hello/agents/assistant.agent.js";
 import lookup from "@app/hello/tools/lookup.tool.js";
 
-test("assistant uses a function-derived tool with an offline AI SDK model", async () => {
-  expect(assistant.model).toBe("openai:gpt-5-mini");
-  expect(assistant.tools.map((tool) => tool.ref.id)).toEqual(["hello.lookup"]);
+test("assistant runs native tools and todo middleware without a paid provider", async () => {
+  expect(assistant.tools).toEqual([expect.objectContaining({ ref: lookup.ref }), uppercase]);
+  expect(assistant.middleware.map((middleware) => middleware.name)).toEqual(["todoListMiddleware"]);
+  expect(assistant.client?.state).toEqual(["todos"]);
   expect(assistant.limits).toEqual({ maxSteps: 4, maxToolCalls: 4, timeoutMs: 10_000 });
 
-  const agent = createTestAgent({
-    agent: assistant,
-    tools: [lookup],
-    engine: {
-      invoke: (request) =>
-        invokeFunction(hello, request.input as Parameters<typeof hello.invoke>[0]),
-    },
-    model: { provider: "openai", modelId: "gpt-5-mini" },
-    // Script the model's choices while running the real greeting function.
-    script: [
-      {
-        type: "tool-call",
-        callId: "call-1",
-        toolId: "hello.lookup",
-        input: { name: "Ada" },
-      },
-      { type: "final", output: { answer: "Hello, Ada!" } },
-    ],
-  });
-
   await expect(
-    invokeFunction(
-      askAssistant,
-      { question: "greet Ada" },
-      {
-        clients: { agents: { "hello.assistant": agent.invoke } },
-      },
-    ),
-  ).resolves.toEqual({ answer: "Hello, Ada!" });
-  expect(agent.model.calls).toHaveLength(2);
+    invokeAgent({
+      agent: assistant,
+      input: { message: "Greet Ada" },
+      threadId: "test:assistant",
+      tools: [lookup],
+      engine: { invoke: async () => ({ message: "Hello, Ada!" }) },
+    }),
+  ).resolves.toEqual({ answer: "Hello from the offline LangChain model." });
 });

package/dist/templates/default/v1/agent/tests/unit/review.agent.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { GraphInterruptedError, invokeAgent } from "@relkit/app/agents";
+import review from "@app/hello/agents/review.agent.js";
+
+const runtime = {
+  agent: review,
+  tools: {},
+  engine: { invoke: async () => Promise.reject(new Error("Unexpected function invocation")) },
+};
+
+test("review graph interrupts and resumes on an explicit thread", async () => {
+  const threadId = "test:review";
+  await expect(
+    invokeAgent({ ...runtime, input: { request: "Publish" }, threadId }),
+  ).rejects.toBeInstanceOf(GraphInterruptedError);
+  await expect(invokeAgent({ ...runtime, input: true, threadId, resume: true })).resolves.toEqual({
+    result: "Publish approved",
+  });
+});

package/dist/templates/default/v1/api/package.json

@@ -15,12 +15,12 @@
     "graph": "relkit graph print"
   },
   "dependencies": {
-    "@relkit/app": "0.4.0"
+    "@relkit/app": "0.5.0"
   },
   "devDependencies": {
     "@types/bun": "1.3.10",
-    "@relkit/cli": "0.4.0",
-    "@relkit/testing": "0.4.0",
+    "@relkit/cli": "0.5.0",
+    "@relkit/testing": "0.5.0",
     "typescript": "5.9.3"
   }
 }

package/dist/templates/default/v1/fullstack/.env.example

@@ -0,0 +1 @@
+APP_ENV=development

package/dist/templates/default/v1/fullstack/README.md

@@ -0,0 +1,15 @@
+# my-app
+
+A Relkit backend and Next.js typed client. The example includes an offline
+native LangChain agent with typed todo/tool state, a LangGraph interrupt and
+resume flow, explicit application-owned thread IDs, and selectable SSE or
+WebSocket streaming. `bun run dev` serves the API on port 3000, the web app on
+port 3001, and the Inspector on port 3210.
+
+```sh
+bun install
+bun run dev
+bun run test
+bun run typecheck
+bun run build
+```

package/dist/templates/default/v1/fullstack/gitignore

@@ -0,0 +1,4 @@
+node_modules
+.next
+.relkit
+.env

package/dist/templates/default/v1/fullstack/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "my-app",
+  "private": true,
+  "type": "module",
+  "packageManager": "bun@1.3.10",
+  "scripts": {
+    "dev": "bun run check && bun run --parallel dev:api dev:web",
+    "dev:api": "RELKIT_ALLOWED_ORIGINS=http://127.0.0.1:3001 relkit dev",
+    "dev:web": "next dev web --hostname 127.0.0.1 --port 3001",
+    "check": "relkit check",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p web/tsconfig.json",
+    "test": "bun test",
+    "build": "relkit build && next build web",
+    "start": "relkit start"
+  },
+  "dependencies": {
+    "@langchain/langgraph": "1.4.14",
+    "@relkit/app": "0.5.0",
+    "@relkit/client": "0.5.0",
+    "@relkit/local": "0.5.0",
+    "@tanstack/react-query": "5.102.3",
+    "langchain": "1.5.10",
+    "next": "16.3.3",
+    "react": "19.2.8",
+    "react-dom": "19.2.8"
+  },
+  "devDependencies": {
+    "@relkit/cli": "0.5.0",
+    "@relkit/testing": "0.5.0",
+    "@types/bun": "1.3.10",
+    "@types/react": "19.2.18",
+    "@types/react-dom": "19.2.7",
+    "typescript": "5.9.3"
+  }
+}

package/dist/templates/default/v1/fullstack/relkit.config.ts

@@ -0,0 +1,15 @@
+import { defineApp } from "@relkit/app/config";
+import { localAgentState, localRealtime } from "@relkit/local";
+import env from "@app/platform/env.js";
+// relkit:create:deployment-imports
+
+export default defineApp({
+  env,
+  realtime: localRealtime(),
+  "agent-state": localAgentState(),
+  defaults: { realtime: "default", "agent-state": "default" },
+  telemetry: { redaction: { mode: "development-redacted", maxBytes: 65_536 } },
+  server: { port: 3000, maxBodyBytes: 1_048_576 },
+  inspector: { port: 3210 },
+  // relkit:create:deployment
+});

package/dist/templates/default/v1/fullstack/src/hello/agents/assistant.agent.ts

@@ -0,0 +1,46 @@
+import { defineAgent } from "@relkit/app/agents";
+import { z } from "@relkit/app/schema";
+import { FakeToolCallingModel, todoListMiddleware, tool } from "langchain";
+import lookup from "@app/hello/tools/lookup.tool.js";
+
+const uppercase = tool(async ({ text }) => text.toUpperCase(), {
+  name: "uppercase",
+  description: "Uppercase text without leaving the process",
+  schema: z.object({ text: z.string() }),
+});
+
+export default defineAgent({
+  id: "hello.assistant",
+  input: z.object({ message: z.string().min(1) }),
+  output: z.object({ answer: z.string() }),
+  model: new FakeToolCallingModel({
+    toolCalls: [
+      [
+        {
+          name: "write_todos",
+          args: { todos: [{ content: "Answer the greeting", status: "completed" }] },
+          id: "todo-1",
+        },
+      ],
+      [
+        {
+          name: "relkit_output",
+          args: { value: { answer: "Hello from the offline LangChain model." } },
+          id: "output-1",
+        },
+      ],
+    ],
+  }),
+  instructions: "Answer greeting questions with the available tools.",
+  tools: [lookup, uppercase],
+  middleware: [todoListMiddleware()],
+  stateProfile: "default",
+  client: {
+    public: true,
+    state: ["todos"],
+    events: { notice: z.object({ message: z.string() }) },
+  },
+  chat: { input: "message", output: "answer" },
+  controls: ["stop"],
+  limits: { maxSteps: 4, maxToolCalls: 4, timeoutMs: 10_000 },
+});

package/dist/templates/default/v1/fullstack/src/hello/agents/review.agent.ts

@@ -0,0 +1,43 @@
+import { defineGraph, defineGraphNode } from "@relkit/app/agents";
+import { z } from "@relkit/app/schema";
+import { END, MemorySaver, START, StateSchema, interrupt } from "@langchain/langgraph";
+
+const state = new StateSchema({
+  request: z.string(),
+  approved: z.boolean().optional(),
+  result: z.string().optional(),
+});
+
+const review = defineGraphNode({
+  id: "review",
+  input: z.object({ request: z.string() }),
+  output: z.object({ approved: z.boolean() }),
+  resume: z.boolean(),
+  handler: ({ request }) => ({
+    approved: interrupt({ question: `Approve "${request}"?` }) as boolean,
+  }),
+});
+
+const finish = defineGraphNode({
+  id: "finish",
+  input: z.object({ request: z.string(), approved: z.boolean() }),
+  output: z.object({ result: z.string() }),
+  handler: ({ request, approved }) => ({
+    result: approved ? `${request} approved` : `${request} rejected`,
+  }),
+});
+
+export default defineGraph({
+  id: "hello.review",
+  state,
+  input: z.object({ request: z.string().min(1) }),
+  output: z.object({ result: z.string() }),
+  nodes: [review, finish],
+  edges: (graph) =>
+    graph.addEdge(START, "review").addEdge("review", "finish").addEdge("finish", END),
+  checkpointer: new MemorySaver(),
+  stateProfile: "default",
+  client: { public: true, state: ["approved", "result"] },
+  controls: ["stop"],
+  limits: { maxSteps: 4, maxToolCalls: 1, timeoutMs: 10_000 },
+});

package/dist/templates/default/v1/fullstack/src/hello/functions/hello.function.ts

@@ -0,0 +1,10 @@
+import { defineFunction } from "@relkit/app/functions";
+import { z } from "@relkit/app/schema";
+
+const hello = defineFunction({
+  input: z.object({ name: z.string().min(1).default("world") }),
+  output: z.object({ message: z.string() }),
+  handler: async ({ name }) => ({ message: `Hello, ${name}!` }),
+});
+
+export default hello;

package/dist/templates/default/v1/fullstack/src/hello/service.ts

@@ -0,0 +1,4 @@
+import { defineService } from "@relkit/app/services";
+import hello from "@app/hello/functions/hello.function.js";
+
+export default defineService({ functions: { hello } });

package/dist/templates/default/v1/fullstack/src/hello/tools/lookup.tool.ts

@@ -0,0 +1,9 @@
+import hello from "@app/hello/functions/hello.function.js";
+
+export default hello.asTool({
+  id: "hello.lookup",
+  description: "Read a greeting for a supplied name",
+  sideEffect: "read",
+  approval: "never",
+  timeoutMs: 2_000,
+});

package/dist/templates/default/v1/fullstack/src/platform/env.ts

@@ -0,0 +1,5 @@
+import { defineEnv, env } from "@relkit/app/config";
+
+export default defineEnv({
+  APP_ENV: env.literal("development", "test", "production").default("development"),
+});

package/dist/templates/default/v1/fullstack/src/routes/hello/route.ts

@@ -0,0 +1,4 @@
+import { defineRoute } from "@relkit/app/routes";
+import hello from "@app/hello/service.js";
+
+export const GET = defineRoute({ target: hello.hello, client: { operation: "query" } });

package/dist/templates/default/v1/fullstack/tests/integration/hello.route.test.ts

@@ -0,0 +1,29 @@
+import { afterAll, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createTestAgentStateProvider,
+  createTestApplication,
+  createTestRealtimeProvider,
+} from "@relkit/testing";
+import config from "../../relkit.config.js";
+
+const providerRoot = await mkdtemp(join(tmpdir(), "relkit-fullstack-template-"));
+const testApp = await createTestApplication(config, {
+  providers: {
+    "agent-state": { default: createTestAgentStateProvider(join(providerRoot, "agents")) },
+    realtime: { default: createTestRealtimeProvider(join(providerRoot, "realtime")) },
+  },
+});
+
+test("GET /hello", async () => {
+  const response = await testApp.http.request("/hello?name=Mustafa");
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ message: "Hello, Mustafa!" });
+});
+
+afterAll(async () => {
+  await testApp.close();
+  await rm(providerRoot, { force: true, recursive: true });
+});

package/dist/templates/default/v1/fullstack/tests/unit/assistant.agent.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "bun:test";
+import { invokeAgent } from "@relkit/app/agents";
+import assistant from "@app/hello/agents/assistant.agent.js";
+import lookup from "@app/hello/tools/lookup.tool.js";
+
+test("assistant runs with native todo middleware and the offline model", async () => {
+  expect(assistant.client?.state).toEqual(["todos"]);
+  expect(assistant.middleware.map((middleware) => middleware.name)).toEqual(["todoListMiddleware"]);
+  await expect(
+    invokeAgent({
+      agent: assistant,
+      input: { message: "Greet Ada" },
+      threadId: "test:assistant",
+      tools: [lookup],
+      engine: { invoke: async () => ({ message: "Hello, Ada!" }) },
+    }),
+  ).resolves.toEqual({ answer: "Hello from the offline LangChain model." });
+});

package/dist/templates/default/v1/fullstack/tests/unit/hello.function.test.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "bun:test";
+import { invokeFunction } from "@relkit/testing";
+import hello from "@app/hello/functions/hello.function.js";
+
+test("greets by name", async () => {
+  await expect(invokeFunction(hello, { name: "Ada" })).resolves.toEqual({ message: "Hello, Ada!" });
+});

package/dist/templates/default/v1/fullstack/tests/unit/review.agent.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { GraphInterruptedError, invokeAgent } from "@relkit/app/agents";
+import review from "@app/hello/agents/review.agent.js";
+
+const runtime = {
+  agent: review,
+  tools: {},
+  engine: { invoke: async () => Promise.reject(new Error("Unexpected function invocation")) },
+};
+
+test("review graph interrupts and resumes on an explicit thread", async () => {
+  const threadId = "test:review";
+  await expect(
+    invokeAgent({ ...runtime, input: { request: "Publish" }, threadId }),
+  ).rejects.toBeInstanceOf(GraphInterruptedError);
+  await expect(invokeAgent({ ...runtime, input: true, threadId, resume: true })).resolves.toEqual({
+    result: "Publish approved",
+  });
+});

package/dist/templates/default/v1/fullstack/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "baseUrl": ".",
+    "paths": { "@app/*": ["src/*"] },
+    "lib": ["ES2022"],
+    "types": ["bun"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts", "relkit.config.ts"],
+  "exclude": ["node_modules", ".relkit", "web"]
+}

package/dist/templates/default/v1/fullstack/web/app/agent-config.ts

@@ -0,0 +1,7 @@
+export const agentThreadIds = {
+  assistant: "demo:assistant",
+  review: "demo:review",
+} as const;
+
+export const agentTransports = ["sse", "websocket"] as const;
+export type AgentTransport = (typeof agentTransports)[number];

package/dist/templates/default/v1/fullstack/web/app/layout.tsx

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import { Providers } from "./providers";
+
+export default function Layout({ children }: { readonly children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        <Providers>{children}</Providers>
+      </body>
+    </html>
+  );
+}

package/dist/templates/default/v1/fullstack/web/app/page.tsx

@@ -0,0 +1,85 @@
+"use client";
+
+import { useAgent, useRoute } from "@relkit/client/react";
+import { agentThreadIds } from "./agent-config";
+
+function interruptQuestion(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    "question" in value &&
+    typeof value.question === "string"
+  ) {
+    return value.question;
+  }
+  return "Approve?";
+}
+
+export default function Page() {
+  const greeting = useRoute("route.get.hello", { input: { name: "Relkit" } });
+  const assistant = useAgent("hello.assistant");
+  const review = useAgent("hello.review");
+
+  return (
+    <main>
+      <h1>{greeting.data?.message ?? "Loading…"}</h1>
+      <section>
+        <h2>Typed agent</h2>
+        <button
+          onClick={() => void assistant.send("Greet Ada", { threadId: agentThreadIds.assistant })}
+        >
+          Run assistant
+        </button>
+        <button onClick={() => void assistant.observe({ threadId: agentThreadIds.assistant })}>
+          Reconnect
+        </button>
+        <button onClick={() => void assistant.stop({ threadId: agentThreadIds.assistant })}>
+          Stop
+        </button>
+        <p>{assistant.output?.answer ?? assistant.status}</p>
+        {assistant.events.map((event) =>
+          event.kind === "custom" ? <p key={event.eventId}>{event.data.message}</p> : null,
+        )}
+        <ul>
+          {assistant.values?.todos.map((todo) => (
+            <li key={todo.content}>{`${todo.status}: ${todo.content}`}</li>
+          ))}
+          {assistant.toolCalls.map((call) => (
+            <li key={call.toolCallId}>{`${call.toolId}: ${call.state}`}</li>
+          ))}
+        </ul>
+      </section>
+      <section>
+        <h2>Interrupt and resume</h2>
+        <button
+          onClick={() =>
+            void review.run({ request: "Publish" }, { threadId: agentThreadIds.review })
+          }
+        >
+          Start review
+        </button>
+        {review.waiting ? (
+          <fieldset>
+            <legend>{interruptQuestion(review.waiting.requests[0]?.value)}</legend>
+            <button
+              onClick={() =>
+                void review.run(true, { threadId: agentThreadIds.review, resume: true })
+              }
+            >
+              Approve
+            </button>
+            <button
+              onClick={() =>
+                void review.run(false, { threadId: agentThreadIds.review, resume: true })
+              }
+            >
+              Reject
+            </button>
+          </fieldset>
+        ) : null}
+        <p>{review.output?.result ?? review.status}</p>
+      </section>
+    </main>
+  );
+}