@firfi/huly-mcp 0.35.0 → 0.36.0

package/README.md

@@ -295,7 +295,7 @@ Planned feature surfaces:
 - Calendar: calendar CRUD/config, external calendar sync metadata, primary calendar management, schedule objects, participant mutations, and RSVP/status support when stable.
 - Team planner and schedule reporting: team agendas, workload/capacity summaries, and visibility-aware free/busy views across members/projects.
 - Virtual office and meetings: offices, floors, rooms, access/language/default recording/transcription settings, meeting schedules, active participants, room info, meeting notes/transcript records (minutes), recordings, and device preferences.
-- Chat and communication: request-access flows if Huly exposes a stable model, pinned messages, message attachments, translation, applets, in-message polls, guest communication settings, and external Gmail/Telegram/Huly Mail surfaces once compatible packages/APIs are proven.
+- Chat and communication: request-access flows if Huly exposes a stable model, pinned messages, translation, applets, in-message polls, guest communication settings, and external Gmail/Telegram/Huly Mail surfaces plus provider-specific attachments once compatible packages/APIs are proven.
 - Notifications and activity: browser/push subscription internals, provider defaults, UI presenter/viewlet metadata, and activity control/extension metadata.
 - Attachments and media: previews/preview metadata and friendly wrappers for additional object types beyond issue/document/inventory product.
 - Core schema and workspace administration: attribute/property create/update/delete/hide, enum CRUD/options, sequence management, role/permission definition writes, generic space creation, global space admins, integrations registry, invite settings, role capability settings, and workspace setting metadata.
@@ -503,6 +503,11 @@ SDK upgrade revisit:
 | `add_thread_reply` | Add a reply to a message thread. Reply body supports markdown formatting. |
 | `update_thread_reply` | Update a thread reply. Only the body can be modified. |
 | `delete_thread_reply` | Permanently delete a thread reply. This action cannot be undone. |
+| `list_chat_message_attachments` | List files attached directly to a Huly chat message target. target.kind supports channel_message, dm_message, and thread_reply; the tool resolves channel names and one-to-one DM participant display names for you. |
+| `get_chat_message_attachment` | Get one file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target. |
+| `add_chat_message_attachment` | Attach a file directly to a Huly channel message, direct-message message, or thread reply. Provide filename, contentType, and exactly one of filePath, fileUrl, or data. |
+| `update_chat_message_attachment` | Update description and/or pinned state for a file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target. |
+| `delete_chat_message_attachment` | Delete one file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target. |
 
 ### Calendar
 

package/dist/index.cjs

@@ -154405,6 +154405,17 @@ var ThreadReplyNotFoundError = class extends Schema_exports.TaggedError()(
     return `Thread reply '${this.replyId}' not found on message '${this.messageId}'`;
   }
 };
+var ChatMessageAttachmentNotFoundError = class extends Schema_exports.TaggedError()(
+  "ChatMessageAttachmentNotFoundError",
+  {
+    target: NonEmptyString2,
+    attachmentId: AttachmentId
+  }
+) {
+  get message() {
+    return `Attachment '${this.attachmentId}' not found on ${this.target}`;
+  }
+};
 var ActivityMessageNotFoundError = class extends Schema_exports.TaggedError()(
   "ActivityMessageNotFoundError",
   {
@@ -155913,6 +155924,7 @@ var HulyDomainError = Schema_exports.Union(
   DirectMessageNotFoundError,
   DirectMessageParticipantCountError,
   MessageNotFoundError,
+  ChatMessageAttachmentNotFoundError,
   PersonNotAnEmployeeError,
   ThreadReplyNotFoundError,
   CalendarNotAccessibleError,
@@ -166927,6 +166939,7 @@ var INVALID_PARAMS_TAGS = /* @__PURE__ */ new Set([
   "PersonNotAnEmployeeError",
   "MessageNotFoundError",
   "ThreadReplyNotFoundError",
+  "ChatMessageAttachmentNotFoundError",
   "CalendarNotAccessibleError",
   "EventNotFoundError",
   "RecurringEventNotFoundError",
@@ -171254,6 +171267,559 @@ var parseAddThreadReplyParams = Schema_exports.decodeUnknown(AddThreadReplyParam
 var parseUpdateThreadReplyParams = Schema_exports.decodeUnknown(UpdateThreadReplyParamsSchema);
 var parseDeleteThreadReplyParams = Schema_exports.decodeUnknown(DeleteThreadReplyParamsSchema);
 
+// src/domain/schemas/domain-values.ts
+var LocalFilePath = Schema_exports.String.pipe(Schema_exports.brand("LocalFilePath")).annotations({
+  identifier: "LocalFilePath",
+  title: "LocalFilePath",
+  description: "Host-local file path used only as an upload transport input. It is not a Huly domain identifier and may be OS-specific."
+});
+var Base64FileData = Schema_exports.String.pipe(Schema_exports.brand("Base64FileData")).annotations({
+  identifier: "Base64FileData",
+  title: "Base64FileData",
+  description: "Base64-encoded upload payload. It is transport data rather than a Huly domain value, but is branded to avoid arbitrary text confusion."
+});
+var AttachmentFileName = NonEmptyString2.pipe(Schema_exports.brand("AttachmentFileName")).annotations({
+  identifier: "AttachmentFileName",
+  title: "AttachmentFileName",
+  description: "Non-empty attachment filename as stored by Huly."
+});
+var AttachmentDescription = Schema_exports.String.pipe(Schema_exports.brand("AttachmentDescription")).annotations({
+  identifier: "AttachmentDescription",
+  title: "AttachmentDescription",
+  description: "Free-form attachment description. Empty string is valid because Huly uses it to clear descriptions."
+});
+var AttachmentByteSize = NonNegativeInteger.pipe(Schema_exports.brand("AttachmentByteSize")).annotations({
+  identifier: "AttachmentByteSize",
+  title: "AttachmentByteSize",
+  description: "Attachment size in bytes. Must be a non-negative integer, never a fraction or negative value."
+});
+var AttachmentMetadataKey = Schema_exports.String.pipe(Schema_exports.brand("AttachmentMetadataKey")).annotations({
+  identifier: "AttachmentMetadataKey",
+  title: "AttachmentMetadataKey",
+  description: "Open attachment metadata record key supplied by the Huly SDK. It is not a closed MCP domain enum."
+});
+var DisplayText = NonEmptyString2.pipe(Schema_exports.brand("DisplayText")).annotations({
+  identifier: "DisplayText",
+  title: "DisplayText",
+  description: "Human-readable display text from Huly model metadata or user-authored content."
+});
+var ActivityMarkup = Schema_exports.String.pipe(Schema_exports.brand("ActivityMarkup")).annotations({
+  identifier: "ActivityMarkup",
+  title: "ActivityMarkup",
+  description: "Huly activity markup payload. Empty string is valid when the SDK stores cleared content."
+});
+var ActivityMarkdown = Schema_exports.String.pipe(Schema_exports.brand("ActivityMarkdown")).annotations({
+  identifier: "ActivityMarkdown",
+  title: "ActivityMarkdown",
+  description: "Markdown projection of a Huly activity markup payload for MCP responses."
+});
+var MentionContent = Schema_exports.String.pipe(Schema_exports.brand("MentionContent")).annotations({
+  identifier: "MentionContent",
+  title: "MentionContent",
+  description: "User-authored activity mention snippet returned by Huly."
+});
+var DrawingContent = Schema_exports.String.pipe(Schema_exports.brand("DrawingContent")).annotations({
+  identifier: "DrawingContent",
+  title: "DrawingContent",
+  description: "Opaque drawing content payload stored by Huly."
+});
+var ActivityFilterPosition = Integer.pipe(Schema_exports.brand("ActivityFilterPosition")).annotations({
+  identifier: "ActivityFilterPosition",
+  title: "ActivityFilterPosition",
+  description: "Integer display order for an activity filter."
+});
+var NotificationProviderOrder = Integer.pipe(Schema_exports.brand("NotificationProviderOrder")).annotations({
+  identifier: "NotificationProviderOrder",
+  title: "NotificationProviderOrder",
+  description: "Integer display order for a notification provider."
+});
+var NotificationFieldName = NonEmptyString2.pipe(Schema_exports.brand("NotificationFieldName")).annotations({
+  identifier: "NotificationFieldName",
+  title: "NotificationFieldName",
+  description: "Huly document field name associated with a notification type."
+});
+
+// src/domain/schemas/attachments.ts
+var DEFAULT_ATTACHMENT_PINNED = false;
+var AttachmentKindSchema = Schema_exports.Literal("attachment", "embedding", "photo").annotations({
+  title: "AttachmentKind",
+  description: "Attachment class to create: attachment, embedding, or photo. Defaults to attachment."
+});
+var AttachmentMetadataSchema = Schema_exports.Record({ key: AttachmentMetadataKey, value: Schema_exports.Unknown });
+var ListAttachmentsParamsSchema = Schema_exports.Struct({
+  objectId: DocId.annotations({
+    description: "ID of the parent object (issue, document, etc.)"
+  }),
+  objectClass: ObjectClassName.annotations({
+    description: "Class of the parent object (e.g., 'tracker:class:Issue', 'document:class:Document')"
+  }),
+  limit: Schema_exports.optional(
+    LimitParam.annotations({
+      description: `Maximum number of attachments to return (default: ${DEFAULT_LIMIT})`
+    })
+  )
+}).annotations({
+  title: "ListAttachmentsParams",
+  description: "Parameters for listing attachments on an object"
+});
+var GetAttachmentParamsSchema = Schema_exports.Struct({
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID"
+  })
+}).annotations({
+  title: "GetAttachmentParams",
+  description: "Parameters for getting a single attachment"
+});
+var FileSourceFields = {
+  filename: AttachmentFileName.annotations({
+    description: "Name of the file"
+  }),
+  contentType: MimeType.annotations({
+    description: "MIME type of the file (e.g., 'image/png', 'application/pdf')"
+  }),
+  filePath: Schema_exports.optional(LocalFilePath.annotations({
+    description: "Local file path to upload (preferred - avoids context flooding)"
+  })),
+  fileUrl: Schema_exports.optional(UrlString.annotations({
+    description: "URL to fetch file from (for remote files)"
+  })),
+  data: Schema_exports.optional(Base64FileData.annotations({
+    description: "Base64-encoded file data (fallback for small files <10KB)"
+  })),
+  description: Schema_exports.optional(AttachmentDescription.annotations({
+    description: "Attachment description"
+  })),
+  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: `Whether to pin the attachment (default: ${DEFAULT_ATTACHMENT_PINNED})`
+  })),
+  kind: Schema_exports.optional(AttachmentKindSchema.annotations({
+    description: "Attachment subclass to create: attachment, embedding, or photo (default: attachment)."
+  }))
+};
+var hasFileSource = (params) => {
+  const hasSource = params.filePath || params.fileUrl || params.data;
+  return hasSource ? true : "Must provide filePath, fileUrl, or data";
+};
+var AddAttachmentParamsBase = Schema_exports.Struct({
+  objectId: DocId.annotations({
+    description: "ID of the parent object (issue, document, etc.)"
+  }),
+  objectClass: ObjectClassName.annotations({
+    description: "Class of the parent object (e.g., 'tracker:class:Issue', 'document:class:Document')"
+  }),
+  space: SpaceId.annotations({
+    description: "Space ID where the parent object resides"
+  }),
+  ...FileSourceFields
+});
+var AddAttachmentParamsSchema = AddAttachmentParamsBase.pipe(
+  Schema_exports.filter(hasFileSource)
+).annotations({
+  title: "AddAttachmentParams",
+  description: "Parameters for adding an attachment. Provide ONE of: filePath, fileUrl, or data"
+});
+var UPDATE_ATTACHMENT_FIELDS = ["description", "pinned"];
+var UpdateAttachmentParamsSchema = Schema_exports.Struct({
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID"
+  }),
+  description: Schema_exports.optional(
+    Schema_exports.NullOr(AttachmentDescription).annotations({
+      description: "New description (null to clear)"
+    })
+  ),
+  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Pin or unpin the attachment"
+  }))
+}).pipe(
+  Schema_exports.filter(
+    (params) => hasAtLeastOneDefined(params, UPDATE_ATTACHMENT_FIELDS) ? void 0 : atLeastOneUpdateFieldMessage(UPDATE_ATTACHMENT_FIELDS)
+  )
+).annotations({
+  title: "UpdateAttachmentParams",
+  description: `Parameters for updating an attachment. ${atLeastOneUpdateFieldMessage(UPDATE_ATTACHMENT_FIELDS)}`
+});
+assertUpdateFields()(["attachmentId"], UPDATE_ATTACHMENT_FIELDS);
+var DeleteAttachmentParamsSchema = Schema_exports.Struct({
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID to delete"
+  })
+}).annotations({
+  title: "DeleteAttachmentParams",
+  description: "Parameters for deleting an attachment"
+});
+var PinAttachmentParamsSchema = Schema_exports.Struct({
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID"
+  }),
+  pinned: Schema_exports.Boolean.annotations({
+    description: "Whether to pin (true) or unpin (false)"
+  })
+}).annotations({
+  title: "PinAttachmentParams",
+  description: "Parameters for pinning/unpinning an attachment"
+});
+var DownloadAttachmentParamsSchema = Schema_exports.Struct({
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID"
+  })
+}).annotations({
+  title: "DownloadAttachmentParams",
+  description: "Parameters for getting attachment download URL"
+});
+var AddIssueAttachmentParamsBase = Schema_exports.Struct({
+  project: ProjectIdentifier.annotations({
+    description: "Project identifier (e.g., 'HULY')"
+  }),
+  identifier: IssueIdentifier.annotations({
+    description: "Issue identifier (e.g., 'HULY-123')"
+  }),
+  ...FileSourceFields
+});
+var AddIssueAttachmentParamsSchema = AddIssueAttachmentParamsBase.pipe(
+  Schema_exports.filter(hasFileSource)
+).annotations({
+  title: "AddIssueAttachmentParams",
+  description: "Parameters for adding an attachment to an issue"
+});
+var AddDocumentAttachmentParamsBase = Schema_exports.Struct({
+  teamspace: TeamspaceIdentifier.annotations({
+    description: "Teamspace name or ID"
+  }),
+  document: DocumentIdentifier.annotations({
+    description: "Document title or ID"
+  }),
+  ...FileSourceFields
+});
+var AddDocumentAttachmentParamsSchema = AddDocumentAttachmentParamsBase.pipe(
+  Schema_exports.filter(hasFileSource)
+).annotations({
+  title: "AddDocumentAttachmentParams",
+  description: "Parameters for adding an attachment to a document"
+});
+var listAttachmentsParamsJsonSchema = JSONSchema_exports.make(ListAttachmentsParamsSchema);
+var getAttachmentParamsJsonSchema = JSONSchema_exports.make(GetAttachmentParamsSchema);
+var addAttachmentParamsJsonSchema = JSONSchema_exports.make(AddAttachmentParamsSchema);
+var updateAttachmentParamsJsonSchema = withAtLeastOneRequired(
+  JSONSchema_exports.make(UpdateAttachmentParamsSchema),
+  UPDATE_ATTACHMENT_FIELDS
+);
+var deleteAttachmentParamsJsonSchema = JSONSchema_exports.make(DeleteAttachmentParamsSchema);
+var pinAttachmentParamsJsonSchema = JSONSchema_exports.make(PinAttachmentParamsSchema);
+var downloadAttachmentParamsJsonSchema = JSONSchema_exports.make(DownloadAttachmentParamsSchema);
+var addIssueAttachmentParamsJsonSchema = JSONSchema_exports.make(AddIssueAttachmentParamsSchema);
+var addDocumentAttachmentParamsJsonSchema = JSONSchema_exports.make(AddDocumentAttachmentParamsSchema);
+var parseListAttachmentsParams = Schema_exports.decodeUnknown(ListAttachmentsParamsSchema);
+var parseGetAttachmentParams = Schema_exports.decodeUnknown(GetAttachmentParamsSchema);
+var parseAddAttachmentParams = Schema_exports.decodeUnknown(AddAttachmentParamsSchema);
+var parseUpdateAttachmentParams = Schema_exports.decodeUnknown(UpdateAttachmentParamsSchema);
+var parseDeleteAttachmentParams = Schema_exports.decodeUnknown(DeleteAttachmentParamsSchema);
+var parsePinAttachmentParams = Schema_exports.decodeUnknown(PinAttachmentParamsSchema);
+var parseDownloadAttachmentParams = Schema_exports.decodeUnknown(DownloadAttachmentParamsSchema);
+var parseAddIssueAttachmentParams = Schema_exports.decodeUnknown(AddIssueAttachmentParamsSchema);
+var parseAddDocumentAttachmentParams = Schema_exports.decodeUnknown(AddDocumentAttachmentParamsSchema);
+var AttachmentSummaryWireSchema = Schema_exports.Struct({
+  id: AttachmentId,
+  class: ObjectClassName,
+  name: AttachmentFileName,
+  type: MimeType,
+  size: AttachmentByteSize,
+  pinned: Schema_exports.optional(Schema_exports.Boolean),
+  description: Schema_exports.optional(AttachmentDescription),
+  metadata: Schema_exports.optional(AttachmentMetadataSchema),
+  modifiedOn: Schema_exports.optional(Timestamp)
+});
+var AttachmentWireSchema = Schema_exports.Struct({
+  id: AttachmentId,
+  class: ObjectClassName,
+  name: AttachmentFileName,
+  type: MimeType,
+  size: AttachmentByteSize,
+  pinned: Schema_exports.optional(Schema_exports.Boolean),
+  readonly: Schema_exports.optional(Schema_exports.Boolean),
+  description: Schema_exports.optional(AttachmentDescription),
+  metadata: Schema_exports.optional(AttachmentMetadataSchema),
+  url: Schema_exports.optional(UrlString),
+  modifiedOn: Schema_exports.optional(Timestamp),
+  createdOn: Schema_exports.optional(Timestamp)
+});
+var ListAttachmentsResultSchema = Schema_exports.Array(AttachmentSummaryWireSchema);
+
+// src/domain/schemas/json-schema.ts
+var withJsonSchemaPropertyDescriptions = (schema, descriptions) => {
+  const properties = Predicate_exports.isRecord(schema) ? schema.properties : void 0;
+  if (!Predicate_exports.isRecord(properties)) return schema;
+  return {
+    ...schema,
+    properties: Object.fromEntries(
+      Object.entries(properties).map(([key, value3]) => {
+        const description = descriptions[key];
+        return [
+          key,
+          description === void 0 || !Predicate_exports.isRecord(value3) ? value3 : { ...value3, description }
+        ];
+      })
+    )
+  };
+};
+var withExactlyOneRequired = (schema, fields) => ({
+  ...schema,
+  oneOf: fields.map((field) => ({ required: [field] }))
+});
+
+// src/domain/schemas/chat-message-attachment-results.ts
+var ResolvedTargetBaseSchema = {
+  space: SpaceId,
+  objectId: DocId,
+  objectClass: ObjectClassName,
+  collection: Schema_exports.Literal("attachments")
+};
+var ChatMessageAttachmentResolvedTargetSchema = Schema_exports.Union(
+  Schema_exports.Struct({
+    kind: Schema_exports.Literal("channel_message"),
+    channelId: ChannelId,
+    channelName: ChannelName,
+    messageId: MessageId,
+    display: NonEmptyString2,
+    ...ResolvedTargetBaseSchema
+  }),
+  Schema_exports.Struct({
+    kind: Schema_exports.Literal("dm_message"),
+    dmId: ChannelId,
+    messageId: MessageId,
+    display: NonEmptyString2,
+    ...ResolvedTargetBaseSchema
+  }),
+  Schema_exports.Struct({
+    kind: Schema_exports.Literal("thread_reply"),
+    channelId: ChannelId,
+    channelName: ChannelName,
+    messageId: MessageId,
+    replyId: ThreadReplyId,
+    display: NonEmptyString2,
+    ...ResolvedTargetBaseSchema
+  })
+).annotations({
+  title: "ChatMessageAttachmentResolvedTarget",
+  description: "Resolved Huly chat message attachment target. objectId/objectClass/space identify the exact object whose attachments collection is being read or mutated."
+});
+var ListChatMessageAttachmentsResultSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentResolvedTargetSchema,
+  attachments: Schema_exports.Array(AttachmentSummaryWireSchema),
+  total: Count
+});
+var GetChatMessageAttachmentResultSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentResolvedTargetSchema,
+  attachment: AttachmentWireSchema
+});
+var AddChatMessageAttachmentResultSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentResolvedTargetSchema,
+  attachmentId: AttachmentId,
+  blobId: BlobId,
+  url: UrlString
+});
+var UpdateChatMessageAttachmentResultSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentResolvedTargetSchema,
+  attachmentId: AttachmentId,
+  updated: Schema_exports.Boolean
+});
+var DeleteChatMessageAttachmentResultSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentResolvedTargetSchema,
+  attachmentId: AttachmentId,
+  deleted: Schema_exports.Boolean
+});
+
+// src/domain/schemas/chat-message-attachments.ts
+var ChannelMessageTargetSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("channel_message"),
+  channel: ChannelIdentifier.annotations({
+    description: "Channel name or ID containing the message."
+  }),
+  messageId: MessageId.annotations({
+    description: "Channel message ID."
+  })
+});
+var DmMessageTargetSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("dm_message"),
+  dm: DirectMessageIdentifier.annotations({
+    description: "Direct-message conversation: either the DM `_id` or a one-to-one participant display name."
+  }),
+  messageId: MessageId.annotations({
+    description: "Direct-message message ID."
+  })
+});
+var ThreadReplyTargetSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("thread_reply"),
+  channel: ChannelIdentifier.annotations({
+    description: "Channel name or ID containing the parent message."
+  }),
+  messageId: MessageId.annotations({
+    description: "Parent channel message ID."
+  }),
+  replyId: ThreadReplyId.annotations({
+    description: "Thread reply ID."
+  })
+});
+var ChatMessageAttachmentTargetSchema = Schema_exports.Union(
+  ChannelMessageTargetSchema,
+  DmMessageTargetSchema,
+  ThreadReplyTargetSchema
+);
+var ChatMessageAttachmentFileFields = {
+  filename: AttachmentFileName.annotations({
+    description: "Name of the file to attach to the chat message or thread reply."
+  }),
+  contentType: MimeType.annotations({
+    description: "MIME type of the file, such as image/png or application/pdf."
+  }),
+  filePath: Schema_exports.optional(LocalFilePath.annotations({
+    description: "Local file path to upload. Mutually exclusive with fileUrl and data."
+  })),
+  fileUrl: Schema_exports.optional(UrlString.annotations({
+    description: "Remote URL to fetch and upload. Mutually exclusive with filePath and data."
+  })),
+  data: Schema_exports.optional(Base64FileData.annotations({
+    description: "Base64-encoded file data. Mutually exclusive with filePath and fileUrl."
+  })),
+  description: Schema_exports.optional(AttachmentDescription.annotations({
+    description: "Optional attachment description."
+  })),
+  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Whether the attachment should be pinned."
+  }))
+};
+var CHAT_MESSAGE_ATTACHMENT_FILE_SOURCE_FIELDS = ["filePath", "fileUrl", "data"];
+var chatMessageAttachmentExactlyOneFileSourceMessage = `Provide exactly one of ${CHAT_MESSAGE_ATTACHMENT_FILE_SOURCE_FIELDS.join(", ")}.`;
+var requireExactlyOneAttachmentFileSource = (params) => CHAT_MESSAGE_ATTACHMENT_FILE_SOURCE_FIELDS.filter((field) => params[field] !== void 0).length === 1 || chatMessageAttachmentExactlyOneFileSourceMessage;
+var ListChatMessageAttachmentsParamsSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentTargetSchema,
+  limit: Schema_exports.optional(LimitParam.annotations({
+    description: `Maximum number of attachments to return (default: ${DEFAULT_LIMIT}).`
+  }))
+}).annotations({
+  title: "ListChatMessageAttachmentsParams",
+  description: "Parameters for listing files attached directly to a Huly chat message or thread reply."
+});
+var GetChatMessageAttachmentParamsSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentTargetSchema,
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID. Must belong directly to the resolved chat message target."
+  })
+}).annotations({
+  title: "GetChatMessageAttachmentParams",
+  description: "Parameters for retrieving one file attached directly to a Huly chat message or thread reply."
+});
+var AddChatMessageAttachmentParamsSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentTargetSchema,
+  ...ChatMessageAttachmentFileFields
+}).pipe(
+  Schema_exports.filter(requireExactlyOneAttachmentFileSource)
+).annotations({
+  title: "AddChatMessageAttachmentParams",
+  description: `Parameters for adding a file to a Huly chat message or thread reply. ${chatMessageAttachmentExactlyOneFileSourceMessage}`
+});
+var UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS = UPDATE_ATTACHMENT_FIELDS;
+var UpdateChatMessageAttachmentParamsSchema = Schema_exports.Struct({
+  target: ChatMessageAttachmentTargetSchema,
+  attachmentId: AttachmentId.annotations({
+    description: "Attachment ID. Must belong directly to the resolved chat message target."
+  }),
+  description: Schema_exports.optional(
+    Schema_exports.NullOr(AttachmentDescription).annotations({
+      description: "New description; use null to clear it."
+    })
+  ),
+  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Pin or unpin the attachment."
+  }))
+}).pipe(
+  Schema_exports.filter(
+    (params) => hasAtLeastOneDefined(params, UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS) ? void 0 : atLeastOneUpdateFieldMessage(UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS)
+  )
+).annotations({
+  title: "UpdateChatMessageAttachmentParams",
+  description: `Parameters for updating chat message attachment metadata. ${atLeastOneUpdateFieldMessage(UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS)}`
+});
+assertUpdateFields()(
+  ["target", "attachmentId"],
+  UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS
+);
+var DeleteChatMessageAttachmentParamsSchema = GetChatMessageAttachmentParamsSchema.annotations({
+  title: "DeleteChatMessageAttachmentParams",
+  description: "Parameters for permanently deleting a file attached directly to a Huly chat message or thread reply."
+});
+var CHAT_MESSAGE_ATTACHMENT_FIELD_DESCRIPTIONS = {
+  target: "Chat attachment target. Use channel_message for a channel message, dm_message for a direct-message message, or thread_reply for a thread reply.",
+  limit: `Maximum number of matching attachments to return (default: ${DEFAULT_LIMIT}).`,
+  attachmentId: "Attachment ID. Must belong directly to the resolved chat message target.",
+  filename: "Name of the file to attach to the chat message or thread reply.",
+  contentType: "MIME type of the file, such as image/png or application/pdf.",
+  filePath: "Local file path to upload. Mutually exclusive with fileUrl and data.",
+  fileUrl: "Remote URL to fetch and upload. Mutually exclusive with filePath and data.",
+  data: "Base64-encoded file data. Mutually exclusive with filePath and fileUrl.",
+  description: "Optional attachment description. Use null on update to clear it.",
+  pinned: "Whether the attachment should be pinned."
+};
+var CHAT_MESSAGE_ATTACHMENT_TARGET_FIELD_DESCRIPTIONS = {
+  kind: "Target kind: channel_message, dm_message, or thread_reply.",
+  channel: "Channel name or ID. Required for channel_message and thread_reply targets.",
+  dm: "Direct-message conversation ID or one-to-one participant display name.",
+  messageId: "Existing message ID. For thread_reply, this is the parent channel message ID.",
+  replyId: "Existing thread reply ID."
+};
+var withRootSchemaMetadata = (schema, title, description) => ({
+  ...schema,
+  title,
+  description
+});
+var withChatMessageAttachmentTargetVariantDescriptions = (schema) => {
+  const properties = Predicate_exports.isRecord(schema) ? schema.properties : void 0;
+  if (!Predicate_exports.isRecord(properties)) return schema;
+  const target = properties.target;
+  if (!Predicate_exports.isRecord(target) || !Array.isArray(target.anyOf)) return schema;
+  return {
+    ...schema,
+    properties: {
+      ...properties,
+      target: {
+        ...target,
+        anyOf: target.anyOf.map(
+          (variant) => Predicate_exports.isRecord(variant) ? withJsonSchemaPropertyDescriptions(variant, CHAT_MESSAGE_ATTACHMENT_TARGET_FIELD_DESCRIPTIONS) : variant
+        )
+      }
+    }
+  };
+};
+var chatMessageAttachmentJsonSchema = (schema) => withChatMessageAttachmentTargetVariantDescriptions(
+  withJsonSchemaPropertyDescriptions(JSONSchema_exports.make(schema), CHAT_MESSAGE_ATTACHMENT_FIELD_DESCRIPTIONS)
+);
+var withExactlyOneChatMessageAttachmentFileSource = (schema) => withExactlyOneRequired(schema, CHAT_MESSAGE_ATTACHMENT_FILE_SOURCE_FIELDS);
+var listChatMessageAttachmentsParamsJsonSchema = chatMessageAttachmentJsonSchema(
+  ListChatMessageAttachmentsParamsSchema
+);
+var getChatMessageAttachmentParamsJsonSchema = chatMessageAttachmentJsonSchema(
+  GetChatMessageAttachmentParamsSchema
+);
+var addChatMessageAttachmentParamsJsonSchema = withExactlyOneChatMessageAttachmentFileSource(
+  withRootSchemaMetadata(
+    chatMessageAttachmentJsonSchema(AddChatMessageAttachmentParamsSchema),
+    "AddChatMessageAttachmentParams",
+    `Parameters for adding a file to a Huly chat message or thread reply. ${chatMessageAttachmentExactlyOneFileSourceMessage}`
+  )
+);
+var updateChatMessageAttachmentParamsJsonSchema = withAtLeastOneRequired(
+  chatMessageAttachmentJsonSchema(UpdateChatMessageAttachmentParamsSchema),
+  UPDATE_CHAT_MESSAGE_ATTACHMENT_FIELDS
+);
+var deleteChatMessageAttachmentParamsJsonSchema = chatMessageAttachmentJsonSchema(
+  DeleteChatMessageAttachmentParamsSchema
+);
+var parseListChatMessageAttachmentsParams = Schema_exports.decodeUnknown(ListChatMessageAttachmentsParamsSchema);
+var parseGetChatMessageAttachmentParams = Schema_exports.decodeUnknown(GetChatMessageAttachmentParamsSchema);
+var parseAddChatMessageAttachmentParams = Schema_exports.decodeUnknown(AddChatMessageAttachmentParamsSchema);
+var parseUpdateChatMessageAttachmentParams = Schema_exports.decodeUnknown(UpdateChatMessageAttachmentParamsSchema);
+var parseDeleteChatMessageAttachmentParams = Schema_exports.decodeUnknown(DeleteChatMessageAttachmentParamsSchema);
+
 // src/domain/schemas/direct-messages.ts
 var ListDmMessagesParamsSchema = Schema_exports.Struct({
   dm: DirectMessageIdentifier.annotations({
@@ -172831,78 +173397,6 @@ var UNKNOWN_SEARCH_TOTAL = UNKNOWN_TOTAL;
 var fulltextSearchParamsJsonSchema = JSONSchema_exports.make(FulltextSearchParamsSchema);
 var parseFulltextSearchParams = Schema_exports.decodeUnknown(FulltextSearchParamsSchema);
 
-// src/domain/schemas/domain-values.ts
-var LocalFilePath = Schema_exports.String.pipe(Schema_exports.brand("LocalFilePath")).annotations({
-  identifier: "LocalFilePath",
-  title: "LocalFilePath",
-  description: "Host-local file path used only as an upload transport input. It is not a Huly domain identifier and may be OS-specific."
-});
-var Base64FileData = Schema_exports.String.pipe(Schema_exports.brand("Base64FileData")).annotations({
-  identifier: "Base64FileData",
-  title: "Base64FileData",
-  description: "Base64-encoded upload payload. It is transport data rather than a Huly domain value, but is branded to avoid arbitrary text confusion."
-});
-var AttachmentFileName = NonEmptyString2.pipe(Schema_exports.brand("AttachmentFileName")).annotations({
-  identifier: "AttachmentFileName",
-  title: "AttachmentFileName",
-  description: "Non-empty attachment filename as stored by Huly."
-});
-var AttachmentDescription = Schema_exports.String.pipe(Schema_exports.brand("AttachmentDescription")).annotations({
-  identifier: "AttachmentDescription",
-  title: "AttachmentDescription",
-  description: "Free-form attachment description. Empty string is valid because Huly uses it to clear descriptions."
-});
-var AttachmentByteSize = NonNegativeInteger.pipe(Schema_exports.brand("AttachmentByteSize")).annotations({
-  identifier: "AttachmentByteSize",
-  title: "AttachmentByteSize",
-  description: "Attachment size in bytes. Must be a non-negative integer, never a fraction or negative value."
-});
-var AttachmentMetadataKey = Schema_exports.String.pipe(Schema_exports.brand("AttachmentMetadataKey")).annotations({
-  identifier: "AttachmentMetadataKey",
-  title: "AttachmentMetadataKey",
-  description: "Open attachment metadata record key supplied by the Huly SDK. It is not a closed MCP domain enum."
-});
-var DisplayText = NonEmptyString2.pipe(Schema_exports.brand("DisplayText")).annotations({
-  identifier: "DisplayText",
-  title: "DisplayText",
-  description: "Human-readable display text from Huly model metadata or user-authored content."
-});
-var ActivityMarkup = Schema_exports.String.pipe(Schema_exports.brand("ActivityMarkup")).annotations({
-  identifier: "ActivityMarkup",
-  title: "ActivityMarkup",
-  description: "Huly activity markup payload. Empty string is valid when the SDK stores cleared content."
-});
-var ActivityMarkdown = Schema_exports.String.pipe(Schema_exports.brand("ActivityMarkdown")).annotations({
-  identifier: "ActivityMarkdown",
-  title: "ActivityMarkdown",
-  description: "Markdown projection of a Huly activity markup payload for MCP responses."
-});
-var MentionContent = Schema_exports.String.pipe(Schema_exports.brand("MentionContent")).annotations({
-  identifier: "MentionContent",
-  title: "MentionContent",
-  description: "User-authored activity mention snippet returned by Huly."
-});
-var DrawingContent = Schema_exports.String.pipe(Schema_exports.brand("DrawingContent")).annotations({
-  identifier: "DrawingContent",
-  title: "DrawingContent",
-  description: "Opaque drawing content payload stored by Huly."
-});
-var ActivityFilterPosition = Integer.pipe(Schema_exports.brand("ActivityFilterPosition")).annotations({
-  identifier: "ActivityFilterPosition",
-  title: "ActivityFilterPosition",
-  description: "Integer display order for an activity filter."
-});
-var NotificationProviderOrder = Integer.pipe(Schema_exports.brand("NotificationProviderOrder")).annotations({
-  identifier: "NotificationProviderOrder",
-  title: "NotificationProviderOrder",
-  description: "Integer display order for a notification provider."
-});
-var NotificationFieldName = NonEmptyString2.pipe(Schema_exports.brand("NotificationFieldName")).annotations({
-  identifier: "NotificationFieldName",
-  title: "NotificationFieldName",
-  description: "Huly document field name associated with a notification type."
-});
-
 // src/domain/schemas/activity.ts
 var ActivityCount = Count.pipe(Schema_exports.brand("ActivityCount")).annotations({
   identifier: "ActivityCount",
@@ -173310,212 +173804,6 @@ var ListActivityFiltersResultSchema = Schema_exports.Array(ActivityFilterWireSch
 var ListActivityReferencesResultSchema = Schema_exports.Array(ActivityReferenceWireSchema);
 var ListActivityRepliesResultSchema = Schema_exports.Array(ActivityMessageWireSchema);
 
-// src/domain/schemas/attachments.ts
-var DEFAULT_ATTACHMENT_PINNED = false;
-var AttachmentKindSchema = Schema_exports.Literal("attachment", "embedding", "photo").annotations({
-  title: "AttachmentKind",
-  description: "Attachment class to create: attachment, embedding, or photo. Defaults to attachment."
-});
-var AttachmentMetadataSchema = Schema_exports.Record({ key: AttachmentMetadataKey, value: Schema_exports.Unknown });
-var ListAttachmentsParamsSchema = Schema_exports.Struct({
-  objectId: DocId.annotations({
-    description: "ID of the parent object (issue, document, etc.)"
-  }),
-  objectClass: ObjectClassName.annotations({
-    description: "Class of the parent object (e.g., 'tracker:class:Issue', 'document:class:Document')"
-  }),
-  limit: Schema_exports.optional(
-    LimitParam.annotations({
-      description: `Maximum number of attachments to return (default: ${DEFAULT_LIMIT})`
-    })
-  )
-}).annotations({
-  title: "ListAttachmentsParams",
-  description: "Parameters for listing attachments on an object"
-});
-var GetAttachmentParamsSchema = Schema_exports.Struct({
-  attachmentId: AttachmentId.annotations({
-    description: "Attachment ID"
-  })
-}).annotations({
-  title: "GetAttachmentParams",
-  description: "Parameters for getting a single attachment"
-});
-var FileSourceFields = {
-  filename: AttachmentFileName.annotations({
-    description: "Name of the file"
-  }),
-  contentType: MimeType.annotations({
-    description: "MIME type of the file (e.g., 'image/png', 'application/pdf')"
-  }),
-  filePath: Schema_exports.optional(LocalFilePath.annotations({
-    description: "Local file path to upload (preferred - avoids context flooding)"
-  })),
-  fileUrl: Schema_exports.optional(UrlString.annotations({
-    description: "URL to fetch file from (for remote files)"
-  })),
-  data: Schema_exports.optional(Base64FileData.annotations({
-    description: "Base64-encoded file data (fallback for small files <10KB)"
-  })),
-  description: Schema_exports.optional(AttachmentDescription.annotations({
-    description: "Attachment description"
-  })),
-  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
-    description: `Whether to pin the attachment (default: ${DEFAULT_ATTACHMENT_PINNED})`
-  })),
-  kind: Schema_exports.optional(AttachmentKindSchema.annotations({
-    description: "Attachment subclass to create: attachment, embedding, or photo (default: attachment)."
-  }))
-};
-var hasFileSource = (params) => {
-  const hasSource = params.filePath || params.fileUrl || params.data;
-  return hasSource ? true : "Must provide filePath, fileUrl, or data";
-};
-var AddAttachmentParamsBase = Schema_exports.Struct({
-  objectId: DocId.annotations({
-    description: "ID of the parent object (issue, document, etc.)"
-  }),
-  objectClass: ObjectClassName.annotations({
-    description: "Class of the parent object (e.g., 'tracker:class:Issue', 'document:class:Document')"
-  }),
-  space: SpaceId.annotations({
-    description: "Space ID where the parent object resides"
-  }),
-  ...FileSourceFields
-});
-var AddAttachmentParamsSchema = AddAttachmentParamsBase.pipe(
-  Schema_exports.filter(hasFileSource)
-).annotations({
-  title: "AddAttachmentParams",
-  description: "Parameters for adding an attachment. Provide ONE of: filePath, fileUrl, or data"
-});
-var UPDATE_ATTACHMENT_FIELDS = ["description", "pinned"];
-var UpdateAttachmentParamsSchema = Schema_exports.Struct({
-  attachmentId: AttachmentId.annotations({
-    description: "Attachment ID"
-  }),
-  description: Schema_exports.optional(
-    Schema_exports.NullOr(AttachmentDescription).annotations({
-      description: "New description (null to clear)"
-    })
-  ),
-  pinned: Schema_exports.optional(Schema_exports.Boolean.annotations({
-    description: "Pin or unpin the attachment"
-  }))
-}).pipe(
-  Schema_exports.filter(
-    (params) => hasAtLeastOneDefined(params, UPDATE_ATTACHMENT_FIELDS) ? void 0 : atLeastOneUpdateFieldMessage(UPDATE_ATTACHMENT_FIELDS)
-  )
-).annotations({
-  title: "UpdateAttachmentParams",
-  description: `Parameters for updating an attachment. ${atLeastOneUpdateFieldMessage(UPDATE_ATTACHMENT_FIELDS)}`
-});
-assertUpdateFields()(["attachmentId"], UPDATE_ATTACHMENT_FIELDS);
-var DeleteAttachmentParamsSchema = Schema_exports.Struct({
-  attachmentId: AttachmentId.annotations({
-    description: "Attachment ID to delete"
-  })
-}).annotations({
-  title: "DeleteAttachmentParams",
-  description: "Parameters for deleting an attachment"
-});
-var PinAttachmentParamsSchema = Schema_exports.Struct({
-  attachmentId: AttachmentId.annotations({
-    description: "Attachment ID"
-  }),
-  pinned: Schema_exports.Boolean.annotations({
-    description: "Whether to pin (true) or unpin (false)"
-  })
-}).annotations({
-  title: "PinAttachmentParams",
-  description: "Parameters for pinning/unpinning an attachment"
-});
-var DownloadAttachmentParamsSchema = Schema_exports.Struct({
-  attachmentId: AttachmentId.annotations({
-    description: "Attachment ID"
-  })
-}).annotations({
-  title: "DownloadAttachmentParams",
-  description: "Parameters for getting attachment download URL"
-});
-var AddIssueAttachmentParamsBase = Schema_exports.Struct({
-  project: ProjectIdentifier.annotations({
-    description: "Project identifier (e.g., 'HULY')"
-  }),
-  identifier: IssueIdentifier.annotations({
-    description: "Issue identifier (e.g., 'HULY-123')"
-  }),
-  ...FileSourceFields
-});
-var AddIssueAttachmentParamsSchema = AddIssueAttachmentParamsBase.pipe(
-  Schema_exports.filter(hasFileSource)
-).annotations({
-  title: "AddIssueAttachmentParams",
-  description: "Parameters for adding an attachment to an issue"
-});
-var AddDocumentAttachmentParamsBase = Schema_exports.Struct({
-  teamspace: TeamspaceIdentifier.annotations({
-    description: "Teamspace name or ID"
-  }),
-  document: DocumentIdentifier.annotations({
-    description: "Document title or ID"
-  }),
-  ...FileSourceFields
-});
-var AddDocumentAttachmentParamsSchema = AddDocumentAttachmentParamsBase.pipe(
-  Schema_exports.filter(hasFileSource)
-).annotations({
-  title: "AddDocumentAttachmentParams",
-  description: "Parameters for adding an attachment to a document"
-});
-var listAttachmentsParamsJsonSchema = JSONSchema_exports.make(ListAttachmentsParamsSchema);
-var getAttachmentParamsJsonSchema = JSONSchema_exports.make(GetAttachmentParamsSchema);
-var addAttachmentParamsJsonSchema = JSONSchema_exports.make(AddAttachmentParamsSchema);
-var updateAttachmentParamsJsonSchema = withAtLeastOneRequired(
-  JSONSchema_exports.make(UpdateAttachmentParamsSchema),
-  UPDATE_ATTACHMENT_FIELDS
-);
-var deleteAttachmentParamsJsonSchema = JSONSchema_exports.make(DeleteAttachmentParamsSchema);
-var pinAttachmentParamsJsonSchema = JSONSchema_exports.make(PinAttachmentParamsSchema);
-var downloadAttachmentParamsJsonSchema = JSONSchema_exports.make(DownloadAttachmentParamsSchema);
-var addIssueAttachmentParamsJsonSchema = JSONSchema_exports.make(AddIssueAttachmentParamsSchema);
-var addDocumentAttachmentParamsJsonSchema = JSONSchema_exports.make(AddDocumentAttachmentParamsSchema);
-var parseListAttachmentsParams = Schema_exports.decodeUnknown(ListAttachmentsParamsSchema);
-var parseGetAttachmentParams = Schema_exports.decodeUnknown(GetAttachmentParamsSchema);
-var parseAddAttachmentParams = Schema_exports.decodeUnknown(AddAttachmentParamsSchema);
-var parseUpdateAttachmentParams = Schema_exports.decodeUnknown(UpdateAttachmentParamsSchema);
-var parseDeleteAttachmentParams = Schema_exports.decodeUnknown(DeleteAttachmentParamsSchema);
-var parsePinAttachmentParams = Schema_exports.decodeUnknown(PinAttachmentParamsSchema);
-var parseDownloadAttachmentParams = Schema_exports.decodeUnknown(DownloadAttachmentParamsSchema);
-var parseAddIssueAttachmentParams = Schema_exports.decodeUnknown(AddIssueAttachmentParamsSchema);
-var parseAddDocumentAttachmentParams = Schema_exports.decodeUnknown(AddDocumentAttachmentParamsSchema);
-var AttachmentSummaryWireSchema = Schema_exports.Struct({
-  id: AttachmentId,
-  class: ObjectClassName,
-  name: AttachmentFileName,
-  type: MimeType,
-  size: AttachmentByteSize,
-  pinned: Schema_exports.optional(Schema_exports.Boolean),
-  description: Schema_exports.optional(AttachmentDescription),
-  metadata: Schema_exports.optional(AttachmentMetadataSchema),
-  modifiedOn: Schema_exports.optional(Timestamp)
-});
-var AttachmentWireSchema = Schema_exports.Struct({
-  id: AttachmentId,
-  class: ObjectClassName,
-  name: AttachmentFileName,
-  type: MimeType,
-  size: AttachmentByteSize,
-  pinned: Schema_exports.optional(Schema_exports.Boolean),
-  readonly: Schema_exports.optional(Schema_exports.Boolean),
-  description: Schema_exports.optional(AttachmentDescription),
-  metadata: Schema_exports.optional(AttachmentMetadataSchema),
-  url: Schema_exports.optional(UrlString),
-  modifiedOn: Schema_exports.optional(Timestamp),
-  createdOn: Schema_exports.optional(Timestamp)
-});
-var ListAttachmentsResultSchema = Schema_exports.Array(AttachmentSummaryWireSchema);
-
 // src/domain/schemas/attachment-extras.ts
 var SaveAttachmentParamsSchema = Schema_exports.Struct({
   attachmentId: AttachmentId.annotations({
@@ -175168,28 +175456,6 @@ var parseCreateRecruitingOpinionParams = Schema_exports.decodeUnknown(CreateRecr
 var parseUpdateRecruitingOpinionParams = Schema_exports.decodeUnknown(UpdateRecruitingOpinionParamsSchema);
 var parseDeleteRecruitingOpinionParams = Schema_exports.decodeUnknown(DeleteRecruitingOpinionParamsSchema);
 
-// src/domain/schemas/json-schema.ts
-var withJsonSchemaPropertyDescriptions = (schema, descriptions) => {
-  const properties = Predicate_exports.isRecord(schema) ? schema.properties : void 0;
-  if (!Predicate_exports.isRecord(properties)) return schema;
-  return {
-    ...schema,
-    properties: Object.fromEntries(
-      Object.entries(properties).map(([key, value3]) => {
-        const description = descriptions[key];
-        return [
-          key,
-          description === void 0 || !Predicate_exports.isRecord(value3) ? value3 : { ...value3, description }
-        ];
-      })
-    )
-  };
-};
-var withExactlyOneRequired = (schema, fields) => ({
-  ...schema,
-  oneOf: fields.map((field) => ({ required: [field] }))
-});
-
 // src/domain/schemas/recruiting-media-results.ts
 var RecruitingTargetBaseSchema = {
   objectClass: ObjectClassName,
@@ -175397,7 +175663,7 @@ var RecruitingAttachmentFileFields = {
 };
 var RECRUITING_ATTACHMENT_FILE_SOURCE_FIELDS = ["filePath", "fileUrl", "data"];
 var recruitingAttachmentExactlyOneFileSourceMessage = `Provide exactly one of ${RECRUITING_ATTACHMENT_FILE_SOURCE_FIELDS.join(", ")}.`;
-var requireExactlyOneAttachmentFileSource = (params) => RECRUITING_ATTACHMENT_FILE_SOURCE_FIELDS.filter((field) => params[field] !== void 0).length === 1 || recruitingAttachmentExactlyOneFileSourceMessage;
+var requireExactlyOneAttachmentFileSource2 = (params) => RECRUITING_ATTACHMENT_FILE_SOURCE_FIELDS.filter((field) => params[field] !== void 0).length === 1 || recruitingAttachmentExactlyOneFileSourceMessage;
 var ListRecruitingCommentsParamsSchema = Schema_exports.Struct({
   target: RecruitingCommentTargetSchema,
   limit: Schema_exports.optional(LimitParam.annotations({
@@ -175440,7 +175706,7 @@ var GetRecruitingAttachmentParamsSchema = Schema_exports.Struct({
 var AddRecruitingAttachmentParamsSchema = Schema_exports.Struct({
   target: RecruitingAttachmentTargetSchema,
   ...RecruitingAttachmentFileFields
-}).pipe(Schema_exports.filter(requireExactlyOneAttachmentFileSource));
+}).pipe(Schema_exports.filter(requireExactlyOneAttachmentFileSource2));
 var UPDATE_RECRUITING_ATTACHMENT_FIELDS = UPDATE_ATTACHMENT_FIELDS;
 var UpdateRecruitingAttachmentParamsSchema = Schema_exports.Struct({
   target: RecruitingAttachmentTargetSchema,
@@ -176335,7 +176601,7 @@ var makeDiagnosticsScope = Effect_exports.gen(function* () {
 });
 
 // src/version.ts
-var VERSION = true ? "0.35.0" : "0.0.0-dev";
+var VERSION = true ? "0.36.0" : "0.0.0-dev";
 
 // src/mcp/tool-output-schema.ts
 var toolWarningCodeEnum = [...ToolWarningCodeSchema.literals];
@@ -176470,6 +176736,23 @@ var findActivityMessage = (client, messageId) => findOneOrFail(
 );
 
 // src/huly/operations/thread-replies-shared.ts
+var findThreadReply = (client, channel, message, replyId) => Effect_exports.gen(function* () {
+  const reply = yield* client.findOne(
+    chunter.class.ThreadMessage,
+    hulyQuery({
+      _id: toRef(replyId),
+      attachedTo: toRef(message._id),
+      space: channel._id
+    })
+  );
+  if (reply === void 0) {
+    return yield* new ThreadReplyNotFoundError({
+      replyId,
+      messageId: message._id
+    });
+  }
+  return reply;
+});
 var removeThreadReply = (client, reply) => Effect_exports.gen(function* () {
   const removeCollection = client.removeCollection;
   if (removeCollection === void 0) {
@@ -177524,7 +177807,8 @@ var listChannelMessages = (params) => Effect_exports.gen(function* () {
       createdOn: msg.createdOn,
       modifiedOn: msg.modifiedOn,
       editedOn: msg.editedOn,
-      replies: optionalCount(msg.replies)
+      replies: optionalCount(msg.replies),
+      attachments: optionalCount(msg.attachments)
     };
   });
   return { messages: summaries, total: listTotal(total) };
@@ -181427,7 +181711,8 @@ var listDirectMessageMessages = (params) => Effect_exports.gen(function* () {
       createdOn: msg.createdOn,
       modifiedOn: msg.modifiedOn,
       editedOn: msg.editedOn,
-      replies: optionalCount(msg.replies)
+      replies: optionalCount(msg.replies),
+      attachments: optionalCount(msg.attachments)
     };
   });
   return { messages: summaries, total: listTotal(total) };
@@ -181502,6 +181787,192 @@ var createDirectMessage = (params) => Effect_exports.gen(function* () {
   return { id: ChannelId.make(dmId), created: true };
 });
 
+// src/huly/operations/chat-message-attachments.ts
+var chatMessageScope = (target) => ({
+  classRef: attachment.class.Attachment,
+  attachedTo: target.objectId,
+  attachedToClass: target.objectClass,
+  collection: target.collection
+});
+var channelMessageDisplay = (messageId, channelName) => NonEmptyString2.make(`channel message '${messageId}' in channel '${channelName}'`);
+var dmMessageDisplay = (messageId, dmId) => NonEmptyString2.make(`DM message '${messageId}' in direct message '${dmId}'`);
+var threadReplyDisplay = (replyId, messageId, channelName) => NonEmptyString2.make(`thread reply '${replyId}' on message '${messageId}' in channel '${channelName}'`);
+var targetCoordinates = (space, objectId, objectClass) => ({
+  space,
+  objectId,
+  objectClass,
+  collection: "attachments",
+  spaceId: SpaceId.make(space),
+  docId: DocId.make(objectId),
+  className: ObjectClassName.make(objectClass)
+});
+var resolveChannelMessageTarget = (target) => Effect_exports.gen(function* () {
+  const { channel, client, message } = yield* findChannelMessage(target);
+  const messageId = MessageId.make(message._id);
+  const coordinates2 = targetCoordinates(
+    message.space,
+    toRef(DocId.make(message._id)),
+    toRef(chunter.class.ChatMessage)
+  );
+  return {
+    client,
+    space: coordinates2.space,
+    objectId: coordinates2.objectId,
+    objectClass: coordinates2.objectClass,
+    collection: coordinates2.collection,
+    target: {
+      kind: "channel_message",
+      channelId: ChannelId.make(channel._id),
+      channelName: ChannelName.make(channel.name),
+      messageId,
+      display: channelMessageDisplay(messageId, channel.name),
+      space: coordinates2.spaceId,
+      objectId: coordinates2.docId,
+      objectClass: coordinates2.className,
+      collection: coordinates2.collection
+    }
+  };
+});
+var resolveDmMessageTarget = (target) => Effect_exports.gen(function* () {
+  const { client, dm, message } = yield* findDirectMessageMessage(target);
+  const messageId = MessageId.make(message._id);
+  const dmId = ChannelId.make(dm._id);
+  const coordinates2 = targetCoordinates(
+    message.space,
+    toRef(DocId.make(message._id)),
+    toRef(chunter.class.ChatMessage)
+  );
+  return {
+    client,
+    space: coordinates2.space,
+    objectId: coordinates2.objectId,
+    objectClass: coordinates2.objectClass,
+    collection: coordinates2.collection,
+    target: {
+      kind: "dm_message",
+      dmId,
+      messageId,
+      display: dmMessageDisplay(messageId, dmId),
+      space: coordinates2.spaceId,
+      objectId: coordinates2.docId,
+      objectClass: coordinates2.className,
+      collection: coordinates2.collection
+    }
+  };
+});
+var resolveThreadReplyTarget = (target) => Effect_exports.gen(function* () {
+  const { channel, client, message } = yield* findChannelMessage(target);
+  const reply = yield* findThreadReply(client, channel, message, target.replyId);
+  const messageId = MessageId.make(message._id);
+  const replyId = ThreadReplyId.make(reply._id);
+  const coordinates2 = targetCoordinates(
+    reply.space,
+    toRef(DocId.make(reply._id)),
+    toRef(chunter.class.ThreadMessage)
+  );
+  return {
+    client,
+    space: coordinates2.space,
+    objectId: coordinates2.objectId,
+    objectClass: coordinates2.objectClass,
+    collection: coordinates2.collection,
+    target: {
+      kind: "thread_reply",
+      channelId: ChannelId.make(channel._id),
+      channelName: ChannelName.make(channel.name),
+      messageId,
+      replyId,
+      display: threadReplyDisplay(replyId, messageId, channel.name),
+      space: coordinates2.spaceId,
+      objectId: coordinates2.docId,
+      objectClass: coordinates2.className,
+      collection: coordinates2.collection
+    }
+  };
+});
+var resolveChatAttachmentTarget = (target) => {
+  switch (target.kind) {
+    case "channel_message":
+      return resolveChannelMessageTarget(target);
+    case "dm_message":
+      return resolveDmMessageTarget(target);
+    case "thread_reply":
+      return resolveThreadReplyTarget(target);
+  }
+};
+var scopedAttachmentNotFound = (target, attachmentId) => new ChatMessageAttachmentNotFoundError({
+  target: target.target.display,
+  attachmentId
+});
+var removeChatAttachment = (target, attachmentId) => Effect_exports.gen(function* () {
+  const media = yield* findAttachmentForScope(target.client, attachmentId, chatMessageScope(target)).pipe(
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, attachmentId))
+  );
+  const removeCollection = target.client.removeCollection;
+  if (removeCollection === void 0) {
+    return yield* new HulyError({ message: "Huly client does not support removeCollection" });
+  }
+  yield* removeCollection(
+    attachment.class.Attachment,
+    media.space,
+    media._id,
+    target.objectId,
+    target.objectClass,
+    target.collection
+  );
+});
+var listChatMessageAttachments = (params) => Effect_exports.gen(function* () {
+  const target = yield* resolveChatAttachmentTarget(params.target);
+  const page = yield* listAttachmentPageForScope(target.client, chatMessageScope(target), params.limit);
+  return { target: target.target, attachments: page.attachments, total: page.total };
+});
+var getChatMessageAttachment = (params) => Effect_exports.gen(function* () {
+  const storageClient = yield* HulyStorageClient;
+  const target = yield* resolveChatAttachmentTarget(params.target);
+  const attachmentResult = yield* getAttachmentForScope(
+    target.client,
+    storageClient,
+    params.attachmentId,
+    chatMessageScope(target)
+  ).pipe(
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, params.attachmentId))
+  );
+  return { target: target.target, attachment: attachmentResult };
+});
+var addChatMessageAttachment = (params) => Effect_exports.gen(function* () {
+  const target = yield* resolveChatAttachmentTarget(params.target);
+  const result = yield* uploadAndAttach(params, {
+    spaceRef: target.space,
+    objectRef: target.objectId,
+    objectClassRef: target.objectClass,
+    attachmentClassRef: attachment.class.Attachment,
+    collection: target.collection
+  });
+  return {
+    target: target.target,
+    attachmentId: result.attachmentId,
+    blobId: result.blobId,
+    url: result.url
+  };
+});
+var updateChatMessageAttachment = (params) => Effect_exports.gen(function* () {
+  const target = yield* resolveChatAttachmentTarget(params.target);
+  yield* updateAttachmentForScope(
+    target.client,
+    params.attachmentId,
+    params,
+    chatMessageScope(target)
+  ).pipe(
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, params.attachmentId))
+  );
+  return { target: target.target, attachmentId: params.attachmentId, updated: true };
+});
+var deleteChatMessageAttachment = (params) => Effect_exports.gen(function* () {
+  const target = yield* resolveChatAttachmentTarget(params.target);
+  yield* removeChatAttachment(target, params.attachmentId);
+  return { target: target.target, attachmentId: params.attachmentId, deleted: true };
+});
+
 // src/huly/operations/external-channel-messages.ts
 var EXTERNAL_CHANNEL_PACKAGE_INCOMPATIBLE_REASON = "package-incompatible: package.json and pnpm-lock.yaml include @hcengineering/contact provider refs for email/telegram, but no compatible Huly Gmail or Telegram message SDK package/model is installed; local platform-api examples only expose contact.class.Channel provider values, not external message documents";
 var listExternalChannelMessages = (params) => Effect_exports.sync(
@@ -181517,23 +181988,6 @@ var listExternalChannelMessages = (params) => Effect_exports.sync(
 
 // src/huly/operations/threads.ts
 var import_core32 = __toESM(require_lib4(), 1);
-var findReply = (client, channel, message, replyId) => Effect_exports.gen(function* () {
-  const reply = yield* client.findOne(
-    chunter.class.ThreadMessage,
-    {
-      _id: toRef(replyId),
-      attachedTo: toRef(message._id),
-      space: channel._id
-    }
-  );
-  if (reply === void 0) {
-    return yield* new ThreadReplyNotFoundError({
-      replyId,
-      messageId: message._id
-    });
-  }
-  return reply;
-});
 var listThreadReplies = (params) => Effect_exports.gen(function* () {
   const { channel, client, message } = yield* findChannelMessage(params);
   const markupUrlConfig = client.markupUrlConfig;
@@ -181567,7 +182021,8 @@ var listThreadReplies = (params) => Effect_exports.gen(function* () {
       senderId: msg.modifiedBy,
       createdOn: msg.createdOn,
       modifiedOn: msg.modifiedOn,
-      editedOn: msg.editedOn
+      editedOn: msg.editedOn,
+      attachments: optionalCount(msg.attachments)
     };
   });
   return { replies: threadMessages, total: listTotal(total) };
@@ -181600,7 +182055,7 @@ var addThreadReply = (params) => Effect_exports.gen(function* () {
 });
 var updateThreadReply = (params) => Effect_exports.gen(function* () {
   const { channel, client, message } = yield* findChannelMessage(params);
-  const reply = yield* findReply(client, channel, message, params.replyId);
+  const reply = yield* findThreadReply(client, channel, message, params.replyId);
   const markupUrlConfig = client.markupUrlConfig;
   const markup = markdownToMarkupString(params.body, markupUrlConfig);
   const now2 = yield* Clock_exports.currentTimeMillis;
@@ -181618,7 +182073,7 @@ var updateThreadReply = (params) => Effect_exports.gen(function* () {
 });
 var deleteThreadReply = (params) => Effect_exports.gen(function* () {
   const { channel, client, message } = yield* findChannelMessage(params);
-  const reply = yield* findReply(client, channel, message, params.replyId);
+  const reply = yield* findThreadReply(client, channel, message, params.replyId);
   yield* removeThreadReply(client, reply);
   return { id: ThreadReplyId.make(reply._id), deleted: true };
 });
@@ -181961,6 +182416,66 @@ var channelTools = [
       parseDeleteThreadReplyParams,
       deleteThreadReply
     )
+  },
+  {
+    name: "list_chat_message_attachments",
+    description: "List files attached directly to a Huly chat message target. target.kind supports channel_message, dm_message, and thread_reply; the tool resolves channel names and one-to-one DM participant display names for you.",
+    category: CATEGORY6,
+    inputSchema: listChatMessageAttachmentsParamsJsonSchema,
+    handler: createEncodedToolHandler(
+      "list_chat_message_attachments",
+      parseListChatMessageAttachmentsParams,
+      listChatMessageAttachments,
+      ListChatMessageAttachmentsResultSchema
+    )
+  },
+  {
+    name: "get_chat_message_attachment",
+    description: "Get one file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target.",
+    category: CATEGORY6,
+    inputSchema: getChatMessageAttachmentParamsJsonSchema,
+    handler: createEncodedCombinedToolHandler(
+      "get_chat_message_attachment",
+      parseGetChatMessageAttachmentParams,
+      getChatMessageAttachment,
+      GetChatMessageAttachmentResultSchema
+    )
+  },
+  {
+    name: "add_chat_message_attachment",
+    description: "Attach a file directly to a Huly channel message, direct-message message, or thread reply. Provide filename, contentType, and exactly one of filePath, fileUrl, or data.",
+    category: CATEGORY6,
+    inputSchema: addChatMessageAttachmentParamsJsonSchema,
+    handler: createEncodedCombinedToolHandler(
+      "add_chat_message_attachment",
+      parseAddChatMessageAttachmentParams,
+      addChatMessageAttachment,
+      AddChatMessageAttachmentResultSchema
+    )
+  },
+  {
+    name: "update_chat_message_attachment",
+    description: "Update description and/or pinned state for a file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target.",
+    category: CATEGORY6,
+    inputSchema: updateChatMessageAttachmentParamsJsonSchema,
+    handler: createEncodedToolHandler(
+      "update_chat_message_attachment",
+      parseUpdateChatMessageAttachmentParams,
+      updateChatMessageAttachment,
+      UpdateChatMessageAttachmentResultSchema
+    )
+  },
+  {
+    name: "delete_chat_message_attachment",
+    description: "Delete one file attached directly to a Huly channel message, direct-message message, or thread reply. The attachmentId must belong to the resolved target.",
+    category: CATEGORY6,
+    inputSchema: deleteChatMessageAttachmentParamsJsonSchema,
+    handler: createEncodedToolHandler(
+      "delete_chat_message_attachment",
+      parseDeleteChatMessageAttachmentParams,
+      deleteChatMessageAttachment,
+      DeleteChatMessageAttachmentResultSchema
+    )
   }
 ];
 
@@ -194698,13 +195213,13 @@ var scopedCommentNotFound = (target, commentId) => new RecruitingCommentNotFound
   target: target.display,
   commentId
 });
-var scopedAttachmentNotFound = (target, attachmentId) => new RecruitingAttachmentNotFoundError({
+var scopedAttachmentNotFound2 = (target, attachmentId) => new RecruitingAttachmentNotFoundError({
   target: target.display,
   attachmentId
 });
 var removeRecruitingAttachment = (target, attachmentId) => Effect_exports.gen(function* () {
   const media = yield* findAttachmentForScope(target.client, attachmentId, attachmentScope(target)).pipe(
-    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, attachmentId))
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound2(target, attachmentId))
   );
   const removeCollection = target.client.removeCollection;
   if (removeCollection === void 0) {
@@ -194770,7 +195285,7 @@ var getRecruitingAttachment = (params) => Effect_exports.gen(function* () {
     params.attachmentId,
     attachmentScope(target)
   ).pipe(
-    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, params.attachmentId))
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound2(target, params.attachmentId))
   );
   return { target: target.target, attachment: attachmentResult };
 });
@@ -194800,7 +195315,7 @@ var updateRecruitingAttachment = (params) => Effect_exports.gen(function* () {
     params,
     attachmentScope(target)
   ).pipe(
-    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound(target, params.attachmentId))
+    Effect_exports.catchTag("AttachmentNotFoundError", () => scopedAttachmentNotFound2(target, params.attachmentId))
   );
   return { target: target.target, attachmentId: params.attachmentId, updated: true };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firfi/huly-mcp",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "MCP server for Huly integration",
   "mcpName": "io.github.dearlordylord/huly-mcp",
   "type": "module",