typeclaw 0.23.0 → 0.25.0

package/src/channels/adapters/kakaotalk-classify.ts

@@ -1,8 +1,8 @@
-import type { KakaoTalkPushMessageEvent } from 'agent-messenger/kakaotalk'
+import { KAKAO_MESSAGE_TYPE, type KakaoTalkPushMessageEvent } from 'agent-messenger/kakaotalk'
 
 import { matchesAnyAlias } from '@/channels/engagement'
 import type { ChannelAdapterConfig } from '@/channels/schema'
-import type { InboundAttachment, InboundMessage } from '@/channels/types'
+import type { InboundAttachment, InboundMessage, InboundReferenceContext } from '@/channels/types'
 
 export type InboundDropReason = 'self_author' | 'empty_text' | 'unknown_chat' | 'pre_connect' | 'bot_message'
 
@@ -49,7 +49,9 @@ export function classifyInbound(
     return { kind: 'drop', reason: 'bot_message' }
   }
 
-  const text = event.message ?? ''
+  const rawText = event.message ?? ''
+  const replyContext = parseReplyContext(event, context.selfUserId)
+  const text = rawText
   if (text === '') return { kind: 'drop', reason: 'empty_text' }
 
   const chatInfo = context.lookupChat(event.chat_id)
@@ -64,7 +66,7 @@ export function classifyInbound(
   // mention (see engagement.ts: alias is unconditional and ranks alongside
   // explicit triggers). Without aliases configured, only `reply` and `dm`
   // triggers can fire on KakaoTalk.
-  const aliasMatched = matchesAnyAlias(text, context.selfAliases ?? [])
+  const aliasMatched = matchesAnyAlias(rawText, context.selfAliases ?? [])
 
   return {
     kind: 'route',
@@ -74,6 +76,7 @@ export function classifyInbound(
       chat: event.chat_id,
       thread: null,
       text,
+      ...referenceContextPayload(replyContext),
       ...(context.attachments !== undefined && context.attachments.length > 0
         ? { attachments: context.attachments }
         : {}),
@@ -82,9 +85,9 @@ export function classifyInbound(
       authorName: event.author_name ?? String(event.author_id),
       authorIsBot: false,
       isBotMention: aliasMatched,
-      replyToBotMessageId: null,
+      replyToBotMessageId: replyContext?.target === 'bot' ? replyContext.logId : null,
       mentionsOthers: false,
-      replyToOtherMessageId: null,
+      replyToOtherMessageId: replyContext?.target === 'other' ? replyContext.logId : null,
       isDm: chatInfo.isDm,
       // SDK delivers `sent_at` in Unix seconds (LOCO `sendAt`); contract
       // wants ms (see `src/channels/types.ts`). Without `* 1000`, ms-based
@@ -93,3 +96,61 @@ export function classifyInbound(
     },
   }
 }
+
+type ParsedReplyContext = {
+  logId: string
+  authorId: string
+  authorName: string
+  quotedText: string | null
+  target: 'bot' | 'other'
+}
+
+function parseReplyContext(event: KakaoTalkPushMessageEvent, selfUserId: string): ParsedReplyContext | null {
+  if (event.message_type !== KAKAO_MESSAGE_TYPE.REPLY) return null
+  if (event.attachment === null) return null
+
+  const logId = stringField(event.attachment, 'src_logId')
+  const sourceUserId = numericField(event.attachment, 'src_userId')
+  if (logId === null || sourceUserId === null) return null
+
+  const sourceAuthorId = String(sourceUserId)
+  const quotedText = stringField(event.attachment, 'src_message')
+  return {
+    logId,
+    authorId: sourceAuthorId,
+    // classifyInbound is synchronous and has no cheap author resolver access;
+    // fall back to Kakao's stable source user id rather than fetching.
+    authorName: sourceAuthorId,
+    quotedText,
+    target: sourceAuthorId === selfUserId ? 'bot' : 'other',
+  }
+}
+
+function referenceContextPayload(
+  replyContext: ParsedReplyContext | null,
+): { referenceContext: InboundReferenceContext } | Record<string, never> {
+  if (replyContext === null || replyContext.quotedText === null || replyContext.quotedText.trim() === '') return {}
+  return {
+    referenceContext: {
+      kind: 'reply',
+      sources: [
+        {
+          adapter: 'kakaotalk',
+          authorId: replyContext.authorId,
+          authorName: replyContext.authorName,
+          text: replyContext.quotedText,
+        },
+      ],
+    },
+  }
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+function numericField(record: Record<string, unknown>, key: string): number | null {
+  const value = record[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}

package/src/channels/adapters/slack-bot-classify.ts

@@ -4,6 +4,7 @@ import { matchesAnyAlias } from '@/channels/engagement'
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type { InboundAttachment, InboundMessage } from '@/channels/types'
 
+import { hasSlackMessageShareAttachments } from './slack-bot-reference'
 import { slackTsToMillis } from './slack-bot-time'
 
 export type SlackInboundMessageEvent = SlackSocketModeMessageEvent
@@ -62,7 +63,8 @@ export function classifyInbound(
 
   const rawText = event.text ?? ''
   const { text, attachments } = splitInbound(event)
-  if (text === '') return { kind: 'drop', reason: 'empty_text' }
+  const slackAttachments = Array.isArray(event.attachments) ? event.attachments : undefined
+  if (text === '' && !hasSlackMessageShareAttachments(slackAttachments)) return { kind: 'drop', reason: 'empty_text' }
 
   const isDm = event.channel_type === 'im'
   const workspace = isDm ? '@dm' : context.teamId
@@ -92,6 +94,11 @@ export function classifyInbound(
   // found, keeping the cost negligible in mention-heavy channels.
   const aliasMatched = !isBotMention && matchesAnyAlias(rawText, context.selfAliases ?? [])
   const thread = event.thread_ts ?? (!isDm && (isBotMention || aliasMatched) ? event.ts : null)
+  // DMs stay flat (`thread` null), but Slack's typing status still needs a real
+  // message ts; anchor it on the inbound so the indicator renders without
+  // threading the reply. `assistant.threads.setStatus` accepts any live channel
+  // message ts, confirmed against the API.
+  const typingThread = isDm && thread === null ? event.ts : undefined
 
   // A reply is "to the bot" only when the thread parent was authored by the
   // bot. Slack surfaces the parent author via `parent_user_id` on every
@@ -130,6 +137,7 @@ export function classifyInbound(
       workspace,
       chat: event.channel,
       thread,
+      ...(typingThread !== undefined ? { typingThread } : {}),
       text,
       ...(attachments.length > 0 ? { attachments } : {}),
       externalMessageId: event.ts,

package/src/channels/adapters/slack-bot-reference.ts

@@ -0,0 +1,129 @@
+import type { InboundReferenceContext, QuoteAnchorSource } from '@/channels/types'
+
+export type SlackResolvedReference = {
+  authorId: string
+  authorName: string
+  text: string
+}
+
+export type SlackReferenceFetch = (channelId: string, messageTs: string) => Promise<SlackResolvedReference | null>
+
+export type SlackMessagePointer = {
+  channelId: string
+  messageTs: string
+}
+
+export async function enrichSlackReferenceContext(args: {
+  text: string
+  channelId: string
+  threadTs?: string
+  messageTs: string
+  attachments?: readonly unknown[]
+  fetchMessage: SlackReferenceFetch
+  linkLimit?: number
+}): Promise<{ text: string; referenceContext?: InboundReferenceContext }> {
+  const sources: QuoteAnchorSource[] = []
+  let kind: InboundReferenceContext['kind'] = 'link'
+
+  if (args.threadTs !== undefined && args.threadTs !== args.messageTs) {
+    const parent = await fetchSafely(args.fetchMessage, { channelId: args.channelId, messageTs: args.threadTs })
+    if (parent !== null) {
+      sources.push(toSource(parent))
+      kind = 'reply'
+    }
+  }
+
+  for (const source of extractSlackShareSources(args.attachments ?? [])) {
+    sources.push(source)
+    if (kind !== 'reply') kind = 'quote'
+  }
+
+  const links = extractSlackMessageLinks(args.text).slice(0, args.linkLimit ?? 3)
+  const seen = new Set(sources.map((source) => `${source.authorId}\x00${source.text}`))
+  for (const link of links) {
+    const message = await fetchSafely(args.fetchMessage, link)
+    if (message === null) continue
+    const source = toSource(message)
+    const key = `${source.authorId}\x00${source.text}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    sources.push(source)
+  }
+
+  if (sources.length === 0) return { text: args.text }
+  return { text: args.text, referenceContext: { kind, sources } }
+}
+
+export function hasSlackMessageShareAttachments(attachments: readonly unknown[] | undefined): boolean {
+  return extractSlackShareSources(attachments ?? []).length > 0
+}
+
+const SLACK_ARCHIVE_LINK = /https?:\/\/[^\s/]+\.slack\.com\/archives\/([^/\s]+)\/p(\d{10})(\d{6})/g
+
+function extractSlackMessageLinks(text: string): SlackMessagePointer[] {
+  const seen = new Set<string>()
+  const links: SlackMessagePointer[] = []
+  for (const match of text.matchAll(SLACK_ARCHIVE_LINK)) {
+    const channelId = match[1]
+    const seconds = match[2]
+    const micros = match[3]
+    if (channelId === undefined || seconds === undefined || micros === undefined) continue
+    const messageTs = `${seconds}.${micros}`
+    const key = `${channelId}:${messageTs}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    links.push({ channelId, messageTs })
+  }
+  return links
+}
+
+// A stable author id is required because the quote renders as `<@id>`
+// downstream; a name-only source would emit `<@unknown>`, worse than omitting
+// the context. Forwarded message-shares put it under `author_id`, classic
+// shares under `user`/`user_id`. `author_subname` is Slack's display-name
+// fallback on forwarded messages — used for the name only, never the id.
+function extractSlackShareSources(attachments: readonly unknown[]): QuoteAnchorSource[] {
+  const sources: QuoteAnchorSource[] = []
+  for (const attachment of attachments) {
+    const record = recordValue(attachment)
+    if (record === null) continue
+    const text = stringField(record, 'text') ?? stringField(record, 'fallback')
+    if (text === null || text.trim() === '') continue
+    const authorId = stringField(record, 'author_id') ?? stringField(record, 'user') ?? stringField(record, 'user_id')
+    if (authorId === null) continue
+    const authorName = stringField(record, 'author_name') ?? stringField(record, 'author_subname') ?? authorId
+    sources.push({
+      adapter: 'slack-bot',
+      authorId,
+      authorName,
+      text,
+    })
+  }
+  return sources
+}
+
+async function fetchSafely(
+  fetchMessage: SlackReferenceFetch,
+  pointer: SlackMessagePointer,
+): Promise<SlackResolvedReference | null> {
+  try {
+    return await fetchMessage(pointer.channelId, pointer.messageTs)
+  } catch {
+    return null
+  }
+}
+
+function toSource(message: SlackResolvedReference): QuoteAnchorSource {
+  return { adapter: 'slack-bot', authorId: message.authorId, authorName: message.authorName, text: message.text }
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}

package/src/channels/adapters/slack-bot.ts

@@ -43,6 +43,7 @@ import {
   type SlackInboundMessageEvent,
 } from './slack-bot-classify'
 import { createSlackDedupe } from './slack-bot-dedupe'
+import { enrichSlackReferenceContext } from './slack-bot-reference'
 import {
   buildSlashAckPayload,
   commandResultReply,
@@ -261,6 +262,7 @@ export type SlackBotAdapterOptions = {
   // classifier behaves as before (no alias-driven thread anchoring), so
   // tests and ad-hoc adapter constructions stay backwards-compatible.
   selfAliasesRef?: () => readonly string[]
+  fetchImpl?: typeof fetch
 }
 
 export type SlackBotAdapter = {
@@ -351,18 +353,23 @@ export function createTypingCallback(deps: {
   const { typingTracker, logger, formatChannelTag } = deps
   return async (target: TypingTarget): Promise<void> => {
     if (target.adapter !== 'slack-bot') return
+    // DMs are flat (thread null) but setStatus still needs a real message ts;
+    // `typingThread` carries the inbound ts for exactly that case. Real channel
+    // threads keep using `thread`. Either way the status is keyed on one ts.
+    const statusThread =
+      target.typingThread !== undefined && target.typingThread !== '' ? target.typingThread : target.thread
     const tag = formatChannelTag
-      ? await formatChannelTag(target.workspace, target.thread ?? target.chat)
-      : `channel=${target.thread ?? target.chat}`
-    if (target.thread === undefined || target.thread === null || target.thread === '') {
+      ? await formatChannelTag(target.workspace, statusThread ?? target.chat)
+      : `channel=${statusThread ?? target.chat}`
+    if (statusThread === undefined || statusThread === null || statusThread === '') {
       if (target.phase === 'tick') logger.info(`[slack-bot] typing (no-op, top-level chat) ${tag}`)
       return
     }
     if (target.phase === 'stop') {
-      await typingTracker.clearAfterSend(target.chat, target.thread)
+      await typingTracker.clearAfterSend(target.chat, statusThread)
       return
     }
-    await typingTracker.setStatus(target.chat, target.thread, 'is typing...')
+    await typingTracker.setStatus(target.chat, statusThread, 'is typing...')
   }
 }
 
@@ -823,7 +830,7 @@ export function createOutboundCallback(deps: {
           // top-level posts.
           if (threadTs === null && chunks.length > 1) threadTs = sent.ts
         }
-        if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.thread)
+        if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.typingThread ?? msg.thread)
         return { ok: true }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err)
@@ -856,7 +863,7 @@ export function createOutboundCallback(deps: {
         return { ok: false, error: `uploadFile failed: ${message}` }
       }
     }
-    if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.thread)
+    if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.typingThread ?? msg.thread)
     return { ok: true }
   }
 }
@@ -897,9 +904,46 @@ export function createFetchAttachmentCallback(deps: {
   }
 }
 
+function createSlackReferenceFetch(deps: { token: string; fetchImpl: typeof fetch }) {
+  return async (channelId: string, messageTs: string) => {
+    const url = new URL('https://slack.com/api/conversations.replies')
+    url.searchParams.set('channel', channelId)
+    url.searchParams.set('ts', messageTs)
+    url.searchParams.set('limit', '1')
+    const response = await deps.fetchImpl(url, { headers: { Authorization: `Bearer ${deps.token}` } })
+    if (!response.ok) return null
+    const body = recordValue(await response.json())
+    if (body === null || body.ok !== true) return null
+    const messages = arrayField(body, 'messages')
+    const first = recordValue(messages[0])
+    if (first === null) return null
+    const authorId = stringField(first, 'user') ?? stringField(first, 'bot_id')
+    const text = stringField(first, 'text')
+    if (authorId === null || text === null) return null
+    return { authorId, authorName: authorId, text }
+  }
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function arrayField(record: Record<string, unknown>, key: string): readonly unknown[] {
+  const value = record[key]
+  return Array.isArray(value) ? value : []
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
 export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBotAdapter {
   const logger = options.logger ?? consoleLogger
   const client = new SlackBotClient()
+  const fetchImpl = options.fetchImpl ?? fetch
   let listener: SlackBotListener | null = null
   let botUserId: string | null = null
   let teamId: string | null = null
@@ -1053,7 +1097,22 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       }
 
       dedupe.mark(event)
-      const enriched = { ...verdict.payload, authorName: resolvedUserName }
+      const slackAttachments = Array.isArray(event.attachments) ? event.attachments : undefined
+      const referenceResult = await enrichSlackReferenceContext({
+        text: verdict.payload.text,
+        channelId: event.channel,
+        ...(event.thread_ts !== undefined ? { threadTs: event.thread_ts } : {}),
+        messageTs: event.ts,
+        ...(slackAttachments !== undefined ? { attachments: slackAttachments } : {}),
+        fetchMessage: createSlackReferenceFetch({ token: options.token, fetchImpl }),
+      })
+      const enriched = {
+        ...verdict.payload,
+        authorName: resolvedUserName,
+        ...(referenceResult.referenceContext !== undefined
+          ? { referenceContext: referenceResult.referenceContext }
+          : {}),
+      }
       const routedTag = await formatChannelTag(enriched.workspace, enriched.chat)
       logger.info(
         `[slack-bot] routed ts=${event.ts} ${routedTag} mention=${enriched.isBotMention} reply=${enriched.replyToBotMessageId !== null}`,

package/src/channels/manager.ts

@@ -13,7 +13,13 @@ import { createKakaotalkAdapter, type KakaotalkAdapter } from './adapters/kakaot
 import { createSlackBotAdapter, type SlackBotAdapter } from './adapters/slack-bot'
 import { createTelegramBotAdapter, type TelegramBotAdapter } from './adapters/telegram-bot'
 import type { GithubTokenBridge } from './github-token-bridge'
-import { createChannelRouter, type ChannelRouter, type ClaimHandler, type CreateSessionForChannel } from './router'
+import {
+  createChannelRouter,
+  type ChannelRouter,
+  type ClaimHandler,
+  type CreateSessionForChannel,
+  type RestartCommandContext,
+} from './router'
 import {
   ADAPTER_IDS,
   type AdapterId,
@@ -94,7 +100,7 @@ export type ChannelManagerOptions = {
   // container-restart bindings; tests omit them so the commands stay
   // unregistered. See CreateChannelRouterOptions.onReload/onRestart.
   onReload?: () => Promise<string>
-  onRestart?: () => Promise<string>
+  onRestart?: (ctx?: RestartCommandContext) => Promise<string>
 }
 
 export type ChannelManager = {