@omelhorsite/sdk 0.16.0 → 0.18.0

package/dist/index.js

@@ -951,7 +951,10 @@ var OMS_SCOPES = [
   "news:read",
   "news:write",
   "cron:read",
-  "cron:write"
+  "cron:write",
+  "cron:run",
+  "bots:read",
+  "bots:write"
 ];
 var DEFAULT_REFRESH_SKEW_MS = 60000;
 var REFRESH_REUSE_WINDOW_MS = 5000;
@@ -10483,6 +10486,8 @@ function modelBody(input) {
     body["capabilities"] = { ...input.capabilities };
   if (input.limits !== undefined)
     body["limits"] = { ...input.limits };
+  if (input.metadata !== undefined)
+    body["metadata"] = { ...input.metadata };
   return body;
 }
 function assignmentBody(input) {
@@ -10516,6 +10521,12 @@ class AdminLlmProvidersNamespace extends Resource {
   async availableModels(id, input = {}, options = {}) {
     return this.http.get(`/admin/llm_providers/${encodeURIComponent(id)}/available_models`, { ...input.fresh ? { query: { fresh: 1 } } : {}, ...options });
   }
+  async modelEndpoints(id, input, options = {}) {
+    return this.http.get(`/admin/llm_providers/${encodeURIComponent(id)}/model_endpoints`, {
+      ...options,
+      query: { model_id: input.modelId, ...input.fresh ? { fresh: 1 } : {} }
+    });
+  }
   async test(id, input = {}, options = {}) {
     const body = {};
     if (input.modelId !== undefined)
@@ -11423,6 +11434,8 @@ function feedBody(input) {
     body["retention_days"] = input.retentionDays;
   if (input.enabled !== undefined)
     body["enabled"] = input.enabled;
+  if (input.includedFeedIds !== undefined)
+    body["included_feed_ids"] = [...input.includedFeedIds];
   return body;
 }
 
@@ -11457,6 +11470,17 @@ class NewsItemsNamespace extends Resource {
   async get(id, options = {}) {
     return this.http.get(`/news_items/${encodeURIComponent(id)}`, options);
   }
+  async similar(params, options = {}) {
+    const query = {
+      text: params.text,
+      item_id: params.itemId,
+      news_feed_id: params.feedId,
+      limit: params.limit,
+      since: params.since,
+      max_distance: params.maxDistance
+    };
+    return this.http.get("/news_items/similar", { ...options, query });
+  }
   async delete(id, options = {}) {
     await this.http.delete(`/news_items/${encodeURIComponent(id)}`, options);
   }
@@ -11496,7 +11520,7 @@ class NewsScriptsNamespace extends Resource {
 // src/resources/content/news/sources.ts
 var NEWS_SOURCE_HEALTHS = ["unknown", "ok", "error"];
 var NEWS_SOURCE_DISABLE_AFTER_FAILURES = 20;
-var NEWS_SOURCE_FILTER_COLUMNS = Object.freeze(["name", "health", "enabled", "news_feed_id", "news_script_id"]);
+var NEWS_SOURCE_FILTER_COLUMNS = Object.freeze(["name", "health", "enabled", "news_feed_id", "news_script_id", "cron_job_id"]);
 
 class NewsSourcesNamespace extends Resource {
   async list(params = {}, options = {}) {
@@ -11506,7 +11530,8 @@ class NewsSourcesNamespace extends Resource {
         health: params.health,
         enabled: params.enabled,
         news_feed_id: params.feedId,
-        news_script_id: params.scriptId
+        news_script_id: params.scriptId,
+        cron_job_id: params.jobId
       }
     };
     return paginate(params, 100, (at) => this.http.get("/news_sources", { ...options, query: listQuery(params, at, base) }));
@@ -11517,7 +11542,8 @@ class NewsSourcesNamespace extends Resource {
   async create(input, options = {}) {
     return this.http.post("/news_sources", {
       name: input.name,
-      news_script_id: input.scriptId,
+      ...input.scriptId === undefined ? {} : { news_script_id: input.scriptId },
+      ...input.jobId === undefined ? {} : { cron_job_id: input.jobId },
       ...input.newsFeedId === undefined ? {} : { news_feed_id: input.newsFeedId },
       ...input.config === undefined ? {} : { config: input.config },
       ...input.pollIntervalMinutes === undefined ? {} : { poll_interval_minutes: input.pollIntervalMinutes },
@@ -11529,6 +11555,7 @@ class NewsSourcesNamespace extends Resource {
       ...input.name === undefined ? {} : { name: input.name },
       ...input.newsFeedId === undefined ? {} : { news_feed_id: input.newsFeedId },
       ...input.scriptId === undefined ? {} : { news_script_id: input.scriptId },
+      ...input.jobId === undefined ? {} : { cron_job_id: input.jobId },
       ...input.config === undefined ? {} : { config: input.config },
       ...input.pollIntervalMinutes === undefined ? {} : { poll_interval_minutes: input.pollIntervalMinutes },
       ...input.enabled === undefined ? {} : { enabled: input.enabled },
@@ -11538,6 +11565,13 @@ class NewsSourcesNamespace extends Resource {
   async delete(id, options = {}) {
     await this.http.delete(`/news_sources/${encodeURIComponent(id)}`, options);
   }
+  async test(input, options = {}) {
+    return this.http.post("/news_sources/test", {
+      ...input.scriptId === undefined ? {} : { news_script_id: input.scriptId },
+      ...input.jobId === undefined ? {} : { cron_job_id: input.jobId },
+      config: input.config ?? {}
+    }, { retry: false, ...options });
+  }
   async run(id, options = {}) {
     return this.http.post(`/news_sources/${encodeURIComponent(id)}/run`, undefined, { retry: false, ...options });
   }
@@ -11556,6 +11590,9 @@ class NewsNamespace extends Resource {
     this.scripts = new NewsScriptsNamespace(http);
     this.items = new NewsItemsNamespace(http);
   }
+  async discover(url, options = {}) {
+    return this.http.get("/news/discover", { ...options, query: { url } });
+  }
 }
 
 // src/resources/content/jokes.ts
@@ -11629,6 +11666,8 @@ var NOTIFICATION_KINDS = [
   "news_source_failing",
   "cron_run_failed",
   "cron_run_done",
+  "bot_message_received",
+  "bot_needs_human",
   "oauth_application_approved",
   "oauth_application_rejected",
   "admin_oauth_application_submitted",
@@ -11777,20 +11816,27 @@ var CRON_JOB_SCOPES = Object.freeze([
   "tools:read",
   "tools:write",
   "blogs:read",
-  "blogs:write"
+  "blogs:write",
+  "bots:read",
+  "bots:write",
+  "cron:run"
 ]);
 var CRON_JOB_HEALTHS = Object.freeze(["unknown", "ok", "error"]);
+var CRON_JOB_RUNTIMES = Object.freeze(["sandbox", "full"]);
 var CRON_JOB_DISABLE_AFTER_FAILURES = 10;
 var CRON_JOB_MAX_CODE_BYTES = 256 * 1024;
 var CRON_JOB_MAX_STATE_BYTES = 256 * 1024;
 var CRON_JOB_MAX_CONFIG_BYTES = 64 * 1024;
 var CRON_JOB_MIN_INTERVAL_MINUTES = 5;
+var CRON_SCHEDULES_MAX_PER_JOB = 200;
 var CRON_JOB_MIN_TIMEOUT_SECONDS = 5;
 var CRON_JOB_MAX_TIMEOUT_SECONDS = 1200;
 var CRON_JOB_BASE_MAX_TIMEOUT_SECONDS = 120;
+var CRON_VAR_TYPES = Object.freeze(["string", "text", "number", "boolean", "list", "json"]);
+var CRON_SCHEDULE_FILTER_COLUMNS = Object.freeze(["cron_job_id", "enabled"]);
 var CRON_JOB_FILTER_COLUMNS = Object.freeze(["name", "enabled", "health", "template_slug"]);
 var CRON_RUN_STATUSES = Object.freeze(["queued", "running", "ok", "error", "timeout", "skipped"]);
-var CRON_RUN_TRIGGERS = Object.freeze(["schedule", "manual", "test"]);
+var CRON_RUN_TRIGGERS = Object.freeze(["schedule", "manual", "api", "job", "test"]);
 var CRON_RUN_FILTER_COLUMNS = Object.freeze(["cron_job_id", "status", "trigger"]);
 
 class CronJobsNamespace extends Resource {
@@ -11810,17 +11856,36 @@ class CronJobsNamespace extends Resource {
   async delete(id, options = {}) {
     await this.http.delete(`/cron_jobs/${encodeURIComponent(id)}`, options);
   }
-  async run(id, options = {}) {
-    return this.http.post(`/cron_jobs/${encodeURIComponent(id)}/run`, {}, { retry: false, ...options });
+  async run(id, input = {}, options = {}) {
+    return this.http.post(`/cron_jobs/${encodeURIComponent(id)}/run`, runBody(input), { retry: false, ...options });
   }
-  async test(id, options = {}) {
-    return this.http.post(`/cron_jobs/${encodeURIComponent(id)}/test`, {}, { retry: false, ...options });
+  async test(id, input = {}, options = {}) {
+    return this.http.post(`/cron_jobs/${encodeURIComponent(id)}/test`, runBody(input), { retry: false, ...options });
   }
   async check(code, options = {}) {
     return this.http.post("/cron_jobs/check", { code }, options);
   }
 }
 
+class CronSchedulesNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "created_at:asc", exactSearch: { cron_job_id: params.jobId, enabled: params.enabled } };
+    return paginate(params, 50, (at) => this.http.get("/cron_schedules", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/cron_schedules/${encodeURIComponent(id)}`, options);
+  }
+  async create(input, options = {}) {
+    return this.http.post("/cron_schedules", { cron_job_id: input.jobId, ...scheduleBody(input) }, { retry: false, ...options });
+  }
+  async update(id, input, options = {}) {
+    return this.http.patch(`/cron_schedules/${encodeURIComponent(id)}`, scheduleBody(input), options);
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/cron_schedules/${encodeURIComponent(id)}`, options);
+  }
+}
+
 class CronRunsNamespace extends Resource {
   async list(params = {}, options = {}) {
     const base = { order: "created_at:desc", exactSearch: { cron_job_id: params.jobId, status: params.status } };
@@ -11842,18 +11907,130 @@ class CronTemplatesNamespace extends Resource {
     return this.http.get(`/cron_templates/${encodeURIComponent(slug)}`, options);
   }
 }
+var CRON_RECORD_COLLECTION_MAX = 64;
+var CRON_RECORD_KEY_MAX = 200;
+var CRON_RECORD_MAX_DATA_BYTES = 64 * 1024;
+var CRON_RECORD_MAX_PER_JOB = 200000;
+var CRON_RECORD_MAX_PER_BATCH = 500;
+var CRON_RECORD_MAX_PER_DELETE = 1e4;
+var CRON_RECORD_MAX_WHERE = 5;
+var CRON_RECORD_MAX_LIMIT = 500;
+async function cronRecordKey(value) {
+  if (value.length <= CRON_RECORD_KEY_MAX)
+    return value;
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle)
+    throw new TypeError("A key past 200 characters needs WebCrypto to shorten. Pass a shorter key on a runtime without it.");
+  const bytes = new Uint8Array(await subtle.digest("SHA-256", new TextEncoder().encode(value)));
+  let hex = "";
+  for (const byte of bytes)
+    hex += byte.toString(16).padStart(2, "0");
+  return `${value.slice(0, CRON_RECORD_KEY_MAX - 33)}#${hex.slice(0, 32)}`;
+}
+
+class CronRecordsNamespace extends Resource {
+  async list(jobId, params, options = {}) {
+    return this.http.get(`/cron_jobs/${encodeURIComponent(jobId)}/records`, {
+      ...options,
+      query: await listRecordsQuery(params)
+    });
+  }
+  async* all(jobId, collection, params = {}, options = {}) {
+    let cursor = null;
+    for (;; ) {
+      const page = await this.list(jobId, { ...params, collection, cursor }, options);
+      for (const record of page.records)
+        yield record;
+      if (!page.next_cursor)
+        return;
+      cursor = page.next_cursor;
+    }
+  }
+  async get(jobId, collection, key, options = {}) {
+    const page = await this.list(jobId, { collection, keys: [key], limit: 1 }, options);
+    return page.records[0] ?? null;
+  }
+  async put(jobId, collection, key, data = {}, at, options = {}) {
+    return this.putMany(jobId, [{ collection, key, data, at }], options);
+  }
+  async putMany(jobId, records, options = {}) {
+    const total = { created: 0, updated: 0 };
+    for (let from = 0;from < records.length; from += CRON_RECORD_MAX_PER_BATCH) {
+      const chunk = await Promise.all(records.slice(from, from + CRON_RECORD_MAX_PER_BATCH).map(recordBody));
+      const answer = await this.http.post(`/cron_jobs/${encodeURIComponent(jobId)}/records`, { records: chunk }, { retry: false, ...options });
+      total.created += answer.created;
+      total.updated += answer.updated;
+    }
+    return total;
+  }
+  async remove(jobId, collection, key, options = {}) {
+    return this.http.delete(`/cron_jobs/${encodeURIComponent(jobId)}/records`, {
+      ...options,
+      query: { collection, key: await cronRecordKey(key) }
+    });
+  }
+  async removeMany(jobId, collection, keys, options = {}) {
+    return this.http.delete(`/cron_jobs/${encodeURIComponent(jobId)}/records`, {
+      ...options,
+      query: { collection, keys: await Promise.all(keys.map(cronRecordKey)) }
+    });
+  }
+  async prune(jobId, collection, options, requestOptions = {}) {
+    return this.http.delete(`/cron_jobs/${encodeURIComponent(jobId)}/records`, {
+      ...requestOptions,
+      query: { collection, before: asIso(options.before), on: options.on }
+    });
+  }
+  async collections(jobId, options = {}) {
+    return this.http.get(`/cron_jobs/${encodeURIComponent(jobId)}/records/collections`, options);
+  }
+  for(jobId) {
+    return {
+      list: (params, options) => this.list(jobId, params, options),
+      all: (collection, params, options) => this.all(jobId, collection, params, options),
+      get: (collection, key, options) => this.get(jobId, collection, key, options),
+      put: (collection, key, data, at, options) => this.put(jobId, collection, key, data, at, options),
+      putMany: (records, options) => this.putMany(jobId, records, options),
+      remove: (collection, key, options) => this.remove(jobId, collection, key, options),
+      removeMany: (collection, keys, options) => this.removeMany(jobId, collection, keys, options),
+      prune: (collection, options, requestOptions) => this.prune(jobId, collection, options, requestOptions),
+      collections: (options) => this.collections(jobId, options)
+    };
+  }
+}
 
 class CronNamespace extends Resource {
   jobs;
+  schedules;
   runs;
   templates;
+  records;
   constructor(http) {
     super(http);
     this.jobs = new CronJobsNamespace(http);
+    this.schedules = new CronSchedulesNamespace(http);
     this.runs = new CronRunsNamespace(http);
     this.templates = new CronTemplatesNamespace(http);
+    this.records = new CronRecordsNamespace(http);
   }
 }
+function scheduleBody(input) {
+  const body = {};
+  if (input.cron !== undefined)
+    body["cron"] = input.cron;
+  if (input.timezone !== undefined)
+    body["timezone"] = input.timezone;
+  if (input.name !== undefined)
+    body["name"] = input.name;
+  if (input.params !== undefined)
+    body["params"] = input.params;
+  if (input.enabled !== undefined)
+    body["enabled"] = input.enabled;
+  return body;
+}
+function runBody(input) {
+  return input.params === undefined ? {} : { params: input.params };
+}
 function jobBody(input) {
   const body = {};
   if (input.name !== undefined)
@@ -11868,6 +12045,8 @@ function jobBody(input) {
     body["code"] = input.code;
   if (input.scopes !== undefined)
     body["scopes"] = [...input.scopes];
+  if (input.output !== undefined)
+    body["output"] = input.output;
   if (input.config !== undefined)
     body["config"] = input.config;
   if (input.secrets !== undefined)
@@ -11890,6 +12069,266 @@ function jobBody(input) {
     body["template_slug"] = input.templateSlug;
   return body;
 }
+async function listRecordsQuery(params) {
+  const query = { collection: params.collection };
+  if (params.limit !== undefined)
+    query["limit"] = params.limit;
+  if (params.cursor)
+    query["cursor"] = params.cursor;
+  if (params.since !== undefined)
+    query["since"] = asIso(params.since);
+  if (params.until !== undefined)
+    query["until"] = asIso(params.until);
+  if (params.keys !== undefined)
+    query["keys"] = await Promise.all(params.keys.map(cronRecordKey));
+  if (params.where !== undefined)
+    query["where"] = params.where;
+  if (params.order !== undefined)
+    query["order"] = params.order;
+  if (params.count)
+    query["count"] = true;
+  return query;
+}
+async function recordBody(input) {
+  return {
+    collection: input.collection,
+    key: await cronRecordKey(input.key),
+    data: input.data ?? {},
+    ...input.at === undefined || input.at === null ? {} : { at: asIso(input.at) }
+  };
+}
+function asIso(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+// src/resources/bots.ts
+var BOT_CHANNEL_KINDS = Object.freeze(["telegram"]);
+var BOT_CHANNEL_HEALTHS = Object.freeze(["unknown", "ok", "error"]);
+var BOT_PLUGINS = Object.freeze(["inbox", "responder"]);
+var BOT_MESSAGE_MAX_TEXT = 4096;
+var BOT_CHANNEL_FILTER_COLUMNS = Object.freeze(["name", "kind", "enabled"]);
+var BOT_CONTACT_KINDS = Object.freeze(["private", "group", "supergroup", "channel"]);
+var BOT_CONTACT_FILTER_COLUMNS = Object.freeze(["bot_channel_id", "external_id", "username", "kind", "blocked"]);
+var BOT_MESSAGE_FILTER_COLUMNS = Object.freeze(["bot_channel_id", "bot_contact_id", "direction", "source"]);
+var BOT_FACT_FILTER_COLUMNS = Object.freeze(["bot_channel_id", "source", "bot_contact_id"]);
+var BOT_SOURCE_FILTER_COLUMNS = Object.freeze(["bot_channel_id"]);
+var BOT_RUN_FILTER_COLUMNS = Object.freeze(["bot_channel_id", "status", "trigger"]);
+function responderBody(input) {
+  const body = {};
+  for (const key of ["enabled", "system_prompt", "knowledge", "signature", "model", "slots_per_day", "window_start", "window_end", "timezone", "history_limit", "language"]) {
+    if (input[key] !== undefined)
+      body[key] = input[key];
+  }
+  return body;
+}
+function channelBody(input) {
+  const body = {};
+  if (input.name !== undefined)
+    body["name"] = input.name;
+  if (input.token !== undefined)
+    body["token"] = input.token;
+  if (input.kind !== undefined)
+    body["kind"] = input.kind;
+  if (input.plugin !== undefined)
+    body["plugin"] = input.plugin;
+  if (input.enabled !== undefined)
+    body["enabled"] = input.enabled;
+  return body;
+}
+
+class BotChannelsNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "created_at:asc" };
+    return paginate(params, 50, (at) => this.http.get("/bot_channels", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_channels/${encodeURIComponent(id)}`, options);
+  }
+  async create(input, options = {}) {
+    return this.http.post("/bot_channels", channelBody(input), { retry: false, ...options });
+  }
+  async update(id, input, options = {}) {
+    return this.http.patch(`/bot_channels/${encodeURIComponent(id)}`, channelBody(input), { retry: false, ...options });
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/bot_channels/${encodeURIComponent(id)}`, options);
+  }
+  async test(id, options = {}) {
+    return this.http.post(`/bot_channels/${encodeURIComponent(id)}/test`, {}, { retry: false, ...options });
+  }
+}
+
+class BotContactsNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "last_message_at:desc", exactSearch: { bot_channel_id: params.channelId } };
+    return paginate(params, 50, (at) => this.http.get("/bot_contacts", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_contacts/${encodeURIComponent(id)}`, options);
+  }
+  async update(id, input, options = {}) {
+    const body = {};
+    if (input.name !== undefined)
+      body["name"] = input.name;
+    if (input.tags !== undefined)
+      body["tags"] = [...input.tags];
+    if (input.needs_human !== undefined)
+      body["needs_human"] = input.needs_human;
+    if (input.note !== undefined)
+      body["note"] = input.note;
+    return this.http.patch(`/bot_contacts/${encodeURIComponent(id)}`, body, options);
+  }
+  async markRead(id, options = {}) {
+    return this.http.post(`/bot_contacts/${encodeURIComponent(id)}/read`, {}, options);
+  }
+  async botReply(id, options = {}) {
+    return this.http.post(`/bot_contacts/${encodeURIComponent(id)}/bot_reply`, {}, { retry: false, ...options });
+  }
+  async teach(id, hint, options = {}) {
+    return this.http.post(`/bot_contacts/${encodeURIComponent(id)}/teach`, { hint }, { retry: false, ...options });
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/bot_contacts/${encodeURIComponent(id)}`, options);
+  }
+}
+
+class BotMessagesNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "sent_at:desc", exactSearch: { bot_contact_id: params.contactId, bot_channel_id: params.channelId } };
+    return paginate(params, 100, (at) => this.http.get("/bot_messages", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_messages/${encodeURIComponent(id)}`, options);
+  }
+  async send(input, options = {}) {
+    const body = { text: input.text };
+    if (input.contactId !== undefined)
+      body["bot_contact_id"] = input.contactId;
+    if (input.channelId !== undefined)
+      body["bot_channel_id"] = input.channelId;
+    if (input.externalId !== undefined)
+      body["external_id"] = input.externalId;
+    if (input.format !== undefined)
+      body["format"] = input.format;
+    return this.http.post("/bot_messages", body, { retry: false, ...options });
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/bot_messages/${encodeURIComponent(id)}`, options);
+  }
+}
+
+class BotRespondersNamespace extends Resource {
+  async get(channelId, options = {}) {
+    return this.http.get(`/bot_channels/${encodeURIComponent(channelId)}/responder`, options);
+  }
+  async update(channelId, input, options = {}) {
+    return this.http.patch(`/bot_channels/${encodeURIComponent(channelId)}/responder`, responderBody(input), { retry: false, ...options });
+  }
+  async run(channelId, options = {}) {
+    return this.http.post(`/bot_channels/${encodeURIComponent(channelId)}/responder/run`, {}, { retry: false, ...options });
+  }
+}
+
+class BotOwnerChatNamespace extends Resource {
+  async get(channelId, options = {}) {
+    return this.http.get(`/bot_channels/${encodeURIComponent(channelId)}/owner_chat`, options);
+  }
+  async send(channelId, message, options = {}) {
+    return this.http.post(`/bot_channels/${encodeURIComponent(channelId)}/owner_chat`, { message }, { retry: false, ...options });
+  }
+}
+
+class BotFactsNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "created_at:desc", exactSearch: { bot_channel_id: params.channelId } };
+    return paginate(params, 100, (at) => this.http.get("/bot_facts", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_facts/${encodeURIComponent(id)}`, options);
+  }
+  async create(input, options = {}) {
+    const body = { bot_channel_id: input.channelId, text: input.text };
+    if (input.valid_from !== undefined)
+      body["valid_from"] = input.valid_from;
+    if (input.valid_until !== undefined)
+      body["valid_until"] = input.valid_until;
+    return this.http.post("/bot_facts", body, { retry: false, ...options });
+  }
+  async update(id, input, options = {}) {
+    const body = {};
+    if (input.text !== undefined)
+      body["text"] = input.text;
+    if (input.valid_from !== undefined)
+      body["valid_from"] = input.valid_from;
+    if (input.valid_until !== undefined)
+      body["valid_until"] = input.valid_until;
+    return this.http.patch(`/bot_facts/${encodeURIComponent(id)}`, body, { retry: false, ...options });
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/bot_facts/${encodeURIComponent(id)}`, options);
+  }
+}
+
+class BotSourcesNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "created_at:asc", exactSearch: { bot_channel_id: params.channelId } };
+    return paginate(params, 100, (at) => this.http.get("/bot_sources", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_sources/${encodeURIComponent(id)}`, options);
+  }
+  async create(input, options = {}) {
+    const body = { bot_channel_id: input.channelId, name: input.name, url: input.url };
+    if (input.description !== undefined)
+      body["description"] = input.description;
+    return this.http.post("/bot_sources", body, { retry: false, ...options });
+  }
+  async update(id, input, options = {}) {
+    const body = {};
+    if (input.name !== undefined)
+      body["name"] = input.name;
+    if (input.url !== undefined)
+      body["url"] = input.url;
+    if (input.description !== undefined)
+      body["description"] = input.description;
+    return this.http.patch(`/bot_sources/${encodeURIComponent(id)}`, body, { retry: false, ...options });
+  }
+  async delete(id, options = {}) {
+    await this.http.delete(`/bot_sources/${encodeURIComponent(id)}`, options);
+  }
+}
+
+class BotResponderRunsNamespace extends Resource {
+  async list(params = {}, options = {}) {
+    const base = { order: "scheduled_at:desc", exactSearch: { bot_channel_id: params.channelId } };
+    return paginate(params, 50, (at) => this.http.get("/bot_responder_runs", { ...options, query: listQuery(params, at, base) }));
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/bot_responder_runs/${encodeURIComponent(id)}`, options);
+  }
+}
+
+class BotsNamespace extends Resource {
+  channels;
+  contacts;
+  messages;
+  responders;
+  ownerChat;
+  facts;
+  sources;
+  runs;
+  constructor(http) {
+    super(http);
+    this.channels = new BotChannelsNamespace(http);
+    this.contacts = new BotContactsNamespace(http);
+    this.messages = new BotMessagesNamespace(http);
+    this.responders = new BotRespondersNamespace(http);
+    this.ownerChat = new BotOwnerChatNamespace(http);
+    this.facts = new BotFactsNamespace(http);
+    this.sources = new BotSourcesNamespace(http);
+    this.runs = new BotResponderRunsNamespace(http);
+  }
+}
 
 // src/resources/shortLinks.ts
 var SHORT_LINK_BASE_URL = "https://omelhor.site";
@@ -15311,16 +15750,22 @@ class StorageNamespace extends Resource {
     }
   }
   async fetchObject(url, options) {
-    const response = await this.transport(url, {
-      method: "GET",
-      ...options.signal ? { signal: options.signal } : {},
-      credentials: "omit",
-      redirect: "follow"
-    });
-    if (!response.ok) {
-      throw new OmsApiError(`Object storage refused the download (${response.status}). A signed URL is good for six hours; ask for a fresh one if it expired.`, { status: response.status, method: "GET", url, attempts: 1 });
+    let last = null;
+    for (let attempt = 1;attempt <= 3; attempt++) {
+      const response = await this.transport(url, {
+        method: "GET",
+        ...options.signal ? { signal: options.signal } : {},
+        credentials: "omit",
+        redirect: "follow"
+      });
+      if (response.ok)
+        return response;
+      last = response;
+      if (response.status < 500 || attempt === 3)
+        break;
+      await new Promise((resolve) => setTimeout(resolve, attempt * 500));
     }
-    return response;
+    throw new OmsApiError(`Object storage refused the download (${last?.status}). A signed URL is good for six hours; ask for a fresh one if it expired.`, { status: last?.status ?? 0, method: "GET", url, attempts: 3 });
   }
 }
 function cacheKey(parentId, name) {
@@ -15820,6 +16265,42 @@ function withId(answer, id) {
   return { ...answer ?? {}, id };
 }
 
+// src/resources/tools/imageGeneration.ts
+class ImageGenerationNamespace extends Resource {
+  jobs = new JobsNamespace(this.http);
+  async models(options = {}) {
+    const body = await this.http.get("/image_generations/models", options);
+    return body.models;
+  }
+  async create(input, options = {}) {
+    return this.http.post("/image_generations", {
+      prompt: input.prompt,
+      ...input.model === undefined ? {} : { model: input.model },
+      ...input.negativePrompt === undefined ? {} : { negative_prompt: input.negativePrompt },
+      ...input.width === undefined ? {} : { width: input.width },
+      ...input.height === undefined ? {} : { height: input.height },
+      ...input.steps === undefined ? {} : { steps: input.steps },
+      ...input.seed === undefined ? {} : { seed: input.seed },
+      ...input.guidance === undefined ? {} : { guidance: input.guidance },
+      ...toolCaptchaFields(input)
+    }, { ...options, retry: options.retry ?? false });
+  }
+  async get(id, options = {}) {
+    return this.http.get(`/image_generations/${encodeURIComponent(id)}`, options);
+  }
+  async run(input, options = {}) {
+    const created = await this.create(input, options);
+    return awaitToolJob(this.jobs, created, (request) => this.get(created.id, request), options, "the image generation");
+  }
+  async download(id, options = {}) {
+    const record = await this.get(id, options);
+    return fetchToolArtifact(this.http, this.resultUrl(record), options);
+  }
+  resultUrl(record) {
+    return requireToolArtifact(record, record.result_url, "result");
+  }
+}
+
 // src/resources/tools/jumpstyle.ts
 var JUMPSTYLE_DENSITIES = Object.freeze([
   "chill",
@@ -16104,6 +16585,7 @@ async function awaitToolJob(jobs2, created, reread, options, label) {
 class ToolsNamespace extends Resource {
   backgroundRemoval;
   upscale;
+  imageGeneration;
   transcription;
   vocalSeparation;
   captions;
@@ -16114,6 +16596,7 @@ class ToolsNamespace extends Resource {
     super(http);
     this.backgroundRemoval = new BackgroundRemovalNamespace(http);
     this.upscale = new UpscaleNamespace(http);
+    this.imageGeneration = new ImageGenerationNamespace(http);
     this.transcription = new TranscriptionNamespace(http);
     this.vocalSeparation = new VocalSeparationNamespace(http);
     this.captions = new CaptionsNamespace(http);
@@ -16152,6 +16635,7 @@ class Oms {
   search;
   llm;
   cron;
+  bots;
   realtime;
   local = local;
   constructor(options = {}) {
@@ -16199,6 +16683,7 @@ class Oms {
     this.search = new SearchNamespace(this.http);
     this.llm = new LlmNamespace(this.http);
     this.cron = new CronNamespace(this.http);
+    this.bots = new BotsNamespace(this.http);
   }
   get baseUrl() {
     return this.http.baseUrl;
@@ -16333,6 +16818,7 @@ export {
   src_default as default,
   decodeIdToken,
   dataUrlFromFile,
+  cronRecordKey,
   createPage,
   createDeadline,
   counterpart,
@@ -16589,6 +17075,7 @@ export {
   JAM_SKIP_MODES,
   JAM_QUEUE_MODES,
   IpLookupNamespace,
+  ImageGenerationNamespace,
   INTERNAL_SERVICE_SLUGS,
   IDENTITY_PROVIDERS,
   GroupChatsNamespace,
@@ -16636,17 +17123,31 @@ export {
   DEFAULT_BATCH_SIZE,
   DEFAULT_BASE_URL,
   CronTemplatesNamespace,
+  CronSchedulesNamespace,
   CronRunsNamespace,
+  CronRecordsNamespace,
   CronNamespace,
   CronJobsNamespace,
   ContentNamespace,
   ChestsNamespace,
   ChestEntriesNamespace,
   CaptionsNamespace,
+  CRON_VAR_TYPES,
+  CRON_SCHEDULE_FILTER_COLUMNS,
+  CRON_SCHEDULES_MAX_PER_JOB,
   CRON_RUN_TRIGGERS,
   CRON_RUN_STATUSES,
   CRON_RUN_FILTER_COLUMNS,
+  CRON_RECORD_MAX_WHERE,
+  CRON_RECORD_MAX_PER_JOB,
+  CRON_RECORD_MAX_PER_DELETE,
+  CRON_RECORD_MAX_PER_BATCH,
+  CRON_RECORD_MAX_LIMIT,
+  CRON_RECORD_MAX_DATA_BYTES,
+  CRON_RECORD_KEY_MAX,
+  CRON_RECORD_COLLECTION_MAX,
   CRON_JOB_SCOPES,
+  CRON_JOB_RUNTIMES,
   CRON_JOB_MIN_TIMEOUT_SECONDS,
   CRON_JOB_MIN_INTERVAL_MINUTES,
   CRON_JOB_MAX_TIMEOUT_SECONDS,
@@ -16664,11 +17165,31 @@ export {
   CAPTION_CHUNKED_THRESHOLD,
   CAPTION_BUSY_STATUSES,
   CABLE_CHANNELS,
+  BotsNamespace,
+  BotSourcesNamespace,
+  BotRespondersNamespace,
+  BotResponderRunsNamespace,
+  BotOwnerChatNamespace,
+  BotMessagesNamespace,
+  BotFactsNamespace,
+  BotContactsNamespace,
+  BotChannelsNamespace,
   BookChatNamespace,
   BookChatError,
   BlogsNamespace,
   BlogPostsNamespace,
   BackgroundRemovalNamespace,
+  BOT_SOURCE_FILTER_COLUMNS,
+  BOT_RUN_FILTER_COLUMNS,
+  BOT_PLUGINS,
+  BOT_MESSAGE_MAX_TEXT,
+  BOT_MESSAGE_FILTER_COLUMNS,
+  BOT_FACT_FILTER_COLUMNS,
+  BOT_CONTACT_KINDS,
+  BOT_CONTACT_FILTER_COLUMNS,
+  BOT_CHANNEL_KINDS,
+  BOT_CHANNEL_HEALTHS,
+  BOT_CHANNEL_FILTER_COLUMNS,
   BOOK_VISIBILITIES,
   BOOK_UPLOAD_EDGE_LIMIT_BYTES,
   BOOK_TITLE_MAX_LENGTH,