@dual-os/telegram 0.0.0-stage → 8.0.5

package/index-pm1rw9n0.js

@@ -0,0 +1,1301 @@
+// @bun
+import {
+  __exportAll,
+  TelegramChat2,
+  TelegramChatMember2,
+  TelegramMessage2,
+  TelegramFile2,
+  TelegramChatMemberUpdated,
+  TelegramMessageReactionUpdated,
+  TelegramMessageReactionCountUpdated
+} from "./index-68np0qzt.js";
+import {
+  increment,
+  replace,
+  trim,
+  isEmpty,
+  isNonEmpty,
+  startsWith,
+  match,
+  replaceAll,
+  encode,
+  decode,
+  Action_exports,
+  ActionHandlerError,
+  AuthMethod_exports,
+  Schema,
+  AgentChannel_exports,
+  Key,
+  Event,
+  commandSchema,
+  Trigger_exports,
+  Service,
+  File,
+  read,
+  write,
+  Group_exports,
+  Plugin_exports
+} from "./index-ppnnem2q.js";
+import {
+  dual,
+  identity,
+  pipe,
+  isObject,
+  hasProperty,
+  PipeInspectableProto,
+  none,
+  match2,
+  getOrElse,
+  orElse2,
+  fromNullishOr,
+  fromUndefinedOr,
+  getOrNull,
+  getOrUndefined,
+  liftThrowable,
+  map,
+  flatMap,
+  filter,
+  liftPredicate,
+  succeed,
+  fail,
+  fromOption,
+  try_,
+  isSuccess,
+  match3,
+  fromEntries,
+  toEntries,
+  ensure,
+  append,
+  getUnsafe2,
+  findFirst,
+  empty,
+  filter2,
+  every,
+  millis,
+  TaggedClass,
+  TaggedError,
+  forEach,
+  succeed4,
+  suspend,
+  sync,
+  void_2,
+  gen2,
+  fail5,
+  fromOption2,
+  flatMap3,
+  result,
+  map3,
+  mapError,
+  orDie,
+  ignore,
+  scoped,
+  acquireRelease,
+  fnUntraced,
+  fn,
+  encode3,
+  makeZoned,
+  make4,
+  toUtc,
+  toDateUtc,
+  toEpochMillis,
+  formatIso,
+  formatIsoOffset,
+  InvalidValue,
+  compose,
+  transform,
+  transformEffect,
+  is,
+  decodeUnknownEffect,
+  decodeOption,
+  optionalKey,
+  optional,
+  Literal,
+  Never,
+  Unknown,
+  String3,
+  Number3,
+  Boolean2,
+  Struct,
+  Record,
+  StructWithRest,
+  ArraySchema,
+  Union,
+  Literals,
+  NullOr,
+  decodeTo,
+  isPattern,
+  Int,
+  Natural,
+  isMaxLength,
+  NonEmptyString,
+  Defect,
+  fromJsonString,
+  Uint8ArrayFromBase64,
+  TaggedError2,
+  toEquivalence,
+  Json,
+  make6,
+  get5,
+  set,
+  update,
+  fromEffect,
+  fromIterable2,
+  paginate,
+  unwrap2,
+  mapEffect,
+  flatMap4,
+  filterMap2,
+  decodeText,
+  runCollect,
+  runHead,
+  post,
+  del,
+  setHeaders,
+  bodyUint8Array,
+  bodyJsonUnsafe,
+  bodyFormDataRecord,
+  filterStatusOk
+} from "./index-sdgqen8s.js";
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Boolean.js
+var Boolean = globalThis.Boolean;
+var match4 = /* @__PURE__ */ dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Ref.js
+var TypeId = "~effect/Ref";
+var RefProto = {
+  [TypeId]: {
+    _A: identity
+  },
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "Ref",
+      ref: this.ref
+    };
+  }
+};
+var makeUnsafe = (value) => {
+  const self = Object.create(RefProto);
+  self.ref = make6(value);
+  return self;
+};
+var make = (value) => sync(() => makeUnsafe(value));
+var get = (self) => sync(() => self.ref.current);
+var set2 = /* @__PURE__ */ dual(2, (self, value) => sync(() => set(self.ref, value)));
+var getAndUpdate = /* @__PURE__ */ dual(2, (self, f) => sync(() => {
+  const current = self.ref.current;
+  self.ref.current = f(current);
+  return current;
+}));
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/encoding/Sse.js
+var SseErrorTypeId = "~effect/encoding/Sse/SseError";
+
+class EventTooLarge extends (/* @__PURE__ */ TaggedError("EventTooLarge")) {
+  get message() {
+    return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;
+  }
+}
+
+class SseError extends (/* @__PURE__ */ TaggedError("SseError")) {
+  [SseErrorTypeId] = SseErrorTypeId;
+  get message() {
+    return this.reason.message;
+  }
+}
+var defaultMaxEventSize = 10 * 1024 * 1024;
+function makeParser(onParse, options) {
+  const maxEventSize = options?.maxEventSize ?? defaultMaxEventSize;
+  const dispatchEmptyNamedEvents = options?.dispatchEmptyNamedEvents === true;
+  let isFirstChunk;
+  let pending;
+  let pendingLength;
+  let discardTrailingNewline;
+  let generation = 0;
+  let lastEventId;
+  let eventName;
+  let data;
+  reset();
+  return {
+    feed,
+    reset
+  };
+  function reset() {
+    generation++;
+    isFirstChunk = true;
+    pending = [];
+    pendingLength = 0;
+    discardTrailingNewline = false;
+    lastEventId = undefined;
+    eventName = undefined;
+    data = "";
+  }
+  function feed(chunk) {
+    if (chunk.length === 0)
+      return;
+    if (isFirstChunk && chunk.startsWith(BOM)) {
+      chunk = chunk.slice(BOM.length);
+    }
+    isFirstChunk = false;
+    const length = chunk.length;
+    const currentGeneration = generation;
+    let position = 0;
+    while (position < length) {
+      if (discardTrailingNewline) {
+        discardTrailingNewline = false;
+        if (chunk.charCodeAt(position) === LF) {
+          ++position;
+          continue;
+        }
+      }
+      let lineEnd = position;
+      while (lineEnd < length) {
+        const code = chunk.charCodeAt(lineEnd);
+        if (code === CR || code === LF)
+          break;
+        ++lineEnd;
+      }
+      if (lineEnd === length) {
+        pending.push(chunk.slice(position));
+        pendingLength += length - position;
+        break;
+      }
+      discardTrailingNewline = chunk.charCodeAt(lineEnd) === CR;
+      let line = chunk.slice(position, lineEnd);
+      if (pending.length > 0) {
+        pending.push(line);
+        line = pending.join("");
+        pending = [];
+        pendingLength = 0;
+      }
+      parseLine(line);
+      if (generation !== currentGeneration) {
+        return;
+      }
+      position = lineEnd + 1;
+    }
+    if (pendingLength + data.length > maxEventSize) {
+      const error = new SseError({
+        reason: new EventTooLarge({
+          maxEventSize
+        })
+      });
+      reset();
+      return error;
+    }
+  }
+  function parseLine(line) {
+    if (line.length === 0) {
+      const named = eventName !== undefined && eventName !== "";
+      const event = eventName || "message";
+      const eventData = data;
+      eventName = undefined;
+      data = "";
+      if (eventData.length > 0 || dispatchEmptyNamedEvents && named) {
+        onParse({
+          _tag: "Event",
+          id: lastEventId,
+          event,
+          data: eventData.slice(0, -1)
+        });
+      }
+      return;
+    }
+    const colon = line.indexOf(":");
+    let field = line;
+    let value = "";
+    if (colon >= 0) {
+      field = line.slice(0, colon);
+      value = line.slice(line.charCodeAt(colon + 1) === SPACE ? colon + 2 : colon + 1);
+    }
+    if (field === "data") {
+      data += value + `
+`;
+    } else if (field === "event") {
+      eventName = value;
+    } else if (field === "id" && !value.includes("\x00")) {
+      lastEventId = value;
+    } else if (field === "retry" && /^\d+$/.test(value)) {
+      const retry = parseInt(value, 10);
+      onParse(new Retry({
+        duration: millis(retry),
+        lastEventId
+      }));
+    }
+  }
+}
+var BOM = "\uFEFF";
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var RetryTypeId = "~effect/encoding/Sse/Retry";
+
+class Retry extends (/* @__PURE__ */ TaggedClass("Retry")) {
+  [RetryTypeId] = RetryTypeId;
+  static is(u) {
+    return hasProperty(u, RetryTypeId);
+  }
+  static filter(u) {
+    return Retry.is(u) ? succeed(u) : fail(u);
+  }
+}
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/AgentChannelConformance.js
+var Command = commandSchema(Json);
+var Fixture = Struct({
+  activate: Command,
+  channelId: Key,
+  connectionId: optionalKey(Key),
+  deactivate: Command,
+  definitionSettings: Json,
+  deliver: Command,
+  deploymentSettings: Json,
+  receive: Command
+});
+var ConformanceError = class extends TaggedError2()("AgentChannelConformanceError", {
+  command: Literals([
+    "activate",
+    "deactivate",
+    "receive",
+    "deliver"
+  ]),
+  rule: Literals([
+    "command_kind",
+    "stable_result",
+    "stable_events",
+    "boundary_rejection"
+  ])
+}) {
+};
+var run = fn("AgentChannelConformance.run")(function* (input) {
+  const fixture = yield* decodeUnknownEffect(Fixture)(input, { onExcessProperty: "error" });
+  const runtime = yield* Service;
+  const definition = yield* runtime.getAgentChannel({ channelId: fixture.channelId });
+  const { activate, receive, deliver, deactivate, ...config } = fixture;
+  const { connectionId: _connectionId, ...withoutConnection } = config;
+  const probes = [
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        channelId: "",
+        command: activate
+      }
+    },
+    {
+      input: {
+        ...config,
+        channelId: "conformance/missing/channel",
+        command: activate
+      },
+      code: "not_found"
+    },
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        command: {
+          ...activate,
+          operationKey: ""
+        }
+      }
+    },
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        agent: { id: "synthetic-authority" },
+        command: activate
+      }
+    },
+    {
+      code: "invalid_auth",
+      input: definition.authMethods.length === 0 ? {
+        ...config,
+        command: activate,
+        connectionId: "unexpected"
+      } : {
+        ...withoutConnection,
+        command: activate
+      }
+    }
+  ];
+  for (const probe of probes) {
+    const outcome = yield* suspend(() => runtime.executeAgentChannel(probe.input)).pipe(result);
+    if (outcome._tag !== "Failure" || outcome.failure.code !== probe.code)
+      return yield* new ConformanceError({
+        command: "activate",
+        rule: "boundary_rejection"
+      });
+  }
+  const commands = [
+    ["activate", activate],
+    ["receive", receive],
+    ["deliver", deliver],
+    ["deactivate", deactivate]
+  ];
+  for (const [kind, command] of commands)
+    if (command.kind !== kind)
+      return yield* new ConformanceError({
+        command: kind,
+        rule: "command_kind"
+      });
+  const activated = yield* acquireRelease(runtime.executeAgentChannel({
+    ...config,
+    command: activate
+  }), (result2) => runtime.executeAgentChannel({
+    ...config,
+    command: {
+      ...deactivate,
+      ...result2.kind === "activate" ? {
+        installationKey: result2.installationKey,
+        state: result2.state
+      } : {}
+    }
+  }).pipe(orDie));
+  for (const [kind, command] of commands) {
+    const first = kind === "activate" ? activated : yield* runtime.executeAgentChannel({
+      ...config,
+      command
+    });
+    if (kind === "deliver" && definition.features.deliveryMode === "at-most-once")
+      continue;
+    const second = yield* runtime.executeAgentChannel({
+      ...config,
+      command
+    });
+    const firstJson = yield* decodeUnknownEffect(Json)(first);
+    const secondJson = yield* decodeUnknownEffect(Json)(second);
+    if (!toEquivalence(Json)(firstJson, secondJson))
+      return yield* new ConformanceError({
+        command: kind,
+        rule: "stable_result"
+      });
+    if (kind === "receive") {
+      const nextReceipt = yield* runtime.executeAgentChannel({
+        ...config,
+        command: {
+          ...command,
+          operationKey: `${command.operationKey.slice(0, 500)}:replay`
+        }
+      });
+      if (first.kind !== "receive" || nextReceipt.kind !== "receive" || !toEquivalence(ArraySchema(Event))(first.events, nextReceipt.events))
+        return yield* new ConformanceError({
+          command: kind,
+          rule: "stable_events"
+        });
+    }
+  }
+}, scoped);
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/Mcp.js
+var McpError = class extends TaggedError2()("McpError", {
+  cause: optional(Defect()),
+  message: String3
+}) {
+};
+var protocolVersion = "2025-06-18";
+var Implementation = Struct({
+  name: String3,
+  title: optionalKey(String3),
+  version: String3
+});
+var Tool = Struct({
+  annotations: optionalKey(Struct({ title: optionalKey(String3) })),
+  description: optionalKey(String3),
+  inputSchema: Record(String3, Unknown),
+  name: String3,
+  outputSchema: optionalKey(Record(String3, Unknown)),
+  title: optionalKey(String3)
+});
+var ListToolsResult = Struct({
+  nextCursor: optionalKey(String3),
+  tools: ArraySchema(Tool)
+});
+var ContentBlock = StructWithRest(Struct({
+  text: optionalKey(String3),
+  type: String3
+}), [Record(String3, Unknown)]);
+var CallToolResult = Struct({
+  content: ArraySchema(ContentBlock),
+  isError: optionalKey(Boolean2),
+  structuredContent: optionalKey(Unknown)
+});
+var InitializeResult = Struct({
+  protocolVersion: String3,
+  serverInfo: Implementation
+});
+var Message = Struct({
+  error: optionalKey(Struct({ message: String3 })),
+  id: optionalKey(Unknown),
+  result: optionalKey(Unknown)
+});
+var responseTo = fnUntraced(function* (id, method, response) {
+  const payloads = match4(pipe(response.headers["content-type"] ?? "", startsWith("text/event-stream")), {
+    onFalse: () => fromEffect(response.text),
+    onTrue: () => unwrap2(sync(() => {
+      const events = make6(empty());
+      const parser = makeParser((event) => {
+        if (event._tag === "Event")
+          update(events, append(event.data));
+      });
+      return pipe(response.stream, decodeText(), mapEffect((chunk) => {
+        const error = parser.feed(chunk);
+        if (error !== undefined)
+          return fail5(McpError.make({
+            cause: error,
+            message: error.message
+          }));
+        const ready = get5(events);
+        set(events, empty());
+        return succeed4(ready);
+      }), flatMap4(fromIterable2));
+    }))
+  });
+  const found = yield* pipe(payloads, filterMap2((payload) => fromOption(filter(decodeOption(fromJsonString(Message))(payload), (message) => message.id === id && (message.result !== undefined || message.error !== undefined)), () => payload)), runHead);
+  return yield* fromOption2(found, () => McpError.make({ message: `${method} got no response` }));
+});
+var connect = fn("Mcp.connect")(function* (client, endpoint, headers) {
+  const checked = filterStatusOk(client);
+  const post2 = fnUntraced(function* (version, session, body) {
+    return yield* checked.execute(pipe(post(endpoint), setHeaders({
+      ...headers,
+      accept: "application/json, text/event-stream",
+      "mcp-protocol-version": version,
+      ...match2(session, {
+        onNone: () => ({}),
+        onSome: (id) => ({ "mcp-session-id": id })
+      })
+    }), bodyJsonUnsafe({
+      jsonrpc: "2.0",
+      ...body
+    })));
+  });
+  const call = fnUntraced(function* (version, session, id, method, params) {
+    const response = yield* post2(version, session, {
+      id,
+      method,
+      params
+    });
+    const message = yield* responseTo(id, method, response);
+    if (message.error !== undefined)
+      return yield* McpError.make({ message: `${method}: ${message.error.message}` });
+    return {
+      result: message.result,
+      session: orElse2(fromNullishOr(response.headers["mcp-session-id"]), () => session)
+    };
+  });
+  const negotiatedVersion = yield* make(protocolVersion);
+  const initialized = yield* acquireRelease(call(protocolVersion, none(), 0, "initialize", {
+    capabilities: {},
+    clientInfo: {
+      name: "dual",
+      version: "1"
+    },
+    protocolVersion
+  }), (opened) => match2(opened.session, {
+    onNone: () => void_2,
+    onSome: (id) => flatMap3(get(negotiatedVersion), (version) => ignore(client.execute(pipe(del(endpoint), setHeaders({
+      ...headers,
+      "mcp-protocol-version": version,
+      "mcp-session-id": id
+    })))))
+  }));
+  const server = yield* decodeUnknownEffect(InitializeResult)(initialized.result);
+  if (server.protocolVersion !== protocolVersion && server.protocolVersion !== "2025-03-26")
+    return yield* McpError.make({ message: `Unsupported MCP protocol version ${server.protocolVersion}` });
+  yield* set2(negotiatedVersion, server.protocolVersion);
+  yield* post2(server.protocolVersion, initialized.session, { method: "notifications/initialized" });
+  const ids = yield* make(1);
+  return {
+    request: fn("Mcp.request")(function* (method, params) {
+      return (yield* call(server.protocolVersion, initialized.session, yield* getAndUpdate(ids, increment), method, params)).result;
+    }),
+    server: server.serverInfo
+  };
+});
+var listTools = fn("Mcp.listTools")(function* (client, endpoint, headers) {
+  const session = yield* connect(client, endpoint, headers);
+  const tools = yield* runCollect(paginate({}, fnUntraced(function* (params) {
+    const page = yield* decodeUnknownEffect(ListToolsResult)(yield* session.request("tools/list", params));
+    return [page.tools, map(fromUndefinedOr(page.nextCursor), (cursor) => ({ cursor }))];
+  })));
+  return {
+    server: session.server,
+    tools
+  };
+}, scoped);
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/Http.js
+var File2 = Struct({
+  _tag: optionalKey(Literal("ToolFile")),
+  contentBase64: Uint8ArrayFromBase64,
+  contentType: optionalKey(NullOr(String3)),
+  filename: optionalKey(NullOr(String3)),
+  sizeBytes: optionalKey(Natural)
+}).annotate({ description: "A ToolFile, such as the result of a download, passed unchanged; or its contentBase64 with an optional contentType and filename." });
+var signatures = [
+  ["image/jpeg", [[0, [
+    255,
+    216,
+    255
+  ]]]],
+  ["image/png", [[0, [
+    137,
+    80,
+    78,
+    71
+  ]]]],
+  ["image/gif", [[0, [
+    71,
+    73,
+    70,
+    56
+  ]]]],
+  ["image/webp", [[0, [
+    82,
+    73,
+    70,
+    70
+  ]], [8, [
+    87,
+    69,
+    66,
+    80
+  ]]]],
+  ["application/pdf", [[0, [
+    37,
+    80,
+    68,
+    70
+  ]]]],
+  ["application/zip", [[0, [
+    80,
+    75,
+    3,
+    4
+  ]]]]
+];
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function sniff(bytes) {
+  return pipe(findFirst(signatures, (signature) => every(signature[1], (part) => every(part[1], (byte, index) => bytes[part[0] + index] === byte))), map((signature) => signature[0]), orElse2(() => liftPredicate("text/plain", () => isSuccess(try_(() => utf8.decode(bytes))))), getOrNull);
+}
+function toolFile(bytes, declared, filename) {
+  return {
+    _tag: "ToolFile",
+    contentBase64: encode3(bytes),
+    contentType: declared === null || pipe(declared, startsWith("application/octet-stream")) ? sniff(bytes) ?? declared : declared,
+    filename,
+    sizeBytes: bytes.byteLength
+  };
+}
+function invalid(expected, value, options) {
+  return fail5(new InvalidValue({ expected }, value, options));
+}
+function decodeBytes(text, options) {
+  return match3(decode(pipe(text, replaceAll("+", "-"), replaceAll("/", "_"))), {
+    onFailure: () => invalid("a Base64 or Base64Url string", text, options),
+    onSuccess: (bytes) => succeed4(bytes)
+  });
+}
+function contentOf(carrier) {
+  return transformEffect((text, options) => {
+    if (carrier !== "data-uri")
+      return map3(decodeBytes(text, options), (bytes) => ({
+        bytes,
+        contentType: null
+      }));
+    return match2(pipe(text, match(/^data:([^;,]*)(?:;[^;,]*)*;base64,(.*)$/su)), {
+      onNone: () => invalid("a Base64 data URI", text, options),
+      onSome: (parts) => map3(decodeBytes(getUnsafe2(parts, 2), options), (bytes) => ({
+        bytes,
+        contentType: pipe(getUnsafe2(parts, 1), liftPredicate(isNonEmpty), getOrNull)
+      }))
+    });
+  });
+}
+function textOf(carrier, content) {
+  if (carrier === "base64")
+    return encode3(content.bytes);
+  if (carrier === "base64url")
+    return encode(content.bytes);
+  return `data:${content.contentType ?? sniff(content.bytes) ?? "application/octet-stream"};base64,${encode3(content.bytes)}`;
+}
+function fileFrom(carrier) {
+  return String3.pipe(decodeTo(Schema, {
+    decode: compose(contentOf(carrier), transform((content) => toolFile(content.bytes, content.contentType, null))),
+    encode: transformEffect((file, options) => map3(decodeBytes(file.contentBase64, options), (bytes) => textOf(carrier, {
+      bytes,
+      contentType: file.contentType
+    })))
+  }));
+}
+function encodedFrom(carrier) {
+  return File2.pipe(decodeTo(String3, {
+    decode: transform((file) => textOf(carrier, {
+      bytes: file.contentBase64,
+      contentType: file.contentType ?? null
+    })),
+    encode: compose(contentOf(carrier), transform((content) => ({
+      contentBase64: content.bytes,
+      contentType: content.contentType
+    })))
+  }));
+}
+var FileFromBase64 = fileFrom("base64");
+var FileFromBase64Url = fileFrom("base64url");
+var Base64FromFile = encodedFrom("base64");
+var Base64UrlFromFile = encodedFrom("base64url");
+var FileFromDataUri = fileFrom("data-uri");
+var DataUriFromFile = encodedFrom("data-uri");
+var DateTimeText = String3.annotate({ format: "date-time" });
+var rfc3339 = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.\d+)?(?:Z|([+-]\d{2}:\d{2}))$/u;
+function rfc3339Instant(text) {
+  return pipe(fromNullishOr(rfc3339.exec(text)), flatMap((match4) => filter(makeZoned(text, { timeZone: match4[2] ?? "+00:00" }), (zoned) => startsWith(match4[1] ?? "")(formatIsoOffset(zoned)))), map(toUtc));
+}
+function instants(wire, expected, read, write) {
+  const fromWire = transformEffect((value, options) => match2(read(value), {
+    onNone: () => invalid(expected, value, options),
+    onSome: (instant) => succeed4(formatIso(instant))
+  }));
+  const toWire = transformEffect((text, options) => match2(rfc3339Instant(text), {
+    onNone: () => invalid("an ISO 8601 date-time", text, options),
+    onSome: (instant) => succeed4(write(instant))
+  }));
+  return {
+    input: pipe(DateTimeText, decodeTo(wire, {
+      decode: toWire,
+      encode: fromWire
+    })),
+    output: pipe(wire, decodeTo(DateTimeText, {
+      decode: fromWire,
+      encode: toWire
+    }))
+  };
+}
+var unixSeconds = instants(Int, "Unix seconds", (seconds) => map(make4(seconds * 1000), toUtc), (instant) => Math.floor(toEpochMillis(instant) / 1000));
+var rfc2822 = instants(String3, "an RFC 2822 date-time", (text) => map(make4(text), toUtc), (instant) => toDateUtc(instant).toUTCString());
+var DateTimeFromUnixSeconds = unixSeconds.output;
+var UnixSecondsFromDateTime = unixSeconds.input;
+var DateTimeFromRfc2822 = rfc2822.output;
+var Rfc2822FromDateTime = rfc2822.input;
+var GraphqlResponse = Struct({
+  data: optionalKey(NullOr(Record(String3, Unknown))),
+  errors: optionalKey(ArraySchema(StructWithRest(Struct({ message: String3 }), [Record(String3, Unknown)])))
+});
+function coerce(value) {
+  return isObject(value) ? JSON.stringify(value) : `${value}`;
+}
+function filePart(bytes, name, contentType) {
+  return new globalThis.File([new Uint8Array(bytes)], name, { type: contentType });
+}
+function fileFailed(error) {
+  return ActionHandlerError.make({
+    cause: error,
+    message: error.message
+  });
+}
+function readFile(file) {
+  return pipe(read(file), mapError(fileFailed));
+}
+var withFile = fnUntraced(function* (request, file) {
+  return bodyUint8Array(request, yield* readFile(file), file.contentType);
+});
+var withForm = fnUntraced(function* (request, payload) {
+  return bodyFormDataRecord(request, fromEntries(yield* forEach(toEntries(payload), (field) => map3(forEach(filter2(ensure(field[1]), (item) => item !== undefined), (item) => gen2(function* () {
+    if (!is(File)(item))
+      return coerce(item);
+    return filePart(yield* readFile(item), item.name, item.contentType);
+  })), (parts) => [field[0], parts]))));
+});
+function dispositionName(header) {
+  if (header === undefined)
+    return;
+  const encoded = pipe(match(/(?:^|;)\s*filename\*\s*=\s*UTF-8'[^']*'([^;]+)/iu)(header), flatMap((match4) => fromUndefinedOr(match4[1])));
+  const decoded = pipe(encoded, flatMap((value) => liftThrowable(() => decodeURIComponent(trim(value)))()));
+  return getOrElse(decoded, () => pipe(match(/(?:^|;)\s*filename\s*=\s*(?:"((?:\\.|[^"\\])*)"|([^;]*))/iu)(header), flatMap((match4) => orElse2(map(fromUndefinedOr(match4[1]), (name) => replace(/\\(.)/gu, "$1")(name)), () => map(fromUndefinedOr(match4[2]), trim))), getOrUndefined));
+}
+var read2 = fnUntraced(function* (response, body) {
+  if (body === "json")
+    return yield* response.json;
+  if (body === "text")
+    return yield* response.text;
+  if (body === "void")
+    return {};
+  if (body === "unknown") {
+    const text = yield* response.text;
+    if (isEmpty(trim(text)))
+      return null;
+    return getOrElse(decodeOption(fromJsonString(Json))(text), () => text);
+  }
+  const bytes = new Uint8Array(yield* response.arrayBuffer);
+  const name = dispositionName(response.headers["content-disposition"]);
+  if (body === "file")
+    return yield* pipe(write({
+      bytes,
+      contentType: getOrNull(fromUndefinedOr(response.headers["content-type"])),
+      name: name ?? "file"
+    }), mapError(fileFailed));
+  return toolFile(bytes, response.headers["content-type"] ?? null, name ?? null);
+});
+
+// dist/TelegramDefinition.js
+var TelegramDefinition_exports = /* @__PURE__ */ __exportAll({
+  TelegramDefinition: () => TelegramDefinition_exports,
+  TelegramUpdateConfigV2: () => TelegramUpdateConfigV22,
+  TelegramUpdateV2: () => TelegramUpdateV22,
+  telegramAccessToken: () => telegramAccessToken2,
+  telegramPluginBase: () => telegramPluginBase2
+});
+var telegramAccessToken2 = AuthMethod_exports.make("access-token", {
+  description: "Authenticate with a Telegram bot access token obtained from @BotFather",
+  name: "Telegram access token",
+  schema: Struct({
+    accessToken: String3,
+    baseUrl: optional(String3)
+  })
+});
+var authMethods = [telegramAccessToken2];
+var ParseMode = Literals([
+  "Markdown",
+  "MarkdownV2",
+  "HTML"
+]);
+var ReplyMarkup = Unknown;
+var BoolResult = Boolean2;
+var chatGet = Action_exports.make("get", {
+  description: "Get up to date information about a chat",
+  name: "Get chat",
+  examples: [{
+    input: { chatId: "@mychannel" },
+    title: "Get a chat"
+  }],
+  input: Struct({ chatId: String3 }),
+  output: TelegramChat2
+});
+var chatAdministrators = Action_exports.make("administrators", {
+  description: "Get the administrators of a chat",
+  name: "Get chat administrators",
+  input: Struct({ chatId: String3 }),
+  output: ArraySchema(TelegramChatMember2)
+});
+var chatMember = Action_exports.make("member", {
+  description: "Get a member of a chat",
+  name: "Get chat member",
+  input: Struct({
+    chatId: String3,
+    userId: String3
+  }),
+  output: TelegramChatMember2
+});
+var chatLeave = Action_exports.make("leave", {
+  description: "Leave a group, supergroup or channel",
+  name: "Leave chat",
+  input: Struct({ chatId: String3 }),
+  output: BoolResult
+});
+var chatSetDescription = Action_exports.make("set-description", {
+  description: "Set the description of a chat",
+  name: "Set chat description",
+  input: Struct({
+    chatId: String3,
+    description: String3
+  }),
+  output: BoolResult
+});
+var chatSetTitle = Action_exports.make("set-title", {
+  description: "Set the title of a chat",
+  name: "Set chat title",
+  input: Struct({
+    chatId: String3,
+    title: String3
+  }),
+  output: BoolResult
+});
+var callbackAnswerQuery = Action_exports.make("answer-query", {
+  description: "Send an answer to a callback query sent from an inline keyboard",
+  name: "Answer query",
+  input: Struct({
+    cacheTime: optional(Number3),
+    queryId: String3,
+    showAlert: optional(Boolean2),
+    text: optional(String3),
+    url: optional(String3)
+  }),
+  output: BoolResult
+});
+var callbackAnswerInlineQuery = Action_exports.make("answer-inline-query", {
+  description: "Send an answer to a callback query sent from an inline bot",
+  name: "Answer inline query",
+  input: Struct({
+    cacheTime: optional(Number3),
+    queryId: String3,
+    results: Unknown
+  }),
+  output: BoolResult
+});
+var fileGet = Action_exports.make("get", {
+  description: "Get a file's metadata, including the download path under <baseUrl>/file/bot<token>/<file_path>",
+  name: "Get file",
+  input: Struct({ fileId: String3 }),
+  output: TelegramFile2
+});
+var messageDelete = Action_exports.make("delete-message", {
+  description: "Delete a chat message",
+  name: "Delete chat message",
+  input: Struct({
+    chatId: String3,
+    messageId: String3
+  }),
+  output: BoolResult
+});
+var messageEditText = Action_exports.make("edit-message-text", {
+  description: "Edit a text message, by chat+message id or by inline message id",
+  name: "Edit message text",
+  input: Struct({
+    chatId: optional(String3),
+    disableWebPagePreview: optional(Boolean2),
+    inlineMessageId: optional(String3),
+    messageId: optional(String3),
+    parseMode: optional(ParseMode),
+    replyMarkup: optional(ReplyMarkup),
+    text: String3
+  }),
+  output: Union([TelegramMessage2, Boolean2])
+});
+var messagePin = Action_exports.make("pin-chat-message", {
+  description: "Pin a chat message",
+  name: "Pin chat message",
+  input: Struct({
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    messageId: String3
+  }),
+  output: BoolResult
+});
+var messageUnpin = Action_exports.make("unpin-chat-message", {
+  description: "Unpin a chat message",
+  name: "Unpin chat message",
+  input: Struct({
+    chatId: String3,
+    messageId: String3
+  }),
+  output: BoolResult
+});
+var messageSend = Action_exports.make("send-message", {
+  description: "Send a text message",
+  name: "Send message",
+  examples: [{
+    input: {
+      chatId: "123456789",
+      text: "Hello!"
+    },
+    title: "Say hello"
+  }],
+  input: Struct({
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    disableWebPagePreview: optional(Boolean2),
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    text: String3
+  }),
+  output: TelegramMessage2
+});
+var messageSendAnimation = Action_exports.make("send-animation", {
+  description: "Send an animated file by file_id or HTTP URL",
+  name: "Send animation",
+  input: Struct({
+    animation: String3,
+    caption: optional(String3),
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    duration: optional(Number3),
+    height: optional(Number3),
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    thumb: optional(String3),
+    width: optional(Number3)
+  }),
+  output: TelegramMessage2
+});
+var messageSendAudio = Action_exports.make("send-audio", {
+  description: "Send an audio file by file_id or HTTP URL",
+  name: "Send audio",
+  input: Struct({
+    audio: String3,
+    caption: optional(String3),
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    duration: optional(Number3),
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    performer: optional(String3),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    thumb: optional(String3),
+    title: optional(String3)
+  }),
+  output: TelegramMessage2
+});
+var messageSendChatAction = Action_exports.make("send-chat-action", {
+  description: "Broadcast a chat action (typing, upload_photo, etc.)",
+  name: "Send chat action",
+  input: Struct({
+    action: Literals([
+      "typing",
+      "upload_photo",
+      "record_video",
+      "upload_video",
+      "record_audio",
+      "upload_audio",
+      "upload_document",
+      "find_location",
+      "record_video_note",
+      "upload_video_note"
+    ]),
+    chatId: String3,
+    messageThreadId: optional(Number3)
+  }),
+  output: BoolResult
+});
+var messageSendDocument = Action_exports.make("send-document", {
+  description: "Send a document by file_id or HTTP URL",
+  name: "Send document",
+  input: Struct({
+    caption: optional(String3),
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    document: String3,
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    thumb: optional(String3)
+  }),
+  output: TelegramMessage2
+});
+var messageSendLocation = Action_exports.make("send-location", {
+  description: "Send a point on the map",
+  name: "Send location",
+  input: Struct({
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    latitude: Number3,
+    longitude: Number3,
+    messageThreadId: optional(Number3),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3)
+  }),
+  output: TelegramMessage2
+});
+var messageSendMediaGroup = Action_exports.make("send-media-group", {
+  description: "Send a group of photos or videos as an album",
+  name: "Send media group",
+  input: Struct({
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    media: Unknown,
+    messageThreadId: optional(Number3),
+    replyToMessageId: optional(Number3)
+  }),
+  output: ArraySchema(TelegramMessage2)
+});
+var messageSendPhoto = Action_exports.make("send-photo", {
+  description: "Send a photo by file_id or HTTP URL",
+  name: "Send photo",
+  examples: [{
+    input: {
+      chatId: "123456789",
+      photo: "https://example.com/cat.jpg"
+    },
+    title: "Send a photo by URL"
+  }],
+  input: Struct({
+    caption: optional(String3),
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    photo: String3,
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3)
+  }),
+  output: TelegramMessage2
+});
+var messageSendSticker = Action_exports.make("send-sticker", {
+  description: "Send a sticker by file_id or HTTP URL",
+  name: "Send sticker",
+  input: Struct({
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    messageThreadId: optional(Number3),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    sticker: String3
+  }),
+  output: TelegramMessage2
+});
+var messageSendVideo = Action_exports.make("send-video", {
+  description: "Send a video by file_id or HTTP URL",
+  name: "Send video",
+  input: Struct({
+    caption: optional(String3),
+    chatId: String3,
+    disableNotification: optional(Boolean2),
+    duration: optional(Number3),
+    height: optional(Number3),
+    messageThreadId: optional(Number3),
+    parseMode: optional(ParseMode),
+    replyMarkup: optional(ReplyMarkup),
+    replyToMessageId: optional(Number3),
+    thumb: optional(String3),
+    video: String3,
+    width: optional(Number3)
+  }),
+  output: TelegramMessage2
+});
+var UPDATE_TYPES = [
+  "message",
+  "edited_message",
+  "channel_post",
+  "edited_channel_post",
+  "callback_query",
+  "inline_query",
+  "poll",
+  "pre_checkout_query",
+  "shipping_query"
+];
+var updateOutput = Struct({
+  callback_query: optional(Unknown),
+  channel_post: optional(Unknown),
+  edited_channel_post: optional(Unknown),
+  edited_message: optional(Unknown),
+  inline_query: optional(Unknown),
+  message: optional(Unknown),
+  poll: optional(Unknown),
+  pre_checkout_query: optional(Unknown),
+  shipping_query: optional(Unknown),
+  update_id: optional(Number3)
+});
+var updateState = Struct({ lastUpdateId: NullOr(Number3) });
+var updateStateV2 = Struct({
+  ...updateState.fields,
+  registrationUrl: optional(String3)
+});
+var hostedUpdateConfig = Struct({
+  chatIds: optional(ArraySchema(String3)),
+  secretToken: optional(String3.check(isPattern(/^[A-Za-z0-9_-]{1,256}$/u))),
+  updates: optional(ArraySchema(Literals([...UPDATE_TYPES]))),
+  userIds: optional(ArraySchema(String3))
+});
+var TelegramUpdateV22 = Struct({
+  ...updateOutput.fields,
+  chat_member: optionalKey(TelegramChatMemberUpdated),
+  message_reaction: optionalKey(TelegramMessageReactionUpdated),
+  message_reaction_count: optionalKey(TelegramMessageReactionCountUpdated),
+  my_chat_member: optionalKey(TelegramChatMemberUpdated),
+  update_id: Int
+});
+var TelegramUpdateConfigV22 = Struct({
+  ...hostedUpdateConfig.fields,
+  updates: optional(ArraySchema(Literals([
+    ...UPDATE_TYPES,
+    "my_chat_member",
+    "chat_member",
+    "message_reaction",
+    "message_reaction_count"
+  ])))
+});
+var updateTrigger = Trigger_exports.webhook("update", {
+  description: "Triggers on Telegram updates (messages, callback queries, inline queries, and more)",
+  name: "On update",
+  config: TelegramUpdateConfigV22,
+  output: TelegramUpdateV22,
+  state: updateStateV2
+});
+var telegramPluginBase2 = Plugin_exports.make("telegram").pipe(Plugin_exports.withName("Telegram"), Plugin_exports.withDescription("Telegram bot messaging, chats, files, callback queries and update triggers"), Plugin_exports.withCategories(["communication"]), Plugin_exports.withHomepageUrl("https://telegram.org"), Plugin_exports.withDocsUrl("https://core.telegram.org/bots/api"), Plugin_exports.withIconUrl("https://telegram.org/img/t_logo.png"), Plugin_exports.withAuthMethods(authMethods), Plugin_exports.add(Group_exports.make("chat").pipe(Group_exports.withName("Chat"), Group_exports.add(chatGet, chatAdministrators, chatMember, chatLeave, chatSetDescription, chatSetTitle)), Group_exports.make("callback").pipe(Group_exports.withName("Callback"), Group_exports.add(callbackAnswerQuery, callbackAnswerInlineQuery)), Group_exports.make("file").pipe(Group_exports.withName("File"), Group_exports.add(fileGet)), Group_exports.make("message").pipe(Group_exports.withName("Message"), Group_exports.add(messageDelete, messageEditText, messagePin, messageUnpin, messageSend, messageSendAnimation, messageSendAudio, messageSendChatAction, messageSendDocument, messageSendLocation, messageSendMediaGroup, messageSendPhoto, messageSendSticker, messageSendVideo)), updateTrigger));
+
+// dist/channel/telegram-bot-definition.js
+var userKey = String3.check(isPattern(/^[1-9][0-9]{0,15}$/u));
+var chatKey = String3.check(isPattern(/^-?[1-9][0-9]{0,15}$/u));
+var groupScope = String3.check(isPattern(/^-[1-9][0-9]{0,15}(?:\/[1-9][0-9]{0,15})?$/u));
+var telegramBotToken = AuthMethod_exports.make("bot-token", {
+  name: "Telegram bot token and webhook secret",
+  schema: Struct({
+    botToken: String3.check(isPattern(/^[0-9]+:[A-Za-z0-9_-]+$/u)),
+    webhookSecret: String3.check(isPattern(/^[A-Za-z0-9_-]{1,256}$/u))
+  })
+});
+var messagesDefinition = {
+  authMethods: [telegramBotToken],
+  definitionSettings: Record(String3, Never),
+  deploymentSettings: Struct({
+    chatIds: ArraySchema(groupScope).check(isMaxLength(1000)).annotate({
+      description: "Group chat IDs (-100\u2026), or one forum topic as <chat ID>/<topic ID>, where the Agent can be activated. Leave empty for every group the bot is in.",
+      title: "Groups and topics"
+    }),
+    directMessages: Boolean2.annotate({
+      description: "Whether people can activate the Agent in a private chat with the bot.",
+      title: "Direct messages"
+    }),
+    access: Literals(["open", "restricted"]).annotate({
+      description: "Who can activate the Agent: anyone who can message the bot (open) or only the allowed people (restricted).",
+      title: "Access"
+    }),
+    allowedSenderKeys: ArraySchema(userKey).check(isMaxLength(1000)).annotate({
+      description: "Numeric Telegram user IDs who can activate the Agent when access is restricted.",
+      title: "Allowed people"
+    }),
+    respondTo: Literals(["mentions", "all_messages"]).annotate({
+      description: "Which group messages activate the Agent: only mentions, commands and replies to the bot, or every message in the chosen groups. Private chats always do.",
+      title: "Respond to"
+    })
+  }),
+  exposure: "webhook",
+  features: {
+    assets: false,
+    deliveryMode: "at-most-once",
+    deliveryState: false,
+    directText: true,
+    groups: true,
+    maxTextLength: 4096,
+    mentions: true,
+    operations: [
+      "present_outcome",
+      "create_message",
+      "update_message",
+      "delete_message",
+      "set_reaction",
+      "set_activity"
+    ],
+    readContext: false,
+    replies: true,
+    threads: true
+  },
+  requiredChecks: ["access"],
+  state: Struct({
+    botId: userKey,
+    botUsername: NonEmptyString,
+    ingressUrl: String3,
+    registrationUrl: String3
+  })
+};
+var messagesChannel = AgentChannel_exports.make("messages", {
+  ...messagesDefinition,
+  description: "Telegram bot text messages in private chats and addressed groups, including forum topics.",
+  name: "Telegram bot messages"
+});
+var telegramBotPluginBase = Plugin_exports.make("telegram").pipe(Plugin_exports.withName("Telegram Bot"), Plugin_exports.withDescription("A customer's Telegram bot, with its own token and webhook secret."), Plugin_exports.withAuthMethods([telegramBotToken]), Plugin_exports.withAgentChannel(messagesChannel));
+
+// dist/definition.js
+var telegramPluginBase3 = telegramPluginBase2.pipe(Plugin_exports.withAuthMethod(telegramBotToken), Plugin_exports.withAgentChannel(messagesChannel));
+export { TelegramDefinition_exports, telegramAccessToken2, TelegramUpdateV22, TelegramUpdateConfigV22, telegramPluginBase2, userKey, chatKey, telegramBotToken, messagesChannel, telegramBotPluginBase, telegramPluginBase3 };
+
+//# debugId=8B62337D34DCDDBD64756E2164756E21
+//# sourceMappingURL=index-pm1rw9n0.js.map