@stigmer/server 3.40.0 → 3.41.0

package/src/temporal/__tests__/sdk-logger.e2e.test.ts

@@ -0,0 +1,150 @@
+/**
+ * The Temporal SDK's lines reach the server logger's sink through the real
+ * Runtime (#1037), end to end: the process bridge installed over the real
+ * `Runtime.install`, a real TemporalManager building its worker through
+ * createWorker, and a local Temporal server. It pins:
+ *
+ *   - `Activity failed` arrives at warn with the activity's identity
+ *     (activityType, workflowId, workflowType, attempt) and the error as
+ *     its message, and without the activity's taskToken;
+ *   - a workflow body's `log.warn` arrives with every field it passed,
+ *     the nested one included, tagged `sdkComponent: workflow`;
+ *   - the SDK's debug `Creating worker` line arrives without the worker
+ *     options it carries (the payload codecs and their keys ride there).
+ *
+ * Its own file, so its own vitest process: the Runtime is a process
+ * singleton, and this file installs the real one. The bridge attaches
+ * BEFORE TestWorkflowEnvironment.createLocal, which creates the Runtime
+ * itself; the manager's own attach then retargets the same bridge. Like
+ * the invoke-workflow suites, every test is VISIBLY skipped when the
+ * local Temporal server cannot start (no `temporal` CLI), never a vacuous
+ * green.
+ */
+import { ApplicationFailure } from "@temporalio/common";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { createLogger, type LogEntry } from "../../boot/logger.js";
+import { TemporalManager } from "../manager.js";
+import { processSdkLogBridge } from "../sdk-logger.js";
+import {
+  SDK_LOG_PROBE_ACTIVITY,
+  SDK_LOG_PROBE_WARNING,
+  SDK_LOG_PROBE_WORKFLOW,
+} from "./sdk-log-workflows.js";
+
+const TASK_QUEUE = "sdk-logger-e2e";
+const WORKFLOWS_PATH = new URL("./sdk-log-workflows.ts", import.meta.url)
+  .pathname;
+
+type TestWorkflowEnvironment =
+  import("@temporalio/testing").TestWorkflowEnvironment;
+
+const entries: LogEntry[] = [];
+const logger = createLogger({
+  level: "debug",
+  pretty: false,
+  write: () => {},
+  sink: (entry) => entries.push(entry),
+});
+
+let env: TestWorkflowEnvironment | null = null;
+let manager: TemporalManager | null = null;
+let envReady = false;
+
+function findEntry(
+  level: LogEntry["level"],
+  message: string,
+): LogEntry | undefined {
+  return entries.find(
+    (entry) => entry.level === level && entry.message === message,
+  );
+}
+
+describe("Temporal SDK lines through the server logger (real Runtime)", () => {
+  beforeAll(async () => {
+    processSdkLogBridge.attach(logger);
+    try {
+      const { TestWorkflowEnvironment: TWE } =
+        await import("@temporalio/testing");
+      env = await TWE.createLocal();
+    } catch (error) {
+      console.warn(
+        `Temporal test server unavailable (tests will be skipped): ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return;
+    }
+
+    manager = new TemporalManager({
+      hostPort: env.address,
+      namespace: env.namespace ?? "default",
+      connection: {},
+      logger,
+      payloadCodecs: [],
+      workerFactories: [
+        (deps) =>
+          deps.createWorker({
+            taskQueue: TASK_QUEUE,
+            activities: {
+              [SDK_LOG_PROBE_ACTIVITY]: async () => {
+                throw ApplicationFailure.create({
+                  message: "probe activity exploded",
+                  type: "SdkLogProbeFailure",
+                });
+              },
+            },
+            workflows: { workflowsPath: WORKFLOWS_PATH },
+          }),
+      ],
+    });
+    envReady =
+      (await manager.initialConnect()) &&
+      (await manager.startWorkers().then(() => true));
+  }, 120_000);
+
+  afterAll(async () => {
+    await manager?.close();
+    if (env) await env.teardown();
+  }, 30_000);
+
+  it("carries Activity failed, a workflow warning and the worker's creation line", async (testCtx) => {
+    if (!envReady || env === null) return testCtx.skip();
+
+    const workflowId = `sdk-logger-e2e-${Date.now()}`;
+    await expect(
+      env.client.workflow.execute(SDK_LOG_PROBE_WORKFLOW, {
+        taskQueue: TASK_QUEUE,
+        workflowId,
+      }),
+    ).rejects.toThrow();
+
+    const failed = findEntry("warn", "Activity failed");
+    expect(failed, "the activity failure must reach the sink").toBeDefined();
+    expect(failed?.fields).toMatchObject({
+      sdkComponent: "worker",
+      activityType: SDK_LOG_PROBE_ACTIVITY,
+      workflowId,
+      workflowType: SDK_LOG_PROBE_WORKFLOW,
+      attempt: 1,
+      error: "probe activity exploded",
+    });
+    expect(failed?.fields).not.toHaveProperty("taskToken");
+
+    const warning = findEntry("warn", SDK_LOG_PROBE_WARNING);
+    expect(warning, "the workflow's warning must reach the sink").toBeDefined();
+    expect(warning?.fields).toMatchObject({
+      sdkComponent: "workflow",
+      workflowId,
+      workflowType: SDK_LOG_PROBE_WORKFLOW,
+      probeCount: 3,
+      outcomes: { reaped: 2, kept: 1 },
+    });
+
+    const creating = findEntry("debug", "Creating worker");
+    expect(creating, "the SDK's debug lines must reach the sink").toBeDefined();
+    expect(creating?.fields).toMatchObject({
+      sdkComponent: "worker",
+      taskQueue: TASK_QUEUE,
+    });
+    expect(creating?.fields).not.toHaveProperty("options");
+  }, 60_000);
+});

package/src/temporal/__tests__/sdk-logger.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Pins the Temporal SDK log adapter and its install bridge (#1037):
+ *
+ *   - the level mapping (TRACE folds into debug) and the verbatim message;
+ *   - the meta table on both sides of the component split: on every line
+ *     a `taskToken`, a symbol key, null and undefined are dropped, an
+ *     Error becomes its message and a bigint its decimal string; a nested
+ *     value passes on a line our code wrote (`workflow`, `activity`,
+ *     `nexus`) and is dropped from the SDK's own lines, an unknown
+ *     component counting as the SDK's, and the drop holds for the written
+ *     line and the sink entry alike;
+ *   - the bridge installs once and retargets after, catches exactly the
+ *     SDK's IllegalStateError (warned once, never retried) and lets any
+ *     other install failure through.
+ *
+ * Every bridge here is built over a fake install, so nothing creates the
+ * native Runtime; the real path is sdk-logger.e2e.test.ts.
+ */
+import { IllegalStateError, SdkComponent } from "@temporalio/common";
+import type { RuntimeOptions } from "@temporalio/worker";
+import { describe, expect, it } from "vitest";
+
+import { createLogger, type LogEntry, type Logger } from "../../boot/logger.js";
+import {
+  createSdkLogBridge,
+  createSdkLoggerAdapter,
+  toLogFields,
+} from "../sdk-logger.js";
+
+function capturingLogger(level = "debug"): {
+  logger: Logger;
+  lines: string[];
+  entries: LogEntry[];
+} {
+  const lines: string[] = [];
+  const entries: LogEntry[] = [];
+  const logger = createLogger({
+    level,
+    pretty: false,
+    write: (line) => lines.push(line),
+    sink: (entry) => entries.push(entry),
+  });
+  return { logger, lines, entries };
+}
+
+describe("createSdkLoggerAdapter", () => {
+  it("maps each SDK level onto the server's and keeps the message verbatim", () => {
+    const { logger, entries } = capturingLogger();
+    const adapter = createSdkLoggerAdapter(() => logger);
+
+    adapter.trace("t");
+    adapter.debug("d");
+    adapter.info("i");
+    adapter.warn("Activity failed");
+    adapter.error("e");
+    adapter.log("WARN", "via log");
+
+    expect(entries.map((entry) => [entry.level, entry.message])).toEqual([
+      ["debug", "t"],
+      ["debug", "d"],
+      ["info", "i"],
+      ["warn", "Activity failed"],
+      ["error", "e"],
+      ["warn", "via log"],
+    ]);
+  });
+
+  it("writes through whichever logger the target returns at call time", () => {
+    const first = capturingLogger();
+    const second = capturingLogger();
+    let current = first.logger;
+    const adapter = createSdkLoggerAdapter(() => current);
+
+    adapter.info("one");
+    current = second.logger;
+    adapter.info("two");
+
+    expect(first.entries.map((entry) => entry.message)).toEqual(["one"]);
+    expect(second.entries.map((entry) => entry.message)).toEqual(["two"]);
+  });
+
+  it("keeps the SDK's own nested values out of the written line and the sink", () => {
+    const { logger, lines, entries } = capturingLogger();
+    const adapter = createSdkLoggerAdapter(() => logger);
+
+    adapter.debug("Creating worker", {
+      sdkComponent: SdkComponent.worker,
+      taskQueue: "q",
+      options: { dataConverter: { key: Buffer.from("secret-key-bytes") } },
+    });
+
+    expect(entries[0]?.fields).toEqual({
+      sdkComponent: "worker",
+      taskQueue: "q",
+    });
+    expect(lines[0]).not.toContain("options");
+    expect(lines[0]).not.toContain("Buffer");
+  });
+});
+
+describe("toLogFields", () => {
+  const shared = {
+    [Symbol("LogTimestamp")]: 1n,
+    taskToken: "dGFzay10b2tlbg==",
+    attempt: 1,
+    isLocal: false,
+    activityType: "FailingActivity",
+    runId: null,
+    updateId: undefined,
+    error: new Error("activity exploded"),
+    durationMs: 12n,
+  };
+
+  it("applies the every-line rules on the SDK's own lines", () => {
+    expect(
+      toLogFields({ ...shared, sdkComponent: SdkComponent.worker }),
+    ).toEqual({
+      sdkComponent: "worker",
+      attempt: 1,
+      isLocal: false,
+      activityType: "FailingActivity",
+      error: "activity exploded",
+      durationMs: "12",
+    });
+  });
+
+  it("applies the same every-line rules on our code's lines", () => {
+    expect(
+      toLogFields({ ...shared, sdkComponent: SdkComponent.workflow }),
+    ).toEqual({
+      sdkComponent: "workflow",
+      attempt: 1,
+      isLocal: false,
+      activityType: "FailingActivity",
+      error: "activity exploded",
+      durationMs: "12",
+    });
+  });
+
+  it("passes nested values on the components our code writes", () => {
+    const outcomes = { reaped: 2, kept: 1 };
+    for (const component of [
+      SdkComponent.workflow,
+      SdkComponent.activity,
+      SdkComponent.nexus,
+    ]) {
+      expect(toLogFields({ sdkComponent: component, outcomes })).toEqual({
+        sdkComponent: component,
+        outcomes,
+      });
+    }
+  });
+
+  it("drops nested values from the SDK's components, unknown and absent ones included", () => {
+    const nested = {
+      options: { taskQueue: "q" },
+      list: ["a"],
+      codecs: new Map([["k", Buffer.from("x")]]),
+      key: Buffer.from("x"),
+    };
+    for (const component of [
+      SdkComponent.worker,
+      SdkComponent.core,
+      "a-component-the-sdk-adds-later",
+    ]) {
+      expect(toLogFields({ sdkComponent: component, ...nested })).toEqual({
+        sdkComponent: component,
+      });
+    }
+    expect(toLogFields(nested)).toEqual({});
+  });
+
+  it("returns no fields for absent meta", () => {
+    expect(toLogFields(undefined)).toEqual({});
+  });
+});
+
+describe("createSdkLogBridge", () => {
+  function recordingInstall(): {
+    install: (options: RuntimeOptions) => void;
+    calls: RuntimeOptions[];
+  } {
+    const calls: RuntimeOptions[] = [];
+    return { install: (options) => calls.push(options), calls };
+  }
+
+  it("installs the adapter on the first attach and only retargets after", () => {
+    const { install, calls } = recordingInstall();
+    const bridge = createSdkLogBridge(install);
+    const first = capturingLogger();
+    const second = capturingLogger();
+
+    bridge.attach(first.logger);
+    calls[0]?.logger?.info("to first");
+    bridge.attach(second.logger);
+    calls[0]?.logger?.info("to second");
+
+    expect(calls).toHaveLength(1);
+    expect(Object.keys(calls[0] ?? {})).toEqual(["logger"]);
+    expect(first.entries.map((entry) => entry.message)).toEqual(["to first"]);
+    expect(second.entries.map((entry) => entry.message)).toEqual(["to second"]);
+  });
+
+  it("warns once and keeps the SDK default when the Runtime already exists", () => {
+    let installs = 0;
+    const bridge = createSdkLogBridge(() => {
+      installs++;
+      throw new IllegalStateError(
+        "Runtime singleton has already been instantiated. Did you start a Worker before calling `install`?",
+      );
+    });
+    const { logger, entries } = capturingLogger();
+
+    bridge.attach(logger);
+    bridge.attach(logger);
+
+    expect(installs).toBe(1);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({
+      level: "warn",
+      message:
+        "Temporal SDK logger not installed: the Temporal runtime already existed before the worker manager's first connect",
+    });
+    expect(entries[0]?.fields?.["error"]).toContain(
+      "already been instantiated",
+    );
+  });
+
+  it("lets any other install failure through", () => {
+    const bridge = createSdkLogBridge(() => {
+      throw new TypeError("Invalid logging filter");
+    });
+
+    expect(() => bridge.attach(capturingLogger().logger)).toThrow(
+      "Invalid logging filter",
+    );
+  });
+});

package/src/temporal/manager.ts

@@ -43,6 +43,11 @@
  * capability (the TS SDK's Worker.create takes its own dataConverter; Go
  * workers inherit the client's — same coverage, two installation sites,
  * one source array, one construction path).
+ *
+ * One choke point for the SDK's own log lines: every native connect is
+ * preceded by attaching this manager's logger to the process's SDK log
+ * bridge (sdk-logger.ts), so the Runtime logger every worker inherits is
+ * the server logger, with its threshold and its sink (#1037).
  */
 import { Client, Connection } from "@temporalio/client";
 import type { PayloadCodec } from "@temporalio/common";
@@ -54,6 +59,7 @@ import {
 } from "@temporalio/worker";
 
 import type { Logger } from "../boot/logger.js";
+import { processSdkLogBridge } from "./sdk-logger.js";
 
 /**
  * Initial connect: 3 attempts with exponential backoff (1s, 2s between
@@ -504,6 +510,9 @@ export class TemporalManager {
   }
 
   private async createAndRunWorkers(): Promise<void> {
+    // Before the connect: the first native connect creates the SDK's
+    // Runtime, after which its logger can no longer be installed.
+    processSdkLogBridge.attach(this.logger);
     const nativeConnection = await NativeConnection.connect({
       address: this.hostPort,
       ...this.connectionSecurity,

package/src/temporal/mcpserver/engine-client.ts

@@ -35,6 +35,7 @@ import type {
   ConnectRun,
   ConnectRunFailure,
   ConnectRunOutcome,
+  ConnectTaskQueue,
   ConnectWorkflowInput,
   ConnectWorkflowOutput,
   McpServerConnectEngine,
@@ -58,13 +59,17 @@ export class TemporalMcpServerConnectEngine implements McpServerConnectEngine {
     mcpServerId: string,
     input: ConnectWorkflowInput,
     runTimeoutMs: number,
+    taskQueue: ConnectTaskQueue,
   ): Promise<ConnectRun> {
     const { client, config, logger } = this.deps;
     const workflowId = connectWorkflowIdFor(mcpServerId);
     // MCP connect is not session-scoped (it discovers tools at the server
-    // level), so it always routes to the default runner queue regardless
-    // of routing mode (connect.go:642-645).
-    const runnerQueue = config.runnerQueue;
+    // level), so it never takes the agent-execution routing mode: it runs
+    // on the shared runner queue (connect.go:642-645) or, with a sandbox
+    // provisioner composed, on the queue its own connect sandbox serves —
+    // the domain decides which (engine.ts ConnectTaskQueue).
+    const runnerQueue =
+      taskQueue.kind === "runner" ? config.runnerQueue : taskQueue.name;
 
     let handle: WorkflowHandle;
     let attached = false;

package/src/temporal/mcpserver/names.ts

@@ -1,7 +1,9 @@
 /**
  * McpServer connect workflow wire identifiers — cross-edition constants
- * copied character-for-character from Go (connect.go:31-32, 584-586).
- * Renaming one is a wire protocol break (guidelines §2).
+ * copied character-for-character from Go (connect.go:31-32, 584-586), plus
+ * the connect sandbox's task queue (stigmer/stigmer#1474), which a
+ * sandboxed runner polls. Renaming one is a wire protocol break
+ * (guidelines §2).
  */
 
 /** The runner's connect workflow type (Go connectWorkflowName). */
@@ -21,3 +23,15 @@ export const CONNECT_WORKFLOW_NAME = "stigmer/mcp-server/connect";
 export function connectWorkflowIdFor(mcpServerId: string): string {
   return `${CONNECT_WORKFLOW_NAME}/${mcpServerId}`;
 }
+
+/**
+ * The task queue one connect sandbox serves: its runner polls exactly this
+ * queue (STIGMER_TASK_QUEUE) and the connect workflow is started on it. The
+ * colon form of every per-queue name (`session:`, `wfexec:`, `sandbox:`);
+ * the id is the connect's synthetic execution id
+ * (domain/mcpserver/connect-execution-id.ts), unique per attempt, so two
+ * connects of one server never share a sandbox.
+ */
+export function connectTaskQueueFor(connectExecutionId: string): string {
+  return `mcpconnect:${connectExecutionId}`;
+}

package/src/temporal/sdk-logger.ts

@@ -0,0 +1,173 @@
+/**
+ * The Temporal SDK's log lines, routed through the server logger (#1037).
+ *
+ * The SDK logs through its process-wide Runtime logger: `Activity failed`
+ * with the activity's identity and error, worker lifecycle lines, and every
+ * `log.*` a workflow body calls (the workflow sink resolves to the same
+ * logger). Left at its default, that logger writes its own format to
+ * stderr, outside LOG_LEVEL and outside the sink seam, so a deployable that
+ * exports the server's lines (boot/logger.ts's `sink`) never sees the
+ * warnings an operator most needs. One `Runtime.install({ logger })` before
+ * the first native connection routes them all through the server logger,
+ * with the same threshold, shape and export as every other line.
+ *
+ * Meta becomes fields by one table, keyed on who wrote the line. The SDK
+ * tags each line with `sdkComponent`; `workflow`, `activity` and `nexus`
+ * are the context loggers user code calls, and the SDK "never publishes
+ * messages with" them (@temporalio/common's SdkComponent). Those lines are
+ * ours and get the server logger's own contract: values pass as the call
+ * site wrote them, and redaction is the call site's. Every other line is
+ * the SDK's own, and keeps only strings, numbers and booleans, because
+ * its nested values are not ours to vouch for: at debug the SDK logs
+ * `Creating worker` with the whole worker options, which hold the payload
+ * codecs and their decryption keys. An unknown or absent component is
+ * treated as the SDK's, since the SDK says its component list may change.
+ * On every line: symbol keys are dropped (the workflow sink's call-time
+ * stamp rides one), `taskToken` is dropped (it can complete the activity
+ * from outside, and has no business in a log store), null and undefined
+ * are dropped, an Error becomes its message as every server call site logs
+ * one, and a bigint becomes its decimal string because JSON cannot carry
+ * it. Keys keep the SDK's names (`activityType`, `workflowId`), which are
+ * Temporal's documented vocabulary.
+ *
+ * Two consequences, accepted. A workflow line is stamped when its
+ * activation's sinks flush, milliseconds after the `log.*` call, because
+ * the server Logger takes no instant. And the table runs before the
+ * threshold drops a line, because the Logger exposes no level check; it
+ * walks a handful of keys, and drops the one large SDK object unwalked.
+ *
+ * Native (Rust core) lines stay on the console, as the SDK defaults:
+ * forwarding them makes the SDK buffer every runtime-logger line for
+ * 100 ms (RuntimeOptions' telemetryOptions.logging), which would delay and
+ * restamp `Activity failed` itself.
+ *
+ * The Runtime is a process singleton, so the install is a bridge with one
+ * process instance: the first attach installs an adapter that reads the
+ * bridge's current target, and every later attach (a reconnect, a second
+ * composition in one test process) only retargets it. A Runtime created
+ * before the first attach (a test environment, or an embedder that touched
+ * the SDK first) keeps the SDK default; the attach says so once and never
+ * fails the boot over it. TemporalManager attaches before every native
+ * connect, so every worker it builds, OSS and extension alike, is covered.
+ * A composition that prebuilds a bundle with `bundleWorkflowCode` passes
+ * that call its own logger: the bundler never reads the Runtime.
+ */
+import {
+  IllegalStateError,
+  SdkComponent,
+  type LogLevel as SdkLogLevel,
+  type LogMetadata,
+  type Logger as SdkLogger,
+} from "@temporalio/common";
+import { Runtime, type RuntimeOptions } from "@temporalio/worker";
+
+import type { LogFields, Logger, LogLevel } from "../boot/logger.js";
+
+/** The components whose lines come from our own code (module header). */
+const CALLER_COMPONENTS: ReadonlySet<string> = new Set([
+  SdkComponent.workflow,
+  SdkComponent.activity,
+  SdkComponent.nexus,
+]);
+
+/** Dropped on every line: it completes the activity from outside. */
+const TASK_TOKEN_KEY = "taskToken";
+
+const LEVELS: Record<SdkLogLevel, LogLevel> = {
+  TRACE: "debug",
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error",
+};
+
+/** The meta table (module header), exported for its own unit arms. */
+export function toLogFields(meta: LogMetadata | undefined): LogFields {
+  const fields: LogFields = {};
+  if (meta === undefined) {
+    return fields;
+  }
+  const fromCaller = CALLER_COMPONENTS.has(String(meta["sdkComponent"]));
+  for (const [key, value] of Object.entries(meta)) {
+    if (key === TASK_TOKEN_KEY || value === null || value === undefined) {
+      continue;
+    }
+    if (value instanceof Error) {
+      fields[key] = value.message;
+    } else if (typeof value === "bigint") {
+      fields[key] = value.toString();
+    } else if (
+      fromCaller ||
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean"
+    ) {
+      fields[key] = value;
+    }
+  }
+  return fields;
+}
+
+/** The SDK's Logger over whichever server logger `target` returns now. */
+export function createSdkLoggerAdapter(target: () => Logger): SdkLogger {
+  const log = (level: SdkLogLevel, message: string, meta?: LogMetadata) => {
+    target()[LEVELS[level]](message, toLogFields(meta));
+  };
+  return {
+    log,
+    trace: (message, meta) => log("TRACE", message, meta),
+    debug: (message, meta) => log("DEBUG", message, meta),
+    info: (message, meta) => log("INFO", message, meta),
+    warn: (message, meta) => log("WARN", message, meta),
+    error: (message, meta) => log("ERROR", message, meta),
+  };
+}
+
+/** `Runtime.install`'s shape, the bridge's test seam. */
+export type RuntimeInstall = (options: RuntimeOptions) => unknown;
+
+export interface SdkLogBridge {
+  /**
+   * Routes the SDK's lines to `logger`: installs the Runtime logger on the
+   * first call, retargets it on every later one.
+   */
+  attach(logger: Logger): void;
+}
+
+export function createSdkLogBridge(install: RuntimeInstall): SdkLogBridge {
+  let state: "pending" | "installed" | "preempted" = "pending";
+  let target: Logger | undefined;
+  const adapter = createSdkLoggerAdapter(() => {
+    if (target === undefined) {
+      throw new Error("Temporal SDK log bridge used before attach");
+    }
+    return target;
+  });
+
+  return {
+    attach(logger) {
+      target = logger;
+      if (state !== "pending") {
+        return;
+      }
+      try {
+        install({ logger: adapter });
+        state = "installed";
+      } catch (error) {
+        if (!(error instanceof IllegalStateError)) {
+          throw error;
+        }
+        state = "preempted";
+        logger.warn(
+          "Temporal SDK logger not installed: the Temporal runtime already existed before the worker manager's first connect",
+          { error: error.message },
+        );
+      }
+    },
+  };
+}
+
+/** The process's one bridge, over the SDK's one Runtime. */
+export const processSdkLogBridge: SdkLogBridge = createSdkLogBridge((options) =>
+  Runtime.install(options),
+);