Generated SDK

export class SlackChannel {
    constructor(
        public readonly channelId: string,
        public readonly name: string
    ) {}

    static DealDesk = new SlackChannel("C08XYZ1234", "deal-desk")
    static Engineering = new SlackChannel("C09ABC5678", "engineering")
    static AllTerseInc = new SlackChannel("C01DEF9012", "all-terse-inc")
}

export class SlackUser {
    constructor(
        public readonly userId: string,
        public readonly name: string
    ) {}

    static OnCall = new SlackUser("U08XYZ1234", "on-call")
}

export class GithubOwner {
    constructor(public readonly name: string) {}

    static TerseAI = new GithubOwner("terse-ai")
}

export class Repos {
    constructor(
        public readonly repositoryId: number,
        public readonly name: string,
        public readonly owner: GithubOwner,
        public readonly fullName: string
    ) {}

    static TerseAI = {
        Terse: new Repos(829471023, "terse", GithubOwner.TerseAI, "terse-ai/terse"),
        Docs: new Repos(829471108, "docs", GithubOwner.TerseAI, "terse-ai/docs")
    } as const
}

export class AttioObject<TSlug extends string = string, TRecordValues extends Record<string, unknown> = Record<string, unknown>, TInputValues extends Record<string, unknown> = TRecordValues> {
    constructor(
        public readonly apiSlug: TSlug,
        public readonly name: string,
        public readonly objectId: string,
        public readonly attributes: readonly AttioAttributeDefinition[] = []
    ) {}

    declare readonly __recordValues: TRecordValues
    declare readonly __inputValues: TInputValues

    static Deal = new AttioObject<"deals", { name?: string; stage?: string; amount?: number }, { name?: string; stage?: string; amount?: number }>("deals", "deal", "obj_f1e3c0b2…", [
        /* attributes */
    ])
    static Company = new AttioObject<"companies", { name?: string; domains?: string[] }, { name?: string; domains?: string[] }>("companies", "company", "obj_8d22a17c…", [
        /* attributes */
    ])
}

export const Triggers = {
    slack: {
        /** Trigger on any message in a channel */
        onMessage(opts: { channel: SlackChannel; userIds?: string[] }): TypedTrigger<SlackMessageTrigger> {
            /* … */
        },
        /** Trigger when the Slack app is directly mentioned */
        onAppMention(opts: { channel: SlackChannel }): TypedTrigger<SlackAppMentionTrigger> {
            /* … */
        }
    },
    github: {
        /** Trigger when a pull request is opened */
        onPROpened(opts: { repo: Repos }): TypedTrigger<GithubPROpenedTrigger> {
            /* … */
        },
        /** Trigger when a pull request is merged */
        onPRMerged(opts: { repo: Repos }): TypedTrigger<GithubPRMergedTrigger> {
            /* … */
        },
        /** Trigger when a comment is created on an issue or pull request */
        onIssueComment(opts: { repo: Repos }): TypedTrigger<GithubIssueCommentCreatedTrigger> {
            /* … */
        }
    },
    attio: {
        /** Trigger when a record is created. Pass `object` to scope to a specific Attio object. */
        onRecordCreated<T extends GeneratedAttioObject>(opts?: { object: T }): TypedTrigger<AttioRecordCreatedTrigger> {
            /* … */
        }
    },
    schedule: {
        /** Run on a cron schedule (5-field cron expression, evaluated as wall-clock time in `timezone` — an IANA name like "America/New_York", DST-aware — defaulting to UTC) */
        cron(opts: { expression: string; timezone?: Timezone }): TypedTrigger<CronTrigger> {
            /* … */
        }
    }
}

export const Skills = {
    /** Slack — send messages and manage threads in a specific channel */
    slack(opts: { channel: SlackChannel }): TypedSkill<"slack_list_channels" | "slack_list_users" | "slack_read_conversation" | "slack_send_message"> {
        /* … */
    },
    /** GitHub — read code and pull requests from the given repositories */
    github(opts: {
        repos: Repos[]
    }): TypedSkill<"grepGitHubCode" | "listGitHubCommits" | "listGitHubDirectory" | "listGitHubPullRequests" | "readGitHubFile" | "searchGitHubCode" | "summarizeGitHubPullRequestDiff"> {
        /* … */
    },
    /** Attio — read and write records, tasks, notes, lists and more on a CRM object */
    attio(opts: {
        object: AttioObject<any>
    }): TypedSkill<
        | "attio_add_list_entry"
        | "attio_create_comment"
        | "attio_create_list"
        | "attio_create_note"
        | "attio_create_record"
        | "attio_create_task"
        | "attio_delete_comment"
        | "attio_delete_file"
        | "attio_delete_note"
        | "attio_delete_record"
        | "attio_delete_task"
        | "attio_modify_schema"
        | "attio_remove_list_entry"
        | "attio_update_list"
        | "attio_update_list_entry"
        | "attio_update_record"
        | "attio_update_task"
        | "attio_upload_file"
        | "attio_upsert_list_entry"
        | "attio_upsert_record"
    > {
        /* … */
    }
}

export type GeneratedTools = {
    slack: {
        /** Send to a channel, existing DM (`channelId`), or member DM (`slackUserId`). */
        sendMessage(params: SlackSendMessageParams): Promise<SlackSendMessageResult>
        /** Read message history from a Slack channel or DM */
        readConversation(params: SlackReadConversationParams): Promise<SlackReadConversationResult>
    }
    attio: {
        /** Query records on an Attio object */
        queryRecords<T extends GeneratedAttioObject>(params: AttioQueryRecordsParams<T>): Promise<AttioQueryRecordsResult<T>>
        /** Upsert records on an Attio object */
        upsertRecord<T extends GeneratedAttioObject>(params: AttioUpsertRecordParams<T>): Promise<AttioUpsertRecordResult<T>>
    }
    github: {
        /** Search code by semantic meaning */
        searchCode(params: SearchGitHubCodeParams): Promise<SearchGitHubCodeResult>
    }
}

declare module "terse-sdk" {
    interface TerseAgent {
        readonly tools: GeneratedTools
    }
}

import { generateText, createJob } from "terse-sdk"

import { Repos, Skills, SlackChannel, Triggers, toolbox } from "./terse.generated"

createJob({
    name: "pr-summary-to-slack",
    triggers: [Triggers.github.onPROpened({ repo: Repos.TerseAI.Terse })],
    onTrigger: async event => {
        const message = await toolbox.slack.sendMessage({
            channelId: SlackChannel.Engineering.channelId,
            message: `New PR from ${event.sender.login}: ${event.pull_request.title}`
        })

        await generateText({
            prompt: `Summarize this PR and reply in thread (ts: ${message.message_ts}). ${event.formatForAgentRunner()}`,
            skills: [Skills.github({ repos: [Repos.TerseAI.Terse] }), Skills.slack({ channel: SlackChannel.Engineering })]
        })
    }
})