@opengeni/contracts 3.1.0-canary.2 → 3.1.2

package/dist/chunk-OL23ARTF.js

@@ -0,0 +1,94 @@
+// src/session-usage-limits.ts
+import { z } from "zod";
+var SESSION_USAGE_LIMIT_BASIS = "model_api_equivalent_v1";
+var SessionUsageLimitBasis = z.literal(SESSION_USAGE_LIMIT_BASIS);
+var SESSION_USAGE_LIMIT_MICROS_PER_DOLLAR = 1e6;
+var SESSION_USAGE_LIMIT_MAX_MICROS = 1e7 * SESSION_USAGE_LIMIT_MICROS_PER_DOLLAR;
+var SessionUsageLimitMicros = z.number().int().nonnegative().safe().max(SESSION_USAGE_LIMIT_MAX_MICROS);
+var UsageMicros = z.number().int().nonnegative().safe();
+var Count = z.number().int().nonnegative().safe();
+var Version = z.number().int().nonnegative().safe();
+var OperationId = z.string().min(1).max(256).refine(
+  (value) => value.trim().length > 0 && !value.includes("\0") && !/[\uD800-\uDFFF]/u.test(value) && new TextEncoder().encode(value).byteLength <= 256
+);
+var SessionUsageLimitStatus = z.enum([
+  "unlimited",
+  "within",
+  "reached",
+  "preparing",
+  "unavailable"
+]);
+var SessionUsageLimitHistory = z.enum(["complete", "legacy_partial", "preparing"]);
+var SessionUsageLimit = z.object({
+  basis: SessionUsageLimitBasis,
+  /** The task root whose limit applies. Equal to the session id for a root. */
+  rootSessionId: z.string().uuid(),
+  /** True when this projection was read through a descendant: edit the root's limit instead. */
+  inherited: z.boolean(),
+  status: SessionUsageLimitStatus,
+  /** Configured limit; null means no limit. Meaningless while `status` is `unavailable`. */
+  limitMicros: SessionUsageLimitMicros.nullable(),
+  /**
+   * Recorded known (priced or known-free) usage of the whole task tree, in USD
+   * micros. Null while `preparing` or `unavailable`: never render it as $0.
+   * May exceed `limitMicros`.
+   */
+  usedMicros: UsageMicros.nullable(),
+  /** Configuration version for compare-and-set writes. Survives clearing. */
+  version: Version,
+  /** Monotonic usage revision; increases whenever a usage receipt changes the total or coverage. */
+  usageRevision: Version,
+  history: SessionUsageLimitHistory,
+  /** `partial` when any usage has unknown cost or history is legacy/preparing: show "at least". */
+  coverage: z.enum(["complete", "partial"]),
+  pricedCalls: Count,
+  /** Responses with a known price of zero; they count as zero, unlike unpriced usage. */
+  freeCalls: Count,
+  /** Responses whose cost is unknown; they are excluded from `usedMicros`. */
+  unpricedCalls: Count,
+  updatedAt: z.string().datetime({ offset: true }).nullable()
+}).strict();
+var SetSessionUsageLimitRequest = z.object({
+  limitMicros: SessionUsageLimitMicros.nullable(),
+  expectedVersion: Version,
+  operationId: OperationId
+}).strict();
+var SessionUsageLimitReachedRefusal = z.object({
+  code: z.literal("session_usage_limit_reached"),
+  basis: SessionUsageLimitBasis,
+  rootSessionId: z.string().uuid(),
+  limitMicros: SessionUsageLimitMicros,
+  usedMicros: UsageMicros,
+  message: z.string().max(1024)
+}).strict();
+var SessionUsageLimitErrorCode = z.enum([
+  "session_usage_limit_reached",
+  "session_usage_limit_conflict",
+  "session_usage_limit_not_root",
+  "session_usage_limit_preparing",
+  "session_usage_limit_unavailable",
+  "session_usage_limit_disabled",
+  "session_usage_limit_forbidden"
+]);
+var SessionUsageLimitUpdatedPayload = z.object({
+  basis: SessionUsageLimitBasis,
+  limitMicros: SessionUsageLimitMicros.nullable(),
+  previousLimitMicros: SessionUsageLimitMicros.nullable(),
+  version: Version
+}).strict();
+
+export {
+  SESSION_USAGE_LIMIT_BASIS,
+  SessionUsageLimitBasis,
+  SESSION_USAGE_LIMIT_MICROS_PER_DOLLAR,
+  SESSION_USAGE_LIMIT_MAX_MICROS,
+  SessionUsageLimitMicros,
+  SessionUsageLimitStatus,
+  SessionUsageLimitHistory,
+  SessionUsageLimit,
+  SetSessionUsageLimitRequest,
+  SessionUsageLimitReachedRefusal,
+  SessionUsageLimitErrorCode,
+  SessionUsageLimitUpdatedPayload
+};
+//# sourceMappingURL=chunk-OL23ARTF.js.map

package/dist/chunk-OL23ARTF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session-usage-limits.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/**\n * Per-task (root session) usage limits.\n *\n * One optional limit belongs to a root session and is shared by every\n * descendant. It is measured in integer USD micros ($1 = 1,000,000) of the\n * canonical pre-margin API-equivalent model cost (`estimatedProviderCostMicros`)\n * recorded when a model response settles, whatever funds the call (Opengeni\n * credits, a connected subscription or a workspace-owned key).\n *\n * The limit is checked before each new model request; it is not a reservation.\n * Requests already admitted may finish and take recorded usage above the\n * limit, and concurrently admitted requests may overshoot together. Usage\n * without a known price is excluded from the total and disclosed as partial\n * coverage instead of being valued at zero. It is not an invoice cap.\n */\n\n/** Versioned measurement basis, exposed so a future basis cannot be confused with this one. */\nexport const SESSION_USAGE_LIMIT_BASIS = \"model_api_equivalent_v1\" as const;\nexport const SessionUsageLimitBasis = z.literal(SESSION_USAGE_LIMIT_BASIS);\nexport type SessionUsageLimitBasis = z.infer<typeof SessionUsageLimitBasis>;\n\nexport const SESSION_USAGE_LIMIT_MICROS_PER_DOLLAR = 1_000_000;\n/** $10M: the largest configurable limit, far inside safe integers. Usage itself is never clamped. */\nexport const SESSION_USAGE_LIMIT_MAX_MICROS = 10_000_000 * SESSION_USAGE_LIMIT_MICROS_PER_DOLLAR;\n\n/** A configured limit. Zero is a valid immediate stop; `null` (not this schema) means no limit. */\nexport const SessionUsageLimitMicros = z\n  .number()\n  .int()\n  .nonnegative()\n  .safe()\n  .max(SESSION_USAGE_LIMIT_MAX_MICROS);\nexport type SessionUsageLimitMicros = z.infer<typeof SessionUsageLimitMicros>;\n\n/** Recorded usage is a non-negative safe integer and may exceed the configured maximum. */\nconst UsageMicros = z.number().int().nonnegative().safe();\nconst Count = z.number().int().nonnegative().safe();\nconst Version = z.number().int().nonnegative().safe();\n\nconst OperationId = z\n  .string()\n  .min(1)\n  .max(256)\n  .refine(\n    (value) =>\n      value.trim().length > 0 &&\n      !value.includes(\"\\0\") &&\n      !/[\\uD800-\\uDFFF]/u.test(value) &&\n      new TextEncoder().encode(value).byteLength <= 256,\n  );\n\n/**\n * - `unlimited`: no limit is configured; usage is still recorded.\n * - `within`: a limit is configured and recorded usage is below it.\n * - `reached`: recorded usage is at or above the limit; new model requests are refused.\n * - `preparing`: historical usage for a task created before this feature is\n *   still being imported; the total is not yet meaningful and a new limit\n *   cannot be set until it finishes.\n * - `unavailable`: the usage state could not be read. Never treat it as zero or unlimited.\n */\nexport const SessionUsageLimitStatus = z.enum([\n  \"unlimited\",\n  \"within\",\n  \"reached\",\n  \"preparing\",\n  \"unavailable\",\n]);\nexport type SessionUsageLimitStatus = z.infer<typeof SessionUsageLimitStatus>;\n\n/**\n * `complete`: every recorded model response of this task was metered live.\n * `legacy_partial`: the task predates usage limits; available historical cost\n * snapshots were imported, but older usage may be missing. This never upgrades\n * to complete, because a missing old record is not proof of no usage.\n * `preparing`: the historical import has not finished.\n */\nexport const SessionUsageLimitHistory = z.enum([\"complete\", \"legacy_partial\", \"preparing\"]);\nexport type SessionUsageLimitHistory = z.infer<typeof SessionUsageLimitHistory>;\n\nexport const SessionUsageLimit = z\n  .object({\n    basis: SessionUsageLimitBasis,\n    /** The task root whose limit applies. Equal to the session id for a root. */\n    rootSessionId: z.string().uuid(),\n    /** True when this projection was read through a descendant: edit the root's limit instead. */\n    inherited: z.boolean(),\n    status: SessionUsageLimitStatus,\n    /** Configured limit; null means no limit. Meaningless while `status` is `unavailable`. */\n    limitMicros: SessionUsageLimitMicros.nullable(),\n    /**\n     * Recorded known (priced or known-free) usage of the whole task tree, in USD\n     * micros. Null while `preparing` or `unavailable`: never render it as $0.\n     * May exceed `limitMicros`.\n     */\n    usedMicros: UsageMicros.nullable(),\n    /** Configuration version for compare-and-set writes. Survives clearing. */\n    version: Version,\n    /** Monotonic usage revision; increases whenever a usage receipt changes the total or coverage. */\n    usageRevision: Version,\n    history: SessionUsageLimitHistory,\n    /** `partial` when any usage has unknown cost or history is legacy/preparing: show \"at least\". */\n    coverage: z.enum([\"complete\", \"partial\"]),\n    pricedCalls: Count,\n    /** Responses with a known price of zero; they count as zero, unlike unpriced usage. */\n    freeCalls: Count,\n    /** Responses whose cost is unknown; they are excluded from `usedMicros`. */\n    unpricedCalls: Count,\n    updatedAt: z.string().datetime({ offset: true }).nullable(),\n  })\n  .strict();\nexport type SessionUsageLimit = z.infer<typeof SessionUsageLimit>;\n\n/**\n * Compare-and-set write of a root task's limit. `expectedVersion` is the\n * `version` the caller last read; a stale version returns 409. A replay of the\n * same `operationId` with the same request returns the committed result.\n */\nexport const SetSessionUsageLimitRequest = z\n  .object({\n    limitMicros: SessionUsageLimitMicros.nullable(),\n    expectedVersion: Version,\n    operationId: OperationId,\n  })\n  .strict();\nexport type SetSessionUsageLimitRequest = z.infer<typeof SetSessionUsageLimitRequest>;\n\n/** Typed refusal for a fresh model request, message or goal resume after the limit is reached. */\nexport const SessionUsageLimitReachedRefusal = z\n  .object({\n    code: z.literal(\"session_usage_limit_reached\"),\n    basis: SessionUsageLimitBasis,\n    rootSessionId: z.string().uuid(),\n    limitMicros: SessionUsageLimitMicros,\n    usedMicros: UsageMicros,\n    message: z.string().max(1_024),\n  })\n  .strict();\nexport type SessionUsageLimitReachedRefusal = z.infer<typeof SessionUsageLimitReachedRefusal>;\n\n/** Typed error codes for the usage-limit routes. */\nexport const SessionUsageLimitErrorCode = z.enum([\n  \"session_usage_limit_reached\",\n  \"session_usage_limit_conflict\",\n  \"session_usage_limit_not_root\",\n  \"session_usage_limit_preparing\",\n  \"session_usage_limit_unavailable\",\n  \"session_usage_limit_disabled\",\n  \"session_usage_limit_forbidden\",\n]);\nexport type SessionUsageLimitErrorCode = z.infer<typeof SessionUsageLimitErrorCode>;\n\n/** The durable event appended to a root's stream when an authorized person changes its limit. */\nexport const SessionUsageLimitUpdatedPayload = z\n  .object({\n    basis: SessionUsageLimitBasis,\n    limitMicros: SessionUsageLimitMicros.nullable(),\n    previousLimitMicros: SessionUsageLimitMicros.nullable(),\n    version: Version,\n  })\n  .strict();\nexport type SessionUsageLimitUpdatedPayload = z.infer<typeof SessionUsageLimitUpdatedPayload>;\n\nexport {\n  formatSessionUsageMicros,\n  parseSessionUsageLimitReachedRefusal,\n  SESSION_USAGE_LIMIT_SEGMENT,\n  SESSION_USAGE_LIMIT_GOAL_PAUSED_REASON,\n  sessionUsageLimitReachedMessage,\n} from \"./session-usage-limit-refusal\";\n"],"mappings":";AAAA,SAAS,SAAS;AAmBX,IAAM,4BAA4B;AAClC,IAAM,yBAAyB,EAAE,QAAQ,yBAAyB;AAGlE,IAAM,wCAAwC;AAE9C,IAAM,iCAAiC,MAAa;AAGpD,IAAM,0BAA0B,EACpC,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,KAAK,EACL,IAAI,8BAA8B;AAIrC,IAAM,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK;AACxD,IAAM,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK;AAClD,IAAM,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK;AAEpD,IAAM,cAAc,EACjB,OAAO,EACP,IAAI,CAAC,EACL,IAAI,GAAG,EACP;AAAA,EACC,CAAC,UACC,MAAM,KAAK,EAAE,SAAS,KACtB,CAAC,MAAM,SAAS,IAAI,KACpB,CAAC,mBAAmB,KAAK,KAAK,KAC9B,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE,cAAc;AAClD;AAWK,IAAM,0BAA0B,EAAE,KAAK;AAAA,EAC5C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAUM,IAAM,2BAA2B,EAAE,KAAK,CAAC,YAAY,kBAAkB,WAAW,CAAC;AAGnF,IAAM,oBAAoB,EAC9B,OAAO;AAAA,EACN,OAAO;AAAA;AAAA,EAEP,eAAe,EAAE,OAAO,EAAE,KAAK;AAAA;AAAA,EAE/B,WAAW,EAAE,QAAQ;AAAA,EACrB,QAAQ;AAAA;AAAA,EAER,aAAa,wBAAwB,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM9C,YAAY,YAAY,SAAS;AAAA;AAAA,EAEjC,SAAS;AAAA;AAAA,EAET,eAAe;AAAA,EACf,SAAS;AAAA;AAAA,EAET,UAAU,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC;AAAA,EACxC,aAAa;AAAA;AAAA,EAEb,WAAW;AAAA;AAAA,EAEX,eAAe;AAAA,EACf,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,CAAC,EAAE,SAAS;AAC5D,CAAC,EACA,OAAO;AAQH,IAAM,8BAA8B,EACxC,OAAO;AAAA,EACN,aAAa,wBAAwB,SAAS;AAAA,EAC9C,iBAAiB;AAAA,EACjB,aAAa;AACf,CAAC,EACA,OAAO;AAIH,IAAM,kCAAkC,EAC5C,OAAO;AAAA,EACN,MAAM,EAAE,QAAQ,6BAA6B;AAAA,EAC7C,OAAO;AAAA,EACP,eAAe,EAAE,OAAO,EAAE,KAAK;AAAA,EAC/B,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,SAAS,EAAE,OAAO,EAAE,IAAI,IAAK;AAC/B,CAAC,EACA,OAAO;AAIH,IAAM,6BAA6B,EAAE,KAAK;AAAA,EAC/C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAIM,IAAM,kCAAkC,EAC5C,OAAO;AAAA,EACN,OAAO;AAAA,EACP,aAAa,wBAAwB,SAAS;AAAA,EAC9C,qBAAqB,wBAAwB,SAAS;AAAA,EACtD,SAAS;AACX,CAAC,EACA,OAAO;","names":[]}

package/dist/chunk-PUIUXIOL.js

@@ -0,0 +1,189 @@
+// src/slack-rest-mcp.ts
+var OFFICIAL_SLACK_MCP_URL = "https://mcp.slack.com/mcp";
+var SLACK_REST_API_BASE = "https://slack.com/api/";
+var SLACK_PRIVATE_FILE_ORIGIN = "https://files.slack.com";
+var SLACK_PRIVATE_FILE_PATH_PREFIX = "/files-pri/";
+function isSlackPrivateFileUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.origin === SLACK_PRIVATE_FILE_ORIGIN && !url.username && !url.password && !url.hash && url.pathname.startsWith(SLACK_PRIVATE_FILE_PATH_PREFIX) && !url.pathname.split("/").some((segment) => segment === "." || segment === "..");
+  } catch {
+    return false;
+  }
+}
+var OPENGENI_SLACK_REST_USER_SCOPES = [
+  "channels:read",
+  "groups:read",
+  "im:read",
+  "mpim:read",
+  "channels:history",
+  "groups:history",
+  "im:history",
+  "mpim:history",
+  "users:read",
+  "files:read",
+  "im:write",
+  "chat:write"
+];
+function normalizeSlackScopes(scopes) {
+  return [
+    ...new Set(
+      (typeof scopes === "string" ? [scopes] : scopes ?? []).flatMap((entry) => entry.split(/[\s,]+/u)).filter(Boolean)
+    )
+  ].sort();
+}
+var conversationScopes = ["channels:read", "groups:read", "im:read", "mpim:read"];
+var historyScopes = ["channels:history", "groups:history", "im:history", "mpim:history"];
+var channel = { type: "string", description: "Slack conversation ID, such as C123 or D123." };
+var cursor = { type: "string", maxLength: 4096, description: "Cursor from the previous page." };
+var directoryPage = { type: "integer", minimum: 1, maximum: 100, default: 100 };
+var historyPage = { type: "integer", minimum: 1, maximum: 15, default: 15 };
+var timestamp = { type: "string", pattern: "^[0-9]+\\.[0-9]+$" };
+function tool(name, description, properties, required = [], mutation = false) {
+  return {
+    name,
+    description,
+    inputSchema: { type: "object", properties, required, additionalProperties: false },
+    annotations: {
+      readOnlyHint: !mutation,
+      destructiveHint: false,
+      idempotentHint: !mutation,
+      openWorldHint: true
+    }
+  };
+}
+var SLACK_REST_MCP_TOOLS = [
+  tool(
+    "slack_list_channels",
+    "Lists one page of conversations visible to your connected Slack account. Conversation types without a granted read scope are omitted.",
+    {
+      types: {
+        type: "array",
+        items: { type: "string", enum: ["public_channel", "private_channel", "im", "mpim"] },
+        minItems: 1,
+        maxItems: 4
+      },
+      cursor,
+      limit: directoryPage,
+      exclude_archived: { type: "boolean", default: true }
+    }
+  ),
+  tool(
+    "slack_get_channel_info",
+    "Gets metadata for one conversation visible to your connected Slack account.",
+    { channel },
+    ["channel"]
+  ),
+  tool(
+    "slack_list_channel_members",
+    "Lists one page of members in a visible channel or group conversation.",
+    { channel, cursor, limit: directoryPage },
+    ["channel"]
+  ),
+  tool("slack_list_users", "Lists one page of users in the connected Slack workspace.", {
+    cursor,
+    limit: directoryPage
+  }),
+  tool(
+    "slack_get_user_info",
+    "Gets a user's profile by their Slack user ID. Email is included only when Slack has granted that scope.",
+    { user: { type: "string" } },
+    ["user"]
+  ),
+  tool(
+    "slack_read_channel",
+    "Reads one page of at most 15 messages from a selected conversation. Slack history limits are shared across the workspace. No automatic pagination or backfill.",
+    {
+      channel,
+      cursor,
+      limit: historyPage,
+      oldest: timestamp,
+      latest: timestamp,
+      inclusive: { type: "boolean", default: false }
+    },
+    ["channel"]
+  ),
+  tool(
+    "slack_read_thread",
+    "Reads one page of at most 15 messages in a selected thread. Slack thread limits are shared across the workspace. No automatic pagination or backfill.",
+    {
+      channel,
+      ts: { ...timestamp, description: "Thread root message timestamp." },
+      cursor,
+      limit: historyPage
+    },
+    ["channel", "ts"]
+  ),
+  tool(
+    "slack_download_file",
+    "Downloads one file shared in Slack, such as a PDF or image, into your workspace like an attachment and returns its path. Use the file ID (F...) from a message's files.",
+    { file: { type: "string", pattern: "^F[A-Z0-9]+$", description: "Slack file ID." } },
+    ["file"]
+  ),
+  tool(
+    "slack_open_dm",
+    "Opens or resumes a direct message with one Slack user as your connected account.",
+    { user: { type: "string" } },
+    ["user"],
+    true
+  ),
+  tool(
+    "slack_send_message",
+    "Sends a message as your connected Slack account. Supply thread_ts to reply in a thread. Review the recipient and text before approving. An uncertain submission is never automatically retried.",
+    {
+      channel,
+      text: { type: "string", minLength: 1, maxLength: 4e4 },
+      thread_ts: { ...timestamp, description: "Optional thread root timestamp for a reply." },
+      unfurl_links: { type: "boolean", default: false },
+      unfurl_media: { type: "boolean", default: false }
+    },
+    ["channel", "text"],
+    true
+  )
+];
+var REQUIRED_ANY_SCOPES = {
+  slack_list_channels: conversationScopes,
+  slack_get_channel_info: conversationScopes,
+  slack_list_channel_members: ["channels:read", "groups:read", "mpim:read"],
+  slack_list_users: ["users:read"],
+  slack_get_user_info: ["users:read"],
+  slack_read_channel: historyScopes,
+  slack_read_thread: historyScopes,
+  slack_download_file: ["files:read"],
+  slack_open_dm: ["im:write"],
+  slack_send_message: ["chat:write"]
+};
+function slackRestMcpToolsForScopes(scopes) {
+  const granted = new Set(normalizeSlackScopes(scopes));
+  return SLACK_REST_MCP_TOOLS.filter(
+    (entry) => REQUIRED_ANY_SCOPES[entry.name]?.some((scope) => granted.has(scope))
+  ).map((entry) => ({
+    ...entry,
+    inputSchema: {
+      ...entry.inputSchema,
+      required: [...entry.inputSchema.required],
+      properties: { ...entry.inputSchema.properties }
+    },
+    annotations: { ...entry.annotations }
+  }));
+}
+var SLACK_CONVERSATION_READ_SCOPE_BY_TYPE = {
+  public_channel: "channels:read",
+  private_channel: "groups:read",
+  im: "im:read",
+  mpim: "mpim:read"
+};
+
+export {
+  OFFICIAL_SLACK_MCP_URL,
+  SLACK_REST_API_BASE,
+  SLACK_PRIVATE_FILE_ORIGIN,
+  SLACK_PRIVATE_FILE_PATH_PREFIX,
+  isSlackPrivateFileUrl,
+  OPENGENI_SLACK_REST_USER_SCOPES,
+  normalizeSlackScopes,
+  SLACK_REST_MCP_TOOLS,
+  slackRestMcpToolsForScopes,
+  SLACK_CONVERSATION_READ_SCOPE_BY_TYPE
+};
+//# sourceMappingURL=chunk-PUIUXIOL.js.map

package/dist/chunk-PUIUXIOL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/slack-rest-mcp.ts"],"sourcesContent":["/** The catalog and OAuth identity stay stable while calls use the ordinary Web API. */\nexport const OFFICIAL_SLACK_MCP_URL = \"https://mcp.slack.com/mcp\";\nexport const SLACK_REST_API_BASE = \"https://slack.com/api/\";\n/** Private Slack file bytes are served only from this origin and path. */\nexport const SLACK_PRIVATE_FILE_ORIGIN = \"https://files.slack.com\";\nexport const SLACK_PRIVATE_FILE_PATH_PREFIX = \"/files-pri/\";\n\n/** A private Slack file download URL that may carry a Slack user token. */\nexport function isSlackPrivateFileUrl(value: string | URL): boolean {\n  try {\n    const url = new URL(value);\n    return (\n      url.origin === SLACK_PRIVATE_FILE_ORIGIN &&\n      !url.username &&\n      !url.password &&\n      !url.hash &&\n      url.pathname.startsWith(SLACK_PRIVATE_FILE_PATH_PREFIX) &&\n      !url.pathname.split(\"/\").some((segment) => segment === \".\" || segment === \"..\")\n    );\n  } catch {\n    return false;\n  }\n}\n\nexport const OPENGENI_SLACK_REST_USER_SCOPES = [\n  \"channels:read\",\n  \"groups:read\",\n  \"im:read\",\n  \"mpim:read\",\n  \"channels:history\",\n  \"groups:history\",\n  \"im:history\",\n  \"mpim:history\",\n  \"users:read\",\n  \"files:read\",\n  \"im:write\",\n  \"chat:write\",\n] as const;\n\n/** Slack returns comma-delimited scopes, including in existing saved grants. */\nexport function normalizeSlackScopes(\n  scopes: readonly string[] | string | undefined | null,\n): string[] {\n  return [\n    ...new Set(\n      (typeof scopes === \"string\" ? [scopes] : (scopes ?? []))\n        .flatMap((entry) => entry.split(/[\\s,]+/u))\n        .filter(Boolean),\n    ),\n  ].sort();\n}\n\nexport type SlackRestMcpTool = {\n  name: string;\n  description: string;\n  inputSchema: {\n    type: \"object\";\n    properties: Record<string, unknown>;\n    required: string[];\n    additionalProperties: false;\n  };\n  annotations: {\n    readOnlyHint: boolean;\n    destructiveHint: false;\n    idempotentHint: boolean;\n    openWorldHint: true;\n  };\n};\n\nconst conversationScopes = [\"channels:read\", \"groups:read\", \"im:read\", \"mpim:read\"];\nconst historyScopes = [\"channels:history\", \"groups:history\", \"im:history\", \"mpim:history\"];\nconst channel = { type: \"string\", description: \"Slack conversation ID, such as C123 or D123.\" };\nconst cursor = { type: \"string\", maxLength: 4096, description: \"Cursor from the previous page.\" };\nconst directoryPage = { type: \"integer\", minimum: 1, maximum: 100, default: 100 };\nconst historyPage = { type: \"integer\", minimum: 1, maximum: 15, default: 15 };\nconst timestamp = { type: \"string\", pattern: \"^[0-9]+\\\\.[0-9]+$\" };\n\nfunction tool(\n  name: string,\n  description: string,\n  properties: Record<string, unknown>,\n  required: string[] = [],\n  mutation = false,\n): SlackRestMcpTool {\n  return {\n    name,\n    description,\n    inputSchema: { type: \"object\", properties, required, additionalProperties: false },\n    annotations: {\n      readOnlyHint: !mutation,\n      destructiveHint: false,\n      idempotentHint: !mutation,\n      openWorldHint: true,\n    },\n  };\n}\n\n/** Static reviewed pilot surface. Each call reads only one explicitly requested page. */\nexport const SLACK_REST_MCP_TOOLS: SlackRestMcpTool[] = [\n  tool(\n    \"slack_list_channels\",\n    \"Lists one page of conversations visible to your connected Slack account. Conversation types without a granted read scope are omitted.\",\n    {\n      types: {\n        type: \"array\",\n        items: { type: \"string\", enum: [\"public_channel\", \"private_channel\", \"im\", \"mpim\"] },\n        minItems: 1,\n        maxItems: 4,\n      },\n      cursor,\n      limit: directoryPage,\n      exclude_archived: { type: \"boolean\", default: true },\n    },\n  ),\n  tool(\n    \"slack_get_channel_info\",\n    \"Gets metadata for one conversation visible to your connected Slack account.\",\n    { channel },\n    [\"channel\"],\n  ),\n  tool(\n    \"slack_list_channel_members\",\n    \"Lists one page of members in a visible channel or group conversation.\",\n    { channel, cursor, limit: directoryPage },\n    [\"channel\"],\n  ),\n  tool(\"slack_list_users\", \"Lists one page of users in the connected Slack workspace.\", {\n    cursor,\n    limit: directoryPage,\n  }),\n  tool(\n    \"slack_get_user_info\",\n    \"Gets a user's profile by their Slack user ID. Email is included only when Slack has granted that scope.\",\n    { user: { type: \"string\" } },\n    [\"user\"],\n  ),\n  tool(\n    \"slack_read_channel\",\n    \"Reads one page of at most 15 messages from a selected conversation. Slack history limits are shared across the workspace. No automatic pagination or backfill.\",\n    {\n      channel,\n      cursor,\n      limit: historyPage,\n      oldest: timestamp,\n      latest: timestamp,\n      inclusive: { type: \"boolean\", default: false },\n    },\n    [\"channel\"],\n  ),\n  tool(\n    \"slack_read_thread\",\n    \"Reads one page of at most 15 messages in a selected thread. Slack thread limits are shared across the workspace. No automatic pagination or backfill.\",\n    {\n      channel,\n      ts: { ...timestamp, description: \"Thread root message timestamp.\" },\n      cursor,\n      limit: historyPage,\n    },\n    [\"channel\", \"ts\"],\n  ),\n  tool(\n    \"slack_download_file\",\n    \"Downloads one file shared in Slack, such as a PDF or image, into your workspace like an attachment and returns its path. Use the file ID (F...) from a message's files.\",\n    { file: { type: \"string\", pattern: \"^F[A-Z0-9]+$\", description: \"Slack file ID.\" } },\n    [\"file\"],\n  ),\n  tool(\n    \"slack_open_dm\",\n    \"Opens or resumes a direct message with one Slack user as your connected account.\",\n    { user: { type: \"string\" } },\n    [\"user\"],\n    true,\n  ),\n  tool(\n    \"slack_send_message\",\n    \"Sends a message as your connected Slack account. Supply thread_ts to reply in a thread. Review the recipient and text before approving. An uncertain submission is never automatically retried.\",\n    {\n      channel,\n      text: { type: \"string\", minLength: 1, maxLength: 40000 },\n      thread_ts: { ...timestamp, description: \"Optional thread root timestamp for a reply.\" },\n      unfurl_links: { type: \"boolean\", default: false },\n      unfurl_media: { type: \"boolean\", default: false },\n    },\n    [\"channel\", \"text\"],\n    true,\n  ),\n];\n\nconst REQUIRED_ANY_SCOPES: Readonly<Record<string, readonly string[]>> = {\n  slack_list_channels: conversationScopes,\n  slack_get_channel_info: conversationScopes,\n  slack_list_channel_members: [\"channels:read\", \"groups:read\", \"mpim:read\"],\n  slack_list_users: [\"users:read\"],\n  slack_get_user_info: [\"users:read\"],\n  slack_read_channel: historyScopes,\n  slack_read_thread: historyScopes,\n  slack_download_file: [\"files:read\"],\n  slack_open_dm: [\"im:write\"],\n  slack_send_message: [\"chat:write\"],\n};\n\nexport function slackRestMcpToolsForScopes(scopes: readonly string[] | string): SlackRestMcpTool[] {\n  const granted = new Set(normalizeSlackScopes(scopes));\n  return SLACK_REST_MCP_TOOLS.filter((entry) =>\n    REQUIRED_ANY_SCOPES[entry.name]?.some((scope) => granted.has(scope)),\n  ).map((entry) => ({\n    ...entry,\n    inputSchema: {\n      ...entry.inputSchema,\n      required: [...entry.inputSchema.required],\n      properties: { ...entry.inputSchema.properties },\n    },\n    annotations: { ...entry.annotations },\n  }));\n}\n\nexport const SLACK_CONVERSATION_READ_SCOPE_BY_TYPE = {\n  public_channel: \"channels:read\",\n  private_channel: \"groups:read\",\n  im: \"im:read\",\n  mpim: \"mpim:read\",\n} as const;\n"],"mappings":"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","names":[]}

package/dist/{chunk-Y3KNXVTD.js → chunk-RMWXDZEO.js}

@@ -1,8 +1,11 @@
 import {
+  SPREADSHEET_DEFAULT_COLUMN_WIDTH,
+  SPREADSHEET_DEFAULT_ROW_HEIGHT,
+  SPREADSHEET_MAX_DIMENSION_PIXELS,
   canonicalSpreadsheetDateFromMilliseconds,
   canonicalSpreadsheetDateMilliseconds,
   spreadsheetSheetId
-} from "./chunk-TXTQIYCV.js";
+} from "./chunk-ILJ72KPO.js";
 
 // src/spreadsheet-artifact-query.ts
 var SPREADSHEET_ARTIFACT_QUERY_VERSION = 1;
@@ -23,6 +26,13 @@ var VIEWPORT_QUERY_PAYLOAD_BYTES = 32;
 var VIEWPORT_PROJECTION_PREFIX_BYTES = 48;
 var METADATA_PROJECTION_PREFIX_BYTES = 4;
 var GENERATIONS_FLAG = 1;
+var DIMENSIONS_FLAG = 2;
+var DIMENSION_KEYS = [
+  "defaultRowHeight",
+  "defaultColumnWidth",
+  "rowHeights",
+  "columnWidths"
+];
 var UINT32_MAX = 4294967295;
 var UINT64_MAX = 0xffffffffffffffffn;
 var FNV_OFFSET = 0xcbf29ce484222325n;
@@ -107,6 +117,8 @@ function encodeSpreadsheetViewportKernelProjection(input, maximumBytes = SPREADS
   payload.u32(projection.startColumn);
   payload.u32(projection.rowCount);
   payload.u32(projection.columnCount);
+  const hasDimensions = projection.defaultRowHeight !== void 0;
+  if (hasDimensions) writeDimensions(payload, projection);
   for (const cell of projection.cells) {
     payload.u32(cell.row - projection.startRow);
     payload.u32(cell.column - projection.startColumn);
@@ -115,7 +127,7 @@ function encodeSpreadsheetViewportKernelProjection(input, maximumBytes = SPREADS
   return encodeProjectionFrame(
     0,
     projection.revision,
-    projection.generationId === null ? 0 : GENERATIONS_FLAG,
+    (projection.generationId === null ? 0 : GENERATIONS_FLAG) | (hasDimensions ? DIMENSIONS_FLAG : 0),
     projection.cells.length,
     payload.finish(),
     maximum
@@ -128,7 +140,7 @@ function encodeSpreadsheetMetadataKernelProjection(input, maximumBytes = SPREADS
     SPREADSHEET_ARTIFACT_METADATA_MIN_RESPONSE_BYTES
   );
   const payload = new DynamicWriter(maximum - PROJECTION_HEADER_BYTES - CHECKSUM_BYTES);
-  payload.u32(0);
+  payload.u32(projection.modeledFeatures.dimensions ? 1 : 0);
   for (const sheet of projection.sheets) {
     payload.stableId(sheet.sheetId);
     payload.optionalStableId(sheet.generationId);
@@ -142,12 +154,13 @@ function encodeSpreadsheetMetadataKernelProjection(input, maximumBytes = SPREADS
       payload.u32(sheet.usedBounds.endRow);
       payload.u32(sheet.usedBounds.endColumn);
     }
+    if (projection.modeledFeatures.dimensions) writeDimensions(payload, sheet);
   }
   const generations = projection.sheets.length > 0 && projection.sheets[0].generationId !== null;
   return encodeProjectionFrame(
     1,
     projection.revision,
-    generations ? GENERATIONS_FLAG : 0,
+    (generations ? GENERATIONS_FLAG : 0) | (projection.modeledFeatures.dimensions ? DIMENSIONS_FLAG : 0),
     projection.sheets.length,
     payload.finish(),
     maximum
@@ -310,7 +323,7 @@ function decodeProjectionFrame(bytes) {
     throw projectionError(`unsupported spreadsheet projection version: ${version}`);
   }
   const flags = reader.u16();
-  if ((flags & ~GENERATIONS_FLAG) !== 0) {
+  if ((flags & ~(GENERATIONS_FLAG | DIMENSIONS_FLAG)) !== 0) {
     throw projectionError("spreadsheet projection flags are noncanonical");
   }
   const kindTag = reader.u8();
@@ -360,6 +373,8 @@ function decodeViewportPayload(frame) {
   const rowCount = reader.u32();
   const columnCount = reader.u32();
   validateViewportGeometry(startRow, startColumn, rowCount, columnCount);
+  const dimensions = (frame.flags & DIMENSIONS_FLAG) !== 0 ? readDimensions(reader) : {};
+  validateDimensionExtent(dimensions, startRow, rowCount, startColumn, columnCount);
   const cells = [];
   let previousOrdinal = -1;
   for (let index = 0; index < frame.itemCount; index += 1) {
@@ -390,6 +405,7 @@ function decodeViewportPayload(frame) {
   reader.done("viewport projection payload contains trailing bytes");
   return Object.freeze({
     revision: frame.revision,
+    ...dimensions,
     sheetId,
     generationId,
     startRow,
@@ -407,7 +423,8 @@ function decodeMetadataPayload(frame) {
     throw projectionError("metadata projection payload is truncated");
   }
   const reader = new Reader(frame.payload);
-  if (reader.u32() !== 0) {
+  const features = reader.u32();
+  if ((features & ~1) !== 0 || features === 1 !== ((frame.flags & DIMENSIONS_FLAG) !== 0)) {
     throw projectionError("metadata projection contains unknown modeled feature bits");
   }
   const hasGenerations = (frame.flags & GENERATIONS_FLAG) !== 0;
@@ -441,12 +458,13 @@ function decodeMetadataPayload(frame) {
       }
       usedBounds = Object.freeze({ startRow, startColumn, endRow, endColumn });
     }
-    sheets.push(Object.freeze({ sheetId, generationId, name, usedBounds }));
+    const dimensions = (frame.flags & DIMENSIONS_FLAG) !== 0 ? readDimensions(reader) : {};
+    sheets.push(Object.freeze({ sheetId, generationId, name, usedBounds, ...dimensions }));
   }
   reader.done("metadata projection payload contains trailing bytes");
   return Object.freeze({
     revision: frame.revision,
-    modeledFeatures: MODELED_FEATURES_NONE,
+    modeledFeatures: Object.freeze({ dimensions: features === 1, hidden: false, merges: false }),
     sheets: Object.freeze(sheets)
   });
 }
@@ -500,8 +518,9 @@ function normalizeViewportProjection(input) {
       "rowCount",
       "sheetId",
       "startColumn",
-      "startRow"
-    ],
+      "startRow",
+      ...projection.defaultRowHeight === void 0 ? [] : DIMENSION_KEYS
+    ].sort(),
     "spreadsheet viewport projection"
   );
   const revision = uint64(projection.revision, "viewport revision");
@@ -512,6 +531,8 @@ function normalizeViewportProjection(input) {
   const rowCount = positiveUint32(projection.rowCount, "viewport rowCount");
   const columnCount = positiveUint32(projection.columnCount, "viewport columnCount");
   validateViewportGeometry(startRow, startColumn, rowCount, columnCount);
+  const dimensions = projection.defaultRowHeight === void 0 ? {} : normalizeDimensions(projection);
+  validateDimensionExtent(dimensions, startRow, rowCount, startColumn, columnCount);
   if (!Array.isArray(projection.cells)) throw projectionError("viewport cells must be an array");
   if (projection.cells.length > SPREADSHEET_ARTIFACT_VIEWPORT_MAX_CELLS) {
     throw projectionError("viewport projection exceeds its hard cell limit");
@@ -535,6 +556,7 @@ function normalizeViewportProjection(input) {
   }
   return Object.freeze({
     revision,
+    ...dimensions,
     sheetId,
     generationId,
     startRow,
@@ -554,8 +576,8 @@ function normalizeMetadataProjection(input) {
   const revision = uint64(projection.revision, "metadata revision");
   const features = exactRecord(projection.modeledFeatures, "metadata modeledFeatures");
   exactKeys(features, ["dimensions", "hidden", "merges"], "metadata modeledFeatures");
-  if (features.dimensions !== false || features.hidden !== false || features.merges !== false) {
-    throw projectionError("version 1 metadata modeled features must all be false");
+  if (typeof features.dimensions !== "boolean" || features.hidden !== false || features.merges !== false) {
+    throw projectionError("metadata modeled features are invalid");
   }
   if (!Array.isArray(projection.sheets)) throw projectionError("metadata sheets must be an array");
   if (projection.sheets.length > SPREADSHEET_ARTIFACT_METADATA_MAX_SHEETS) {
@@ -570,7 +592,17 @@ function normalizeMetadataProjection(input) {
       ownArrayElement(projection.sheets, index, "metadata sheets"),
       "metadata sheet"
     );
-    exactKeys(value, ["generationId", "name", "sheetId", "usedBounds"], "metadata sheet");
+    exactKeys(
+      value,
+      [
+        "generationId",
+        "name",
+        "sheetId",
+        "usedBounds",
+        ...features.dimensions ? DIMENSION_KEYS : []
+      ].sort(),
+      "metadata sheet"
+    );
     const sheetId = spreadsheetSheetId(requireString(value.sheetId, "metadata sheetId"));
     if (ids.has(sheetId)) throw projectionError("metadata projection contains duplicate sheet ids");
     ids.add(sheetId);
@@ -590,14 +622,94 @@ function normalizeMetadataProjection(input) {
     }
     names.add(foldedName);
     const usedBounds = value.usedBounds === null ? null : normalizeUsedBounds(value.usedBounds);
-    sheets.push(Object.freeze({ sheetId, generationId, name, usedBounds }));
+    sheets.push(
+      Object.freeze({
+        sheetId,
+        generationId,
+        name,
+        usedBounds,
+        ...features.dimensions ? normalizeDimensions(value) : {}
+      })
+    );
   }
   return Object.freeze({
     revision,
-    modeledFeatures: MODELED_FEATURES_NONE,
+    modeledFeatures: Object.freeze({
+      dimensions: features.dimensions,
+      hidden: false,
+      merges: false
+    }),
     sheets: Object.freeze(sheets)
   });
 }
+function normalizeDimensions(input) {
+  if (input.defaultRowHeight !== SPREADSHEET_DEFAULT_ROW_HEIGHT || input.defaultColumnWidth !== SPREADSHEET_DEFAULT_COLUMN_WIDTH) {
+    throw projectionError("dimension defaults are invalid");
+  }
+  const normalizeEntries = (value, defaultPixels) => {
+    if (!Array.isArray(value) || value.length > SPREADSHEET_ARTIFACT_PROJECTION_MAX_BYTES / 8)
+      throw projectionError("dimension entries exceed limits");
+    let previous = -1;
+    const entries = [];
+    for (let offset = 0; offset < value.length; offset += 1) {
+      const entry = ownArrayElement(value, offset, "dimension entries");
+      if (!Array.isArray(entry) || entry.length !== 2)
+        throw projectionError("dimension entry must be an index/pixels pair");
+      const index = uint32(ownArrayElement(entry, 0, "dimension index"), `dimension ${offset}`);
+      const pixels = positiveUint32(
+        ownArrayElement(entry, 1, "dimension pixels"),
+        "dimension pixels"
+      );
+      if (index <= previous || pixels > SPREADSHEET_MAX_DIMENSION_PIXELS || pixels === defaultPixels)
+        throw projectionError("dimensions must be sorted unique non-default entries within bounds");
+      previous = index;
+      entries.push(Object.freeze([index, pixels]));
+    }
+    return Object.freeze(entries);
+  };
+  return Object.freeze({
+    defaultRowHeight: SPREADSHEET_DEFAULT_ROW_HEIGHT,
+    defaultColumnWidth: SPREADSHEET_DEFAULT_COLUMN_WIDTH,
+    rowHeights: normalizeEntries(input.rowHeights, SPREADSHEET_DEFAULT_ROW_HEIGHT),
+    columnWidths: normalizeEntries(input.columnWidths, SPREADSHEET_DEFAULT_COLUMN_WIDTH)
+  });
+}
+function writeDimensions(writer, dimensions) {
+  writer.u32(dimensions.defaultRowHeight);
+  writer.u32(dimensions.defaultColumnWidth);
+  for (const entries of [dimensions.rowHeights, dimensions.columnWidths]) {
+    writer.u32(entries.length);
+    for (const [index, pixels] of entries) {
+      writer.u32(index);
+      writer.u32(pixels);
+    }
+  }
+}
+function readDimensions(reader) {
+  const defaultRowHeight = reader.u32();
+  const defaultColumnWidth = reader.u32();
+  const axes = [];
+  for (let axis = 0; axis < 2; axis += 1) {
+    const count = reader.u32();
+    if (count > SPREADSHEET_ARTIFACT_PROJECTION_MAX_BYTES / 8)
+      throw projectionError("dimension entries exceed limits");
+    const entries = [];
+    for (let index = 0; index < count; index += 1) entries.push([reader.u32(), reader.u32()]);
+    axes.push(entries);
+  }
+  return normalizeDimensions({
+    defaultRowHeight,
+    defaultColumnWidth,
+    rowHeights: axes[0],
+    columnWidths: axes[1]
+  });
+}
+function validateDimensionExtent(dimensions, startRow, rowCount, startColumn, columnCount) {
+  if (dimensions.rowHeights?.some(([index]) => index < startRow || index - startRow >= rowCount) || dimensions.columnWidths?.some(
+    ([index]) => index < startColumn || index - startColumn >= columnCount
+  ))
+    throw projectionError("dimensions lie outside viewport");
+}
 function normalizeProjectedCell(input) {
   const cell = exactRecord(input, "projected cell");
   exactKeys(cell, ["column", "formula", "row", "value"], "projected cell");
@@ -810,11 +922,6 @@ function queryError(message) {
 function projectionError(message) {
   return new TypeError(message);
 }
-var MODELED_FEATURES_NONE = Object.freeze({
-  dimensions: false,
-  hidden: false,
-  merges: false
-});
 var EMPTY_VALUE = Object.freeze({
   kind: "empty"
 });
@@ -1142,4 +1249,4 @@ export {
   decodeSpreadsheetMetadataKernelProjection,
   assertCanonicalSpreadsheetArtifactKernelProjectionBytes
 };
-//# sourceMappingURL=chunk-Y3KNXVTD.js.map
+//# sourceMappingURL=chunk-RMWXDZEO.js.map