@convilyn/sdk-author 0.7.0

package/dist/chunk-ZNZXT5ZP.js

@@ -0,0 +1,1311 @@
+import { randomBytes, createHmac, timingSafeEqual } from 'crypto';
+import { writeFile, readFile } from 'fs/promises';
+import { createServer } from 'http';
+
+// src/version.ts
+var VERSION = "0.7.0";
+var MANIFEST_SDK_VERSION = "1.0.0";
+
+// src/errors.ts
+var ConvilynAuthorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConvilynAuthorError";
+  }
+};
+var InvalidSignatureError = class extends ConvilynAuthorError {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "InvalidSignatureError";
+    this.reason = reason;
+  }
+};
+var ConvilynStartupError = class extends ConvilynAuthorError {
+  constructor(message) {
+    super(message);
+    this.name = "ConvilynStartupError";
+  }
+};
+var ConvilynApiError = class extends ConvilynAuthorError {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.name = "ConvilynApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var ConfirmationInvalidError = class extends ConvilynAuthorError {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "ConfirmationInvalidError";
+    this.reason = reason;
+  }
+};
+var SIGNATURE_HEADER = "x-convilyn-signature";
+var TIMESTAMP_HEADER = "x-convilyn-timestamp";
+var SERVER_ID_HEADER = "x-convilyn-server-id";
+var DEFAULT_HMAC_TOLERANCE_SECONDS = 300;
+function expectedSignature(secret, timestamp, body) {
+  return createHmac("sha256", secret).update(timestamp).update(".").update(body).digest("hex");
+}
+function signRequest(secret, body, unixSeconds) {
+  const timestamp = String(Math.trunc(unixSeconds));
+  return { signature: expectedSignature(secret, timestamp, body), timestamp };
+}
+function constantTimeEqual(a, b) {
+  const aBuf = Buffer.from(a);
+  const bBuf = Buffer.from(b);
+  if (aBuf.length !== bBuf.length) {
+    return false;
+  }
+  return timingSafeEqual(aBuf, bBuf);
+}
+function verifySignature(secret, body, headers, options = {}) {
+  const tolerance = options.toleranceSeconds != null && options.toleranceSeconds > 0 ? options.toleranceSeconds : DEFAULT_HMAC_TOLERANCE_SECONDS;
+  const now = options.now ?? (() => Math.floor(Date.now() / 1e3));
+  if (!secret) {
+    throw new InvalidSignatureError("missing_secret", "HMAC secret is not configured on the server");
+  }
+  const signature = headers[SIGNATURE_HEADER];
+  const timestamp = headers[TIMESTAMP_HEADER];
+  if (!signature || !timestamp) {
+    throw new InvalidSignatureError(
+      "missing_header",
+      "Missing X-Convilyn-Signature or X-Convilyn-Timestamp"
+    );
+  }
+  if (!/^[+-]?\d+$/.test(timestamp)) {
+    throw new InvalidSignatureError(
+      "invalid_timestamp",
+      "X-Convilyn-Timestamp must be an integer Unix-seconds value"
+    );
+  }
+  const tsValue = Number(timestamp);
+  if (Math.abs(now() - tsValue) > tolerance) {
+    throw new InvalidSignatureError(
+      "timestamp_out_of_range",
+      "Request timestamp outside acceptable tolerance window"
+    );
+  }
+  const expected = expectedSignature(secret, timestamp, body);
+  if (!constantTimeEqual(expected, signature)) {
+    throw new InvalidSignatureError(
+      "signature_mismatch",
+      "Signature did not match expected HMAC-SHA256 digest"
+    );
+  }
+}
+
+// src/types.ts
+var ToolResult = {
+  ok(data, summary) {
+    return summary !== void 0 ? { success: true, data, summary } : { success: true, data };
+  },
+  fail(code, message, details, summary) {
+    const error = details ? { code, message, details } : { code, message };
+    return summary !== void 0 ? { success: false, error, summary } : { success: false, error };
+  }
+};
+function allChecksPassed(report) {
+  return report.results.every((result) => result.passed);
+}
+function failedChecks(report) {
+  return report.results.filter((result) => !result.passed);
+}
+var DEFAULT_MANIFEST_PATH = "convilyn.manifest.json";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function serverToWire(server) {
+  const wire = {
+    name: server.name,
+    version: server.version,
+    description: server.description
+  };
+  if (server.mcpServerName != null && server.mcpServerName !== "") {
+    wire.mcp_server_name = server.mcpServerName;
+  }
+  return wire;
+}
+function toolToWire(tool) {
+  const wire = {
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema,
+    idempotent: tool.idempotent
+  };
+  if (tool.outputSchema != null) {
+    wire.output_schema = tool.outputSchema;
+  }
+  return wire;
+}
+function serverFromWire(wire) {
+  const server = {
+    name: String(wire.name ?? ""),
+    version: String(wire.version ?? ""),
+    description: String(wire.description ?? "")
+  };
+  if (typeof wire.mcp_server_name === "string") {
+    server.mcpServerName = wire.mcp_server_name;
+  }
+  return server;
+}
+function toolFromWire(wire) {
+  const tool = {
+    name: String(wire.name ?? ""),
+    description: String(wire.description ?? ""),
+    inputSchema: isRecord(wire.input_schema) ? wire.input_schema : {},
+    idempotent: Boolean(wire.idempotent)
+  };
+  if (isRecord(wire.output_schema)) {
+    tool.outputSchema = wire.output_schema;
+  }
+  return tool;
+}
+var ConvilynManifest = class _ConvilynManifest {
+  sdkVersion;
+  server;
+  tools;
+  capabilities;
+  constructor(server, options = {}) {
+    this.sdkVersion = options.sdkVersion ?? MANIFEST_SDK_VERSION;
+    this.server = server;
+    this.tools = options.tools ?? [];
+    this.capabilities = options.capabilities ?? [];
+  }
+  /** The platform wire object (snake_case; empty lists kept as `[]`). */
+  toWire() {
+    return {
+      sdk_version: this.sdkVersion,
+      server: serverToWire(this.server),
+      tools: this.tools.map(toolToWire),
+      capabilities: [...this.capabilities]
+    };
+  }
+  /** The manifest serialised as 2-space-indented JSON. */
+  toJson() {
+    return JSON.stringify(this.toWire(), null, 2);
+  }
+  /** Write the manifest to a JSON file (default `convilyn.manifest.json`). */
+  async save(path = DEFAULT_MANIFEST_PATH) {
+    await writeFile(path, this.toJson(), "utf8");
+    return path;
+  }
+  /** Parse a manifest from its wire object. */
+  static fromWire(wire) {
+    const server = serverFromWire(isRecord(wire.server) ? wire.server : {});
+    const tools = Array.isArray(wire.tools) ? wire.tools.filter(isRecord).map(toolFromWire) : [];
+    const capabilities = Array.isArray(wire.capabilities) ? wire.capabilities.filter((cap) => typeof cap === "string") : [];
+    const sdkVersion = typeof wire.sdk_version === "string" ? wire.sdk_version : MANIFEST_SDK_VERSION;
+    return new _ConvilynManifest(server, { tools, capabilities, sdkVersion });
+  }
+  /** Parse a manifest from a JSON string. */
+  static fromJson(data) {
+    const parsed = JSON.parse(data);
+    if (!isRecord(parsed)) {
+      throw new Error("manifest JSON must be an object");
+    }
+    return _ConvilynManifest.fromWire(parsed);
+  }
+  /** Read a manifest from a JSON file (default `convilyn.manifest.json`). */
+  static async load(path = DEFAULT_MANIFEST_PATH) {
+    const raw = await readFile(path, "utf8");
+    return _ConvilynManifest.fromJson(raw);
+  }
+};
+function generateRefId() {
+  return `td_${randomBytes(6).toString("hex")}`;
+}
+var InMemoryDataStore = class {
+  #store = /* @__PURE__ */ new Map();
+  async store(data) {
+    const refId = generateRefId();
+    this.#store.set(refId, data);
+    return refId;
+  }
+  async get(refId) {
+    return this.#store.get(refId) ?? null;
+  }
+  /** Number of stored entries. */
+  get size() {
+    return this.#store.size;
+  }
+};
+function createDataStore(_config) {
+  return new InMemoryDataStore();
+}
+
+// src/context.ts
+var ConsoleProgressBackend = class {
+  #write;
+  constructor(write) {
+    this.#write = write ?? ((line) => {
+      if (typeof process !== "undefined" && process.stderr) {
+        process.stderr.write(`${line}
+`);
+      }
+    });
+  }
+  report(requestId, percent, message) {
+    this.#write(`[progress ${percent}%] ${requestId}: ${message}`);
+  }
+};
+var ToolContext = class {
+  requestId;
+  dataStore;
+  #progress;
+  constructor(requestId, dataStore, progress = null) {
+    this.requestId = requestId;
+    this.dataStore = dataStore;
+    this.#progress = progress;
+  }
+  /**
+   * Emit a progress update (0–100). Throws {@link RangeError} when `percent` is
+   * out of range; a no-op when no {@link ProgressBackend} is wired.
+   */
+  reportProgress(percent, message) {
+    if (percent < 0 || percent > 100) {
+      throw new RangeError(`progress percent must be in [0, 100], got ${percent}`);
+    }
+    this.#progress?.report(this.requestId, percent, message);
+  }
+};
+function createToolContext(dataStore, payload) {
+  const requestId = typeof payload.request_id === "string" && payload.request_id !== "" ? payload.request_id : "unknown";
+  return new ToolContext(requestId, dataStore, null);
+}
+
+// src/config.ts
+function envOr(env, key, fallback) {
+  const value = env[key];
+  return value !== void 0 && value !== "" ? value : fallback;
+}
+function envIntOr(env, key, fallback) {
+  const value = env[key];
+  if (value !== void 0 && value !== "") {
+    const parsed = Number(value);
+    if (Number.isInteger(parsed)) {
+      return parsed;
+    }
+  }
+  return fallback;
+}
+var SDKConfig = class _SDKConfig {
+  serverHost;
+  serverPort;
+  logLevel;
+  awsRegion;
+  dynamodbEndpoint;
+  toolDataTable;
+  environment;
+  apiKey;
+  platformUrl;
+  hmacSecret;
+  hmacToleranceSeconds;
+  toolConfirmationSecret;
+  #lambda;
+  constructor(options = {}) {
+    this.serverHost = options.serverHost ?? "127.0.0.1";
+    this.serverPort = options.serverPort ?? 8080;
+    this.logLevel = options.logLevel ?? "INFO";
+    this.awsRegion = options.awsRegion ?? "ap-northeast-1";
+    this.dynamodbEndpoint = options.dynamodbEndpoint ?? "";
+    this.toolDataTable = options.toolDataTable ?? "tool-data";
+    this.environment = options.environment ?? "local";
+    this.apiKey = options.apiKey ?? "";
+    this.platformUrl = options.platformUrl ?? "https://api.convilyn.corenovus.com";
+    this.hmacSecret = options.hmacSecret ?? "";
+    this.hmacToleranceSeconds = options.hmacToleranceSeconds ?? DEFAULT_HMAC_TOLERANCE_SECONDS;
+    this.toolConfirmationSecret = options.toolConfirmationSecret ?? "";
+    this.#lambda = options.lambda ?? false;
+  }
+  /** True when running in AWS Lambda. */
+  get isLambda() {
+    return this.#lambda;
+  }
+  /** True for a local/dev environment (relaxes HMAC). */
+  get isLocal() {
+    if (this.environment === "local") {
+      return true;
+    }
+    return !this.#lambda && (this.serverHost === "127.0.0.1" || this.serverHost === "localhost");
+  }
+  /** Load configuration from environment variables, falling back to defaults. */
+  static fromEnv(env = typeof process !== "undefined" ? process.env : {}) {
+    return new _SDKConfig({
+      serverHost: envOr(env, "CONVILYN_HOST", "127.0.0.1"),
+      serverPort: envIntOr(env, "CONVILYN_PORT", 8080),
+      logLevel: envOr(env, "CONVILYN_LOG_LEVEL", "INFO"),
+      awsRegion: envOr(env, "AWS_REGION", "ap-northeast-1"),
+      dynamodbEndpoint: envOr(env, "DYNAMODB_ENDPOINT", ""),
+      toolDataTable: envOr(env, "TOOL_DATA_TABLE", "tool-data"),
+      environment: envOr(env, "CONVILYN_ENVIRONMENT", "local"),
+      apiKey: envOr(env, "CONVILYN_API_KEY", ""),
+      platformUrl: envOr(env, "CONVILYN_PLATFORM_URL", "https://api.convilyn.corenovus.com"),
+      hmacSecret: envOr(env, "CONVILYN_HMAC_SECRET", ""),
+      hmacToleranceSeconds: envIntOr(
+        env,
+        "CONVILYN_HMAC_TOLERANCE_SECONDS",
+        DEFAULT_HMAC_TOLERANCE_SECONDS
+      ),
+      toolConfirmationSecret: envOr(env, "CONVILYN_TOOL_CONFIRMATION_SECRET", ""),
+      lambda: Boolean(env["AWS_LAMBDA_FUNCTION_NAME"])
+    });
+  }
+};
+var PUBLIC_SCHEMA_VERSION = "1";
+var DEFAULT_SCHEMA_VERSION = "1.0";
+var MAX_NAME = 80;
+var MAX_DESCRIPTION = 500;
+var MAX_SYSTEM_PROMPT = 8e3;
+var MAX_TOOLS = 20;
+var MAX_TOOL_NAME = 128;
+var MAX_NOTE = 200;
+var MAX_TAGS = 8;
+var MAX_TAG_LEN = 24;
+var ORIGIN = { x: 0, y: 0 };
+var FORBIDDEN_TOOL = "request_user_input";
+var DEFAULT_VERSION = "1.0.0";
+var MAX_SPEC_ID = 128;
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+function validateName(name) {
+  if (name.length < 1 || name.length > MAX_NAME) {
+    throw new ConvilynAuthorError(`name must be 1\u2013${MAX_NAME} characters (got ${name.length})`);
+  }
+}
+function validateSpecId(specId) {
+  if (specId.length < 1 || specId.length > MAX_SPEC_ID || /\s/.test(specId)) {
+    throw new ConvilynAuthorError(
+      `specId must be 1\u2013${MAX_SPEC_ID} characters with no whitespace (the portal expects the "dev_<developer-id>.<name>" namespace)`
+    );
+  }
+}
+function validateVersion(version) {
+  if (!SEMVER_RE.test(version)) {
+    throw new ConvilynAuthorError(`version must be valid semver (e.g. "1.0.0"; got "${version}")`);
+  }
+}
+function validateDescription(description) {
+  if (description.length > MAX_DESCRIPTION) {
+    throw new ConvilynAuthorError(`description must be \u2264 ${MAX_DESCRIPTION} characters`);
+  }
+}
+function validateSystemPrompt(systemPrompt) {
+  if (systemPrompt.length > MAX_SYSTEM_PROMPT) {
+    throw new ConvilynAuthorError(`systemPrompt must be \u2264 ${MAX_SYSTEM_PROMPT} characters`);
+  }
+}
+function validateTag(tag) {
+  if (tag.length < 1 || tag.length > MAX_TAG_LEN) {
+    throw new ConvilynAuthorError(`tag "${tag}" must be 1\u2013${MAX_TAG_LEN} characters`);
+  }
+}
+function validateTags(tags) {
+  if (tags.length > MAX_TAGS) {
+    throw new ConvilynAuthorError(`at most ${MAX_TAGS} tags are allowed (got ${tags.length})`);
+  }
+  tags.forEach(validateTag);
+}
+function toolKey(toolName) {
+  const parts = toolName.split(":");
+  return parts[parts.length - 1] ?? toolName;
+}
+function validateToolName(toolName) {
+  if (toolName.length < 1 || toolName.length > MAX_TOOL_NAME) {
+    throw new ConvilynAuthorError(`toolName must be 1\u2013${MAX_TOOL_NAME} characters`);
+  }
+  if (toolKey(toolName) === FORBIDDEN_TOOL) {
+    throw new ConvilynAuthorError(
+      `tool "${FORBIDDEN_TOOL}" is not permitted in a workflow palette (the agent cannot pause mid-execution)`
+    );
+  }
+}
+var WorkflowSpec = class _WorkflowSpec {
+  #state;
+  constructor(name, options = {}) {
+    validateName(name);
+    if (options.specId != null) {
+      validateSpecId(options.specId);
+    }
+    const version = options.version ?? DEFAULT_VERSION;
+    validateVersion(version);
+    this.#state = {
+      name,
+      systemPrompt: "",
+      schemaVersion: DEFAULT_SCHEMA_VERSION,
+      specId: options.specId,
+      version,
+      tags: [],
+      toolPalette: []
+    };
+  }
+  #cloneWith(patch) {
+    const next = new _WorkflowSpec(this.#state.name);
+    next.#state = {
+      ...this.#state,
+      ...patch,
+      tags: [...patch.tags ?? this.#state.tags],
+      toolPalette: [...patch.toolPalette ?? this.#state.toolPalette]
+    };
+    return next;
+  }
+  // ── read-only accessors (return copies to preserve immutability) ──────────
+  get name() {
+    return this.#state.name;
+  }
+  get description() {
+    return this.#state.description;
+  }
+  get systemPrompt() {
+    return this.#state.systemPrompt;
+  }
+  get schemaVersion() {
+    return this.#state.schemaVersion;
+  }
+  get specId() {
+    return this.#state.specId;
+  }
+  get version() {
+    return this.#state.version;
+  }
+  get tags() {
+    return [...this.#state.tags];
+  }
+  get toolPalette() {
+    return this.#state.toolPalette.map((item) => ({ ...item, position: { ...item.position } }));
+  }
+  get canvasLayout() {
+    return this.#state.canvasLayout;
+  }
+  // ── builder methods ───────────────────────────────────────────────────────
+  withName(name) {
+    validateName(name);
+    return this.#cloneWith({ name });
+  }
+  withDescription(description) {
+    validateDescription(description);
+    return this.#cloneWith({ description });
+  }
+  withSystemPrompt(systemPrompt) {
+    validateSystemPrompt(systemPrompt);
+    return this.#cloneWith({ systemPrompt });
+  }
+  withSchemaVersion(schemaVersion) {
+    return this.#cloneWith({ schemaVersion });
+  }
+  /** Set the portal spec id (`dev_<developer-id>.<name>` namespace). */
+  withSpecId(specId) {
+    validateSpecId(specId);
+    return this.#cloneWith({ specId });
+  }
+  /** Set the blueprint semver version (default `1.0.0`). */
+  withVersion(version) {
+    validateVersion(version);
+    return this.#cloneWith({ version });
+  }
+  /** Replace the tag set. */
+  withTags(tags) {
+    validateTags(tags);
+    return this.#cloneWith({ tags: [...tags] });
+  }
+  /** Append a tag (no-op if already present). */
+  addTag(tag) {
+    validateTag(tag);
+    if (this.#state.tags.includes(tag)) {
+      return this.#cloneWith({});
+    }
+    const tags = [...this.#state.tags, tag];
+    validateTags(tags);
+    return this.#cloneWith({ tags });
+  }
+  /**
+   * Add (or replace, by `toolName`) one tool on the palette. Rejects the
+   * `request_user_input` tool (invariant I3) and palettes larger than
+   * {@link MAX_TOOLS}.
+   */
+  addTool(toolName, options = {}) {
+    validateToolName(toolName);
+    if (options.note != null && options.note.length > MAX_NOTE) {
+      throw new ConvilynAuthorError(`tool note must be \u2264 ${MAX_NOTE} characters`);
+    }
+    const item = {
+      toolName,
+      position: options.position ? { ...options.position } : { ...ORIGIN },
+      ...options.note != null ? { note: options.note } : {}
+    };
+    const existing = this.#state.toolPalette.findIndex((entry) => entry.toolName === toolName);
+    const toolPalette = existing >= 0 ? this.#state.toolPalette.map((entry, index) => index === existing ? item : entry) : [...this.#state.toolPalette, item];
+    if (toolPalette.length > MAX_TOOLS) {
+      throw new ConvilynAuthorError(`at most ${MAX_TOOLS} tools are allowed`);
+    }
+    return this.#cloneWith({ toolPalette });
+  }
+  /** Add several tools by name (default canvas position), de-duplicated. */
+  useTools(...toolNames) {
+    return toolNames.reduce((spec, toolName) => spec.addTool(toolName), this);
+  }
+  withCanvasLayout(canvasLayout) {
+    return this.#cloneWith({ canvasLayout });
+  }
+  // ── compile / serialize ───────────────────────────────────────────────────
+  /**
+   * The PUBLIC publish blueprint (snake_case; Python-SDK parity). This is the
+   * shape `submitWorkflow` / `convilyn-author push` send to the Developer
+   * Portal. Requires a `specId` (constructor option or {@link withSpecId}).
+   *
+   * Mirrors the Python SDK's `exclude_none` semantics: `agent_config` is
+   * emitted only when a systemPrompt is set, `mcp_config` only when the
+   * palette is non-empty. UI-only metadata (positions, notes, canvasLayout)
+   * is deliberately NOT emitted — the portal's blueprint schema rejects
+   * unknown fields; that data belongs to {@link toExportPayload}.
+   */
+  compile() {
+    const specId = this.#state.specId;
+    if (specId == null) {
+      throw new ConvilynAuthorError(
+        'compile() requires a specId \u2014 pass it to the constructor (new WorkflowSpec(name, { specId })) or call withSpecId(). The Developer Portal expects the "dev_<developer-id>.<name>" namespace.'
+      );
+    }
+    const blueprint = {
+      public_schema_version: PUBLIC_SCHEMA_VERSION,
+      spec_id: specId,
+      version: this.#state.version,
+      name: this.#state.name,
+      keywords: [...this.#state.tags]
+    };
+    if (this.#state.description != null) {
+      blueprint.description = this.#state.description;
+    }
+    if (this.#state.systemPrompt !== "") {
+      blueprint.agent_config = { system_prompt: this.#state.systemPrompt };
+    }
+    if (this.#state.toolPalette.length > 0) {
+      const tools = this.#state.toolPalette.map((item) => item.toolName);
+      const servers = [
+        ...new Set(
+          tools.filter((toolName) => toolName.includes(":")).map((toolName) => toolName.split(":")[0])
+        )
+      ];
+      blueprint.mcp_config = { mcp_servers: servers, tools };
+    }
+    return blueprint;
+  }
+  /** The compiled blueprint serialised as 2-space-indented JSON. */
+  compileJson() {
+    return JSON.stringify(this.compile(), null, 2);
+  }
+  /** Write the compiled blueprint to a JSON file (default `workflow.spec.json`). */
+  async save(path = "workflow.spec.json") {
+    await writeFile(path, this.compileJson(), "utf8");
+    return path;
+  }
+  /**
+   * The camelCase user_workflows `ExportPayload` (canvas/authoring contract).
+   * Carries the UI-only metadata (positions, notes, canvasLayout) that the
+   * publish blueprint omits.
+   */
+  toExportPayload() {
+    const payload = {
+      schemaVersion: this.#state.schemaVersion,
+      name: this.#state.name,
+      systemPrompt: this.#state.systemPrompt,
+      toolPalette: this.#state.toolPalette.map((item) => ({
+        toolName: item.toolName,
+        position: { ...item.position },
+        ...item.note != null ? { note: item.note } : {}
+      })),
+      tags: [...this.#state.tags]
+    };
+    if (this.#state.description != null) {
+      payload.description = this.#state.description;
+    }
+    if (this.#state.canvasLayout != null) {
+      payload.canvasLayout = this.#state.canvasLayout;
+    }
+    return payload;
+  }
+  /** Rebuild a {@link WorkflowSpec} from a user_workflows `ExportPayload`. */
+  static fromExportPayload(payload) {
+    let spec = new _WorkflowSpec(payload.name).withSystemPrompt(payload.systemPrompt ?? "").withSchemaVersion(payload.schemaVersion ?? DEFAULT_SCHEMA_VERSION).withTags(payload.tags ?? []);
+    if (payload.description != null) {
+      spec = spec.withDescription(payload.description);
+    }
+    if (payload.canvasLayout != null) {
+      spec = spec.withCanvasLayout(payload.canvasLayout);
+    }
+    for (const item of payload.toolPalette ?? []) {
+      spec = spec.addTool(item.toolName, {
+        position: item.position,
+        ...item.note != null ? { note: item.note } : {}
+      });
+    }
+    return spec;
+  }
+  /**
+   * Rebuild a {@link WorkflowSpec} from a publish blueprint. Lossy for canvas
+   * metadata by design — that data lives in the `ExportPayload` contract.
+   */
+  static fromBlueprint(blueprint) {
+    let spec = new _WorkflowSpec(blueprint.name, {
+      specId: blueprint.spec_id,
+      ...blueprint.version != null ? { version: blueprint.version } : {}
+    }).withSystemPrompt(blueprint.agent_config?.system_prompt ?? "").withTags(blueprint.keywords ?? []);
+    if (blueprint.description != null) {
+      spec = spec.withDescription(blueprint.description);
+    }
+    for (const toolName of blueprint.mcp_config?.tools ?? []) {
+      spec = spec.addTool(toolName);
+    }
+    return spec;
+  }
+  /**
+   * Parse a spec from a JSON string. Shape-sniffs: objects carrying `spec_id`
+   * or `public_schema_version` parse as a blueprint; anything else as an
+   * `ExportPayload` — so `push --workflow-file` accepts both file formats.
+   */
+  static fromJson(data) {
+    const parsed = JSON.parse(data);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new ConvilynAuthorError("workflow spec JSON must be an object");
+    }
+    if ("spec_id" in parsed || "public_schema_version" in parsed) {
+      return _WorkflowSpec.fromBlueprint(parsed);
+    }
+    return _WorkflowSpec.fromExportPayload(parsed);
+  }
+  /** Read a saved spec from a JSON file (default `workflow.spec.json`). */
+  static async load(path = "workflow.spec.json") {
+    return _WorkflowSpec.fromJson(await readFile(path, "utf8"));
+  }
+};
+
+// src/jsonrpc.ts
+var JSONRPC_VERSION = "2.0";
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+var TOOLS_CALL = "tools/call";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRpcRequest(parsed) {
+  if (!isRecord2(parsed) || typeof parsed.method !== "string") {
+    return null;
+  }
+  const id = typeof parsed.id === "string" || typeof parsed.id === "number" ? parsed.id : null;
+  return {
+    jsonrpc: typeof parsed.jsonrpc === "string" ? parsed.jsonrpc : JSONRPC_VERSION,
+    method: parsed.method,
+    params: isRecord2(parsed.params) ? parsed.params : {},
+    id
+  };
+}
+function rpcResult(id, result) {
+  return { jsonrpc: JSONRPC_VERSION, result, id };
+}
+function rpcError(id, code, message, data) {
+  const error = data !== void 0 ? { code, message, data } : { code, message };
+  return { jsonrpc: JSONRPC_VERSION, error, id };
+}
+
+// src/tool-result-wire.ts
+var OUTPUT_INLINE_THRESHOLD_BYTES = 16384;
+var SUMMARY_MAX = 2e3;
+function clampSummary(summary) {
+  const trimmed = summary.length > SUMMARY_MAX ? summary.slice(0, SUMMARY_MAX) : summary;
+  return trimmed.length > 0 ? trimmed : "Tool executed.";
+}
+async function okEnvelope(data, summary, dataStore) {
+  const base = {
+    summary: clampSummary(summary),
+    status: "ok",
+    success: true,
+    error_code: null,
+    error_message: null
+  };
+  const serialised = JSON.stringify(data);
+  if (Buffer.byteLength(serialised, "utf8") > OUTPUT_INLINE_THRESHOLD_BYTES) {
+    base.ref_id = await dataStore.store(data);
+  } else {
+    base.data = data;
+  }
+  return base;
+}
+function toolErrorEnvelope(code, message, summary, details) {
+  return {
+    summary: clampSummary(summary),
+    status: "tool_error",
+    error: details ? { code, message, details } : { code, message },
+    success: false,
+    error_code: code,
+    error_message: message
+  };
+}
+function validationErrorEnvelope(issues) {
+  const first = issues[0];
+  const summary = first ? `Invalid input: ${first.field} \u2014 ${first.issue}` : "Invalid input";
+  return {
+    summary: clampSummary(summary),
+    status: "validation_error",
+    validation_errors: issues,
+    error: { code: "INPUT_VALIDATION_ERROR", message: summary },
+    success: false,
+    error_code: "INPUT_VALIDATION_ERROR",
+    error_message: summary
+  };
+}
+async function toWireEnvelope(result, dataStore) {
+  if (result.success) {
+    const data = result.data ?? {};
+    const summary2 = result.summary ?? "Tool executed successfully.";
+    return okEnvelope(data, summary2, dataStore);
+  }
+  const code = result.error?.code ?? "TOOL_INTERNAL_ERROR";
+  const message = result.error?.message ?? "Tool execution failed";
+  const summary = result.summary ?? message;
+  return toolErrorEnvelope(code, message, summary, result.error?.details);
+}
+function rawOkEnvelope(data, summary) {
+  return {
+    summary: clampSummary(summary),
+    status: "ok",
+    data,
+    success: true,
+    error_code: null,
+    error_message: null
+  };
+}
+function rawToolErrorEnvelope(code, message, summary) {
+  return toolErrorEnvelope(code, message, summary);
+}
+
+// src/tool-server.ts
+var GET_TOOL_DATA = "get_tool_data";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toValidationIssues(issues) {
+  return issues.map((issue) => {
+    const field = issue.path.length > 0 ? issue.path.join(".") : ".";
+    const wire = { field, issue: issue.message };
+    if (issue.code) {
+      wire.expected = issue.code;
+    }
+    return wire;
+  });
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var ToolServer = class {
+  server;
+  dataStore;
+  #tools = /* @__PURE__ */ new Map();
+  #capabilities;
+  #sdkVersion;
+  constructor(server, options = {}) {
+    this.server = server;
+    this.dataStore = options.dataStore ?? new InMemoryDataStore();
+    this.#capabilities = [...options.capabilities ?? []];
+    this.#sdkVersion = options.sdkVersion;
+    for (const tool of options.tools ?? []) {
+      this.register(tool);
+    }
+  }
+  /** Register a tool. Throws on a duplicate name. Chainable. */
+  register(tool) {
+    if (tool.name === GET_TOOL_DATA) {
+      throw new ConvilynAuthorError(`tool name "${GET_TOOL_DATA}" is reserved`);
+    }
+    if (this.#tools.has(tool.name)) {
+      throw new ConvilynAuthorError(`duplicate tool name: ${tool.name}`);
+    }
+    this.#tools.set(tool.name, tool);
+    return this;
+  }
+  /** Names of the registered (author) tools. */
+  get toolNames() {
+    return [...this.#tools.keys()];
+  }
+  /** Number of registered (author) tools — the `/health` `tool_count`. */
+  get toolCount() {
+    return this.#tools.size;
+  }
+  /** The compiled manifest blueprint for this server. */
+  manifest() {
+    const tools = [...this.#tools.values()].map((tool) => tool.toSpec());
+    return new ConvilynManifest(this.server, {
+      tools,
+      capabilities: this.#capabilities,
+      sdkVersion: this.#sdkVersion
+    });
+  }
+  /**
+   * Dispatch one JSON-RPC request. Pure and transport-free: never throws for a
+   * tool fault — protocol faults become a JSON-RPC `error`, tool/validation
+   * faults become a ToolResult envelope inside `result`.
+   */
+  async dispatch(request) {
+    const id = request.id ?? null;
+    if (request.method !== TOOLS_CALL) {
+      return rpcError(id, METHOD_NOT_FOUND, `unsupported method: ${request.method}`);
+    }
+    const params = request.params ?? {};
+    const name = params.name;
+    if (typeof name !== "string" || name === "") {
+      return rpcError(id, INVALID_PARAMS, "params.name is required");
+    }
+    const args = isRecord3(params.arguments) ? params.arguments : {};
+    const ctx = createToolContext(this.dataStore, isRecord3(params.context) ? params.context : {});
+    if (name === GET_TOOL_DATA) {
+      return this.#dispatchGetToolData(id, args);
+    }
+    const tool = this.#tools.get(name);
+    if (!tool) {
+      return rpcError(id, METHOD_NOT_FOUND, `unknown tool: ${name}`);
+    }
+    const parsed = tool.inputSchema.safeParse(args);
+    if (!parsed.success) {
+      const issues = toValidationIssues(parsed.error.issues);
+      return rpcResult(id, validationErrorEnvelope(issues));
+    }
+    try {
+      const result = await tool.handler(parsed.data, ctx);
+      const envelope = await toWireEnvelope(result, this.dataStore);
+      return rpcResult(id, envelope);
+    } catch (err) {
+      return rpcError(id, INTERNAL_ERROR, errorMessage(err));
+    }
+  }
+  async #dispatchGetToolData(id, args) {
+    const refId = args.ref_id;
+    if (typeof refId !== "string" || refId === "") {
+      return rpcResult(
+        id,
+        rawToolErrorEnvelope(
+          "INPUT_VALIDATION_ERROR",
+          "get_tool_data requires a string ref_id",
+          "Invalid input: ref_id is required"
+        )
+      );
+    }
+    const stored = await this.dataStore.get(refId);
+    if (stored === null) {
+      return rpcResult(
+        id,
+        rawToolErrorEnvelope(
+          "DEPENDENCY_NOT_FOUND",
+          `no data stored for ref_id ${refId}`,
+          `No data for ${refId}`
+        )
+      );
+    }
+    return rpcResult(id, rawOkEnvelope(stored, `Retrieved data for ${refId}`));
+  }
+};
+var ENV_DEV_INSECURE = "CONVILYN_DEV_INSECURE";
+var DEV_INSECURE_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function devInsecureRequested(env = process.env) {
+  return DEV_INSECURE_TRUTHY.has((env[ENV_DEV_INSECURE] ?? "").trim().toLowerCase());
+}
+var JSON_HEADERS = { "content-type": "application/json" };
+function sendJson(res, statusCode, body) {
+  res.writeHead(statusCode, JSON_HEADERS);
+  res.end(JSON.stringify(body));
+}
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+var BodyTooLargeError = class extends Error {
+  constructor() {
+    super(`Request body exceeds ${MAX_BODY_BYTES} bytes`);
+    this.name = "BodyTooLargeError";
+  }
+};
+function readBody(req, maxBytes = MAX_BODY_BYTES) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        chunks.length = 0;
+        reject(new BodyTooLargeError());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function handleMcp(server, req, res, secret, toleranceSeconds, allowInsecure) {
+  let body;
+  try {
+    body = await readBody(req);
+  } catch (err) {
+    if (err instanceof BodyTooLargeError) {
+      res.once("finish", () => req.destroy());
+      sendJson(res, 413, {
+        code: "PAYLOAD_TOO_LARGE",
+        message: "Request body too large"
+      });
+      return;
+    }
+    throw err;
+  }
+  if (secret === "" && allowInsecure) {
+    await dispatchParsed(server, res, body);
+    return;
+  }
+  try {
+    verifySignature(secret, body, req.headers, {
+      toleranceSeconds
+    });
+  } catch (err) {
+    if (err instanceof InvalidSignatureError) {
+      sendJson(res, 401, {
+        code: "INVALID_SIGNATURE",
+        message: "Request signature could not be verified"
+      });
+      return;
+    }
+    throw err;
+  }
+  await dispatchParsed(server, res, body);
+}
+async function dispatchParsed(server, res, body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body.toString("utf8"));
+  } catch {
+    sendJson(res, 400, { error: "Invalid JSON" });
+    return;
+  }
+  const request = asRpcRequest(parsed);
+  if (request === null) {
+    sendJson(res, 400, { error: "Invalid JSON" });
+    return;
+  }
+  const response = await server.dispatch(request);
+  sendJson(res, 200, response);
+}
+function serve(toolServer, options = {}) {
+  const config = options.config ?? SDKConfig.fromEnv();
+  const host = options.host ?? config.serverHost;
+  const port = options.port ?? config.serverPort;
+  const secret = options.hmacSecret ?? config.hmacSecret;
+  const toleranceSeconds = options.toleranceSeconds ?? config.hmacToleranceSeconds;
+  const allowInsecure = options.allowInsecure ?? devInsecureRequested();
+  if (secret === "" && !allowInsecure) {
+    throw new ConvilynStartupError(
+      `CONVILYN_HMAC_SECRET is required to serve inbound /mcp traffic. Refusing to start without signature verification. For local development use \`convilyn-author dev\` or set ${ENV_DEV_INSECURE}=1 (INSECURE \u2014 local only).`
+    );
+  }
+  if (secret === "") {
+    console.warn(
+      "convilyn-author: CONVILYN_HMAC_SECRET not set; serving /mcp WITHOUT signature verification (insecure local dev only \u2014 do NOT deploy this configuration)"
+    );
+  }
+  const httpServer = createServer((req, res) => {
+    void route(toolServer, req, res, secret, toleranceSeconds, allowInsecure).catch(() => {
+      if (!res.headersSent) {
+        sendJson(res, 500, { error: "Internal server error" });
+      }
+    });
+  });
+  httpServer.listen(port, host);
+  return httpServer;
+}
+async function route(toolServer, req, res, secret, toleranceSeconds, allowInsecure) {
+  const path = (req.url ?? "").split("?")[0];
+  const method = req.method ?? "GET";
+  if (method === "GET" && path === "/health") {
+    sendJson(res, 200, {
+      status: "healthy",
+      server: toolServer.server.name,
+      version: VERSION,
+      tool_count: toolServer.toolCount
+    });
+    return;
+  }
+  if (method === "GET" && path === "/manifest") {
+    sendJson(res, 200, toolServer.manifest().toWire());
+    return;
+  }
+  if (method === "POST" && path === "/mcp") {
+    await handleMcp(toolServer, req, res, secret, toleranceSeconds, allowInsecure);
+    return;
+  }
+  sendJson(res, 404, { error: "Not found" });
+}
+
+// src/compliance.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pass(checkName, message) {
+  return { passed: true, checkName, message };
+}
+function fail(checkName, message) {
+  return { passed: false, checkName, message };
+}
+function checkServerMetadata(server) {
+  const { name, version, description } = server.server;
+  if (!name || !version || !description) {
+    return fail("server_metadata", "server name, version, and description must all be non-empty");
+  }
+  return pass("server_metadata", "server metadata is complete");
+}
+function checkToolsExist(server) {
+  return server.toolCount > 0 ? pass("tools_exist", `server has ${server.toolCount} tool(s)`) : fail("tools_exist", "server has no registered tools");
+}
+function checkToolSchemas(server) {
+  for (const tool of server.manifest().tools) {
+    if (!tool.name || !tool.description) {
+      return fail("tool_schemas", `tool "${tool.name}" is missing a name or description`);
+    }
+    if (!isRecord4(tool.inputSchema) || tool.inputSchema.type !== "object") {
+      return fail("tool_schemas", `tool "${tool.name}" input_schema is not a JSON-Schema object`);
+    }
+  }
+  return pass("tool_schemas", "all tool schemas are valid");
+}
+function checkManifestSynth(server) {
+  try {
+    const wire = server.manifest().toWire();
+    return isRecord4(wire) ? pass("manifest_synth", "manifest compiles to a wire object") : fail("manifest_synth", "manifest did not compile to an object");
+  } catch (err) {
+    return fail("manifest_synth", `manifest synth threw: ${err.message}`);
+  }
+}
+async function checkRefIdPattern(server) {
+  const refId = await server.dataStore.store({ __compliance_probe__: true });
+  return /^td_[0-9a-f]{12}$/.test(refId) ? pass("ref_id_pattern", "data store returns a td_<12-hex> ref_id") : fail("ref_id_pattern", `ref_id "${refId}" does not match td_<12-hex>`);
+}
+async function checkGetToolData(server) {
+  const refId = await server.dataStore.store({ probe: 1 });
+  const response = await server.dispatch({
+    jsonrpc: "2.0",
+    method: TOOLS_CALL,
+    params: { name: GET_TOOL_DATA, arguments: { ref_id: refId } },
+    id: "compliance"
+  });
+  const result = response.result;
+  if (isRecord4(result) && result.status === "ok") {
+    return pass("get_tool_data", "built-in get_tool_data resolves a stored ref_id");
+  }
+  return fail("get_tool_data", "built-in get_tool_data did not resolve a stored ref_id");
+}
+async function runComplianceChecks(server) {
+  const results = [
+    checkServerMetadata(server),
+    checkToolsExist(server),
+    checkToolSchemas(server),
+    checkManifestSynth(server),
+    await checkRefIdPattern(server),
+    await checkGetToolData(server)
+  ];
+  return { results };
+}
+
+// src/client.ts
+function withApiV1(platformUrl) {
+  const trimmed = platformUrl.replace(/\/+$/, "");
+  return trimmed.endsWith("/api/v1") ? trimmed : `${trimmed}/api/v1`;
+}
+var CONSUMER_KEY_PREFIX = "ck_";
+function isConsumerKey(key) {
+  return key.startsWith(CONSUMER_KEY_PREFIX);
+}
+function maskKey(key) {
+  return key.length <= 8 ? "***" : `${key.slice(0, 4)}\u2026${key.slice(-2)}`;
+}
+var ConvilynClient = class {
+  baseUrl;
+  #apiKey;
+  #fetch;
+  constructor(options = {}) {
+    const config = options.config ?? SDKConfig.fromEnv();
+    this.baseUrl = options.baseUrl ?? withApiV1(config.platformUrl);
+    this.#apiKey = options.apiKey ?? config.apiKey;
+    if (this.#apiKey && isConsumerKey(this.#apiKey)) {
+      throw new ConvilynAuthorError(
+        `${maskKey(this.#apiKey)} looks like a Convilyn consumer API key ("${CONSUMER_KEY_PREFIX}"), not an Author SDK / developer-portal token. The Author SDK authenticates with a cvl_ developer key \u2014 call register() to mint one, or set CONVILYN_API_KEY to your cvl_ key. (Consumer keys call the data-plane API; they do not publish workflows / tools.)`
+      );
+    }
+    this.#fetch = options.fetch ?? globalThis.fetch;
+  }
+  /** The `cvl_` developer key currently in use (empty until set or registered). */
+  get apiKey() {
+    return this.#apiKey;
+  }
+  #headers(auth) {
+    const headers = { "content-type": "application/json" };
+    if (auth) {
+      if (!this.#apiKey) {
+        throw new ConvilynAuthorError(
+          "No developer API key set. Provide `apiKey`, set CONVILYN_API_KEY to a cvl_ developer key, or call register() first."
+        );
+      }
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    }
+    return headers;
+  }
+  async #request(method, path, body, auth = true) {
+    const res = await this.#fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: this.#headers(auth),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let parsed;
+      try {
+        parsed = await res.json();
+      } catch {
+        parsed = void 0;
+      }
+      throw new ConvilynApiError(
+        res.status,
+        `${method} ${path} failed (HTTP ${res.status})`,
+        parsed
+      );
+    }
+    if (res.status === 204) {
+      return void 0;
+    }
+    return await res.json();
+  }
+  // ── Developer registration ──────────────────────────────────────
+  /**
+   * `POST /developers/register` — create a developer account and mint a `cvl_`
+   * key. No auth required. The returned key is captured on this client for
+   * subsequent calls (and returned so the caller can persist it — it is shown
+   * only once).
+   */
+  async register(request) {
+    const result = await this.#request(
+      "POST",
+      "/developers/register",
+      request,
+      false
+    );
+    if (result.api_key && !this.#apiKey) {
+      this.#apiKey = result.api_key;
+    }
+    return result;
+  }
+  // ── Server operations ───────────────────────────────────────────
+  /** `POST /developers/servers` — submit a tool-server manifest for verification. */
+  async submitServer(request) {
+    return this.#request("POST", "/developers/servers", request);
+  }
+  /** `GET /developers/servers` — list this developer's servers. */
+  async listServers() {
+    return this.#request("GET", "/developers/servers");
+  }
+  /** `GET /developers/servers/{id}/status` — verification status of a server. */
+  async serverStatus(serverId) {
+    return this.#request(
+      "GET",
+      `/developers/servers/${encodeURIComponent(serverId)}/status`
+    );
+  }
+  /** `POST /developers/servers/{id}/test` — trigger a sandbox test run. */
+  async testServer(serverId, slots = {}) {
+    return this.#request(
+      "POST",
+      `/developers/servers/${encodeURIComponent(serverId)}/test`,
+      { slots }
+    );
+  }
+  /** `DELETE /developers/servers/{id}` — deactivate a server. */
+  async deactivateServer(serverId) {
+    await this.#request("DELETE", `/developers/servers/${encodeURIComponent(serverId)}`);
+  }
+  // ── Workflow operations ─────────────────────────────────────────
+  /** `POST /developers/workflows` — submit a compiled workflow spec + its server ids. */
+  async submitWorkflow(request) {
+    return this.#request("POST", "/developers/workflows", request);
+  }
+  /** `GET /developers/workflows` — list this developer's workflows. */
+  async listWorkflows() {
+    return this.#request("GET", "/developers/workflows");
+  }
+  /** `GET /developers/workflows/{id}/status` — verification status of a workflow. */
+  async workflowStatus(workflowId) {
+    return this.#request(
+      "GET",
+      `/developers/workflows/${encodeURIComponent(workflowId)}/status`
+    );
+  }
+  /** `POST /developers/workflows/{id}/test` — sandbox-test a submitted workflow. */
+  async testWorkflow(workflowId, testInput = {}) {
+    return this.#request(
+      "POST",
+      `/developers/workflows/${encodeURIComponent(workflowId)}/test`,
+      { test_input: testInput }
+    );
+  }
+  /** `DELETE /developers/workflows/{id}` — deactivate a workflow. */
+  async deactivateWorkflow(workflowId) {
+    await this.#request("DELETE", `/developers/workflows/${encodeURIComponent(workflowId)}`);
+  }
+  // ── Convilyn-Hosted Author Runtime (port of the Python client) ─────────────
+  /**
+   * `POST /developers/runtimes/hosted` — deploy a tool server into the
+   * Convilyn-Hosted Author Runtime. Counterpart to {@link submitServer}:
+   * instead of registering a caller-deployed endpoint, the platform
+   * provisions a sandboxed Lambda and returns its public endpoint URL.
+   *
+   * Backends without the hosted stack answer 503 `HOSTED_NOT_AVAILABLE`
+   * (older builds: 501); environments with the router unmounted answer 404.
+   * All surface as {@link ConvilynApiError} — catch and fall back to
+   * `push --endpoint-url` (BYO) when a hard guarantee is needed.
+   */
+  async deployHostedRuntime(manifest, options) {
+    const body = { manifest, region: options.region };
+    if (options.workflowSpec !== void 0) {
+      body.workflow_spec = options.workflowSpec;
+    }
+    return this.#request("POST", "/developers/runtimes/hosted", body);
+  }
+  /**
+   * `POST /developers/runtimes/{id}/rollback` — atomically flip the runtime
+   * back to its previous active version.
+   */
+  async rollbackHostedRuntime(runtimeId) {
+    return this.#request(
+      "POST",
+      `/developers/runtimes/${encodeURIComponent(runtimeId)}/rollback`
+    );
+  }
+  /**
+   * `GET /developers/runtimes/{id}/logs` — recent runtime log lines.
+   * `since` is an ISO-8601 timestamp or relative shorthand (`"5m"`, `"1h"`)
+   * interpreted server-side; `limit` defaults to 100 (server caps ~1000).
+   * Accepts either a bare list or an `{entries: [...]}` envelope (mirror of
+   * the Python client) so the SDK survives the wire shape stabilising.
+   */
+  async getHostedRuntimeLogs(runtimeId, options = {}) {
+    const limit = Math.trunc(options.limit ?? 100);
+    let path = `/developers/runtimes/${encodeURIComponent(runtimeId)}/logs?limit=${limit}`;
+    if (options.since) {
+      path = `${path}&since=${encodeURIComponent(options.since)}`;
+    }
+    const result = await this.#request("GET", path);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    if (typeof result === "object" && result !== null && Array.isArray(result.entries)) {
+      return result.entries;
+    }
+    return [];
+  }
+};
+
+export { ConfirmationInvalidError, ConsoleProgressBackend, ConvilynApiError, ConvilynAuthorError, ConvilynClient, ConvilynManifest, ConvilynStartupError, DEFAULT_HMAC_TOLERANCE_SECONDS, ENV_DEV_INSECURE, GET_TOOL_DATA, InMemoryDataStore, InvalidSignatureError, JSONRPC_VERSION, MANIFEST_SDK_VERSION, OUTPUT_INLINE_THRESHOLD_BYTES, PUBLIC_SCHEMA_VERSION, SDKConfig, SERVER_ID_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER, TOOLS_CALL, ToolContext, ToolResult, ToolServer, VERSION, WorkflowSpec, allChecksPassed, createDataStore, createToolContext, devInsecureRequested, failedChecks, generateRefId, runComplianceChecks, serve, signRequest, verifySignature };
+//# sourceMappingURL=chunk-ZNZXT5ZP.js.map
+//# sourceMappingURL=chunk-ZNZXT5ZP.js.map