30 | {notification}
31 |
32 | ) : null,
33 | hasNotification: !!notification,
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/hooks/useOutsideClick.ts:
--------------------------------------------------------------------------------
1 | import React, { useRef, useEffect } from 'react'
2 |
3 | export function useOutsideClick(callback: () => void) {
4 | const ref = useRef(null)
5 |
6 | useEffect(() => {
7 | const handleClick = (event: MouseEvent) => {
8 | if (ref.current && !(ref.current as any).contains(event.target)) {
9 | callback()
10 | }
11 | }
12 | const document = Zotero.getMainWindow().document
13 | document.addEventListener('click', handleClick, true)
14 | addon.data.popup.window!.addEventListener('click', handleClick, true)
15 | return () => {
16 | document.documentElement.removeEventListener('click', handleClick, true)
17 | addon.data.popup.window!.removeEventListener('click', handleClick, true)
18 | }
19 | }, [])
20 |
21 | return ref
22 | }
23 |
--------------------------------------------------------------------------------
/src/hooks/useZoom.ts:
--------------------------------------------------------------------------------
1 | import React, { useState, useMemo, useCallback } from "react"
2 | import { getPref, setPref } from "../utils/prefs"
3 |
4 | export function useZoom() {
5 | const [scale, setScale] = useState(
6 | (getPref("DEFAULT_ZOOM_LEVEL") as number) || 100,
7 | )
8 |
9 | const setScaleAndSave = useCallback(
10 | (scale: number) => {
11 | const constraintScale = Math.max(25, Math.min(400, scale))
12 | setPref("DEFAULT_ZOOM_LEVEL", constraintScale)
13 | setScale(constraintScale)
14 | },
15 | [scale],
16 | )
17 |
18 | const containerStyle = useMemo(() => {
19 | switch (scale) {
20 | case 1: {
21 | return {
22 | width: "calc(100% - 20px)",
23 | }
24 | }
25 | default: {
26 | const constraintScale = Math.max(25, Math.min(400, scale))
27 | const sizePct = Math.round(10000 / constraintScale)
28 | const posPct = Math.round(50 * (2 - 100 / constraintScale))
29 | return {
30 | // width: `${sizePct}%`,
31 | height: `${sizePct}%`,
32 | left: `${posPct}%`,
33 | top: `${posPct}%`,
34 | transform: `scale(${constraintScale / 100}) translate(-50%, -50%)`,
35 | width: `calc(${sizePct}% - 20px)`,
36 | }
37 | }
38 | }
39 | }, [scale])
40 |
41 | return {
42 | scale: scale,
43 | setScale: setScaleAndSave,
44 | style: containerStyle,
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | import globalConfig from "./settings/config"
2 |
3 | globalConfig()
4 |
--------------------------------------------------------------------------------
/src/models/agents/base.ts:
--------------------------------------------------------------------------------
1 | import { PromptManager } from 'zotero-plugin-toolkit/dist/managers/prompt'
2 | import { Command } from 'zotero-plugin-toolkit/dist/managers/prompt'
3 | import { AgentExecutor } from 'langchain/agents'
4 | import { CallbackManager } from 'langchain/callbacks'
5 | import { ZoteroCallbacks } from '../utils/callbacks'
6 |
7 | export abstract class BaseAgent {
8 | id: string
9 | name: string
10 | label: string
11 |
12 | constructor(id: string, name: string, label: string) {
13 | this.id = id
14 | this.name = name
15 | this.label = label
16 | }
17 |
18 | toPromptDefinition(): Command {
19 | return {
20 | id: this.id,
21 | name: this.name,
22 | label: this.label,
23 | callback: prompt => {
24 | addon.hooks.onDialogEvents('dialogExample')
25 | // @ts-ignore
26 | prompt.exit()
27 | },
28 | }
29 | }
30 | }
31 |
32 | export type ExecutorWithMetadata = {
33 | executor: AgentExecutor
34 | metadata: {
35 | title: string
36 | description: string
37 | }
38 | }
39 |
40 | export type ExecutorParams = {
41 | langChainCallbackManager: CallbackManager
42 | zoteroCallbacks: ZoteroCallbacks
43 | }
44 |
--------------------------------------------------------------------------------
/src/models/agents/index.ts:
--------------------------------------------------------------------------------
1 | export { ExecutorWithMetadata } from './base'
2 | // export { createQAExecutor } from './qa'
3 | // export { createHelpExecutor } from './help'
4 |
--------------------------------------------------------------------------------
/src/models/agents/qa.ts:
--------------------------------------------------------------------------------
1 | // import { AgentExecutor } from 'langchain/agents'
2 | // import { ChatOpenAI } from 'langchain/chat_models/openai'
3 | // import { CallbackManager } from 'langchain/callbacks'
4 | // import { config } from '../../../package.json'
5 | // import { OPENAI_GPT_MODEL } from '../../constants'
6 |
7 | // interface createQAExecutorInput {
8 | // langChainCallbackManager: CallbackManager
9 | // zoteroCallbacks: ZoteroCallbacks
10 | // }
11 |
12 | // export function createQAExecutor({ langChainCallbackManager, zoteroCallbacks }: createQAExecutorInput): AgentExecutor {
13 | // const OPENAI_API_KEY = Zotero.Prefs.get(`${config.addonRef}.OPENAI_API_KEY`) as string
14 | // const title = 'QA Assistant'
15 | // const description = `
16 | // QA Assistant analyzes and understands the content of your Zotero library. It can help streamline your research process by performing automatic literature search, summarization, and question & answer.
17 | // `
18 | // const chatModel = new ChatOpenAI({
19 | // temperature: 0,
20 | // openAIApiKey: OPENAI_API_KEY,
21 | // modelName: OPENAI_GPT_MODEL,
22 | // })
23 |
24 | // // const embeddings = new OpenAIEmbeddings({ openAIApiKey: OPENAI_API_KEY })
25 | // const zoteroSearchTool = loadZoteroSearchChainAsTool(chatModel)
26 | // const zoteroQATool = loadQAChainAsTool(chatModel)
27 | // const zoteroItemTool = new ZoteroItem()
28 | // const zoteroCollectionTool = new ZoteroCollection()
29 | // const zoteroSummaryTool = loadAnalyzeDocumentChainAsTool(chatModel)
30 | // const zoteroCreatorsTool = new ZoteroCreators()
31 | // const tools = [
32 | // zoteroSearchTool,
33 | // zoteroQATool,
34 | // zoteroItemTool,
35 | // // zoteroCollectionTool,
36 | // // zoteroSummaryTool,
37 | // // zoteroCreatorsTool,
38 | // ]
39 | // // const executor = await initializeAgentExecutor(tools, chatModel, 'chat-conversational-react-description', true)
40 |
41 | // const executor = AgentExecutor.fromAgentAndTools({
42 | // agent: ChatConversationalAgent.fromLLMAndTools(chatModel, tools, createPromptArgs),
43 | // tools,
44 | // verbose: true,
45 | // callbackManager: langChainCallbackManager,
46 | // maxIterations: 6,
47 | // })
48 | // executor.agent.llmChain.prompt.partialVariables = {
49 | // current_items: () => {
50 | // const items = ZoteroPane.getSelectedItems()
51 | // if (items.length > 0) {
52 | // return items.map(x => `${x.name} (ID: "${x.id}")`).join(', ')
53 | // }
54 | // return 'No selected items'
55 | // },
56 | // current_collection: () => {
57 | // const collection = ZoteroPane.getSelectedCollection()
58 | // if (collection) {
59 | // return `${collection.name} (ID: "${collection.id}")`
60 | // }
61 | // return 'None'
62 | // },
63 | // }
64 | // executor.memory = new BufferWindowMemory({
65 | // returnMessages: true,
66 | // memoryKey: 'chat_history',
67 | // inputKey: 'input',
68 | // k: 5
69 | // })
70 | // return executor
71 | // }
72 |
--------------------------------------------------------------------------------
/src/models/cache.ts:
--------------------------------------------------------------------------------
1 | export class SQLiteCache {
2 | db: any
3 | constructor() {
4 | const { FileUtils } = Components.utils.import('resource://gre/modules/FileUtils.jsm')
5 | const dbFile = FileUtils.getFile('ProfD', ['aria', 'db.sqlite'])
6 | // Open the SQLite database
7 | const storageService = Components.classes['@mozilla.org/storage/service;1'].getService(
8 | Components.interfaces.mozIStorageService
9 | )
10 | this.db = storageService.openDatabase(dbFile)
11 | this.initDatabase()
12 | }
13 |
14 | async initDatabase() {
15 | this.db.executeSimpleSQL(
16 | `
17 | CREATE TABLE IF NOT EXISTS LANGCHAIN_CACHE (
18 | prompt TEXT,
19 | llm TEXT,
20 | idx INTEGER,
21 | response TEXT,
22 | PRIMARY KEY (prompt, llm, idx)
23 | )
24 | `.trim()
25 | )
26 | }
27 |
28 | async lookup(prompt: string, llmKey: string) {
29 | console.log('lookup', prompt, llmKey)
30 | const rows = await this.db.queryAsync(
31 | `SELECT response FROM LANGCHAIN_CACHE WHERE prompt = ? AND llm = ? ORDER BY idx`,
32 | [prompt, llmKey]
33 | )
34 |
35 | if (rows.length > 0) {
36 | const generations = rows.map((row: any) => ({ text: row.response }))
37 | return generations
38 | }
39 |
40 | return null
41 | }
42 |
43 | async update(prompt: string, llmKey: string, value: { text: string }[]) {
44 | for (let i = 0; i < value.length; i++) {
45 | await this.db.queryAsync(`INSERT OR REPLACE INTO cache (prompt, llm, idx, response) VALUES (?, ?, ?, ?)`, [
46 | prompt,
47 | llmKey,
48 | i,
49 | value[i].text,
50 | ])
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/models/chains/summary.ts:
--------------------------------------------------------------------------------
1 | import { BaseLanguageModel } from 'langchain/base_language'
2 | import { loadSummarizationChain, AnalyzeDocumentChain } from 'langchain/chains'
3 | import { ChainTool } from 'langchain/tools'
4 |
5 | export const loadAnalyzeDocumentChainAsTool = (llm: BaseLanguageModel) => {
6 | const combineDocsChain = loadSummarizationChain(llm, { type: 'stuff' })
7 | const chain = new AnalyzeDocumentChain({
8 | combineDocumentsChain: combineDocsChain,
9 | })
10 |
11 | return new ChainTool({
12 | name: 'zotero-summary',
13 | description:
14 | 'Useful for generating a short summary from a long article the Zotero database. The input should be a LONG string representing the entire content of a single article. The input should not be an item ID such as "568" or multiple articles.',
15 | chain: chain,
16 | })
17 | }
18 |
19 | // import { BaseLanguageModel } from 'langchain/base_language'
20 | // import { PromptTemplate } from 'langchain/prompts'
21 | // import { LLMChain } from 'langchain/chains'
22 |
23 | // // Prompt credit: https://github.com/whitead/paper-qa/blob/main/paperqa/qaprompts.py
24 | // const SUMMARY_DEFAULT_PROMPT = new PromptTemplate({
25 | // inputVariables: ['question', 'context_str', 'citation'],
26 | // template: `
27 | // Summarize and provide direct quotes from the text below to help answer a question.
28 | // Do not directly answer the question, instead summarize and quote to give evidence to help answer the question.
29 | // Do not use outside sources.
30 | // Reply with "Not applicable" if the text is unrelated to the question.
31 | // Use 75 or less words.
32 |
33 | // {context_str}
34 |
35 | // Extracted from {citation}
36 |
37 | // Question: {question}
38 |
39 | // Relevant Information Summary:
40 | // `.trim(),
41 | // })
42 |
43 | // interface SummaryChainParams {
44 | // prompt?: PromptTemplate
45 | // }
46 |
47 | // export const loadSummaryChain = (llm: BaseLanguageModel, params: SummaryChainParams = {}) => {
48 | // const { prompt = SUMMARY_DEFAULT_PROMPT } = params
49 | // const chain = new LLMChain({ prompt, llm })
50 | // return chain
51 | // }
52 |
--------------------------------------------------------------------------------
/src/models/schemas/const.ts:
--------------------------------------------------------------------------------
1 | export const conditions = [
2 | // "numPages",
3 | // "numberOfVolumes",
4 | "abstractNote",
5 | "anyField",
6 | // "accessDate",
7 | // "applicationNumber",
8 | // "archive",
9 | // "artworkSize",
10 | // "assignee",
11 | // "fulltextContent",
12 | // "fileTypeID",
13 | // "author",
14 | // "authority",
15 | // "bookAuthor",
16 | // "callNumber",
17 | // "childNote",
18 | // "citationKey",
19 | // "code",
20 | // "codeNumber",
21 | "collection",
22 | // "committee",
23 | // "conferenceName",
24 | // "country",
25 | "creator",
26 | "date",
27 | "dateAdded",
28 | "dateModified",
29 | // "DOI",
30 | // "edition",
31 | // "editor",
32 | // "extra",
33 | // "filingDate",
34 | // "history",
35 | // "ISBN",
36 | // "ISSN",
37 | // "issue",
38 | "itemType",
39 | // "journalAbbreviation",
40 | // "language",
41 | // "libraryCatalog",
42 | // "archiveLocation",
43 | // "medium",
44 | // "meetingName",
45 | "note",
46 | // "number",
47 | // "pages",
48 | // "place",
49 | // "priorityNumbers",
50 | // "programmingLanguage",
51 | // "publicationTitle",
52 | // "publisher",
53 | // "references",
54 | // "reporter",
55 | // "rights",
56 | // "runningTime",
57 | // "scale",
58 | // "section",
59 | // "series",
60 | // "seriesNumber",
61 | // "seriesText",
62 | // "seriesTitle",
63 | // "session",
64 | // "shortTitle",
65 | // "status",
66 | // "system",
67 | "tag",
68 | "title",
69 | "type",
70 | // "url",
71 | // "versionNumber",
72 | // "volume",
73 | // "deleted",
74 | // "noChildren",
75 | // "unfiled",
76 | // "retracted",
77 | // "publications",
78 | // "feed",
79 | // "includeParentsAndChildren",
80 | // "includeParents",
81 | // "includeChildren",
82 | // "recursive",
83 | // "joinMode",
84 | // "quicksearch-titleCreatorYear",
85 | // "quicksearch-titleCreatorYearNote",
86 | // "quicksearch-fields",
87 | // "quicksearch-everything",
88 | // "quicksearch",
89 | // "blockStart",
90 | // "blockEnd",
91 | // "collectionID",
92 | // "savedSearchID",
93 | // "savedSearch",
94 | // "itemTypeID",
95 | // "tagID",
96 | // "lastName",
97 | // "field",
98 | // "datefield",
99 | // "year",
100 | // "numberfield",
101 | "libraryID",
102 | // "key",
103 | // "itemID",
104 | // "annotationText",
105 | // "annotationComment",
106 | // "fulltextWord",
107 | // "tempTable",
108 | ] as const
109 |
110 | export const operators = [
111 | "contains",
112 | "doesNotContain",
113 | "is",
114 | "isNot",
115 | "beginsWith",
116 | "isBefore",
117 | "isAfter"
118 | ] as const
--------------------------------------------------------------------------------
/src/models/schemas/search.ts:
--------------------------------------------------------------------------------
1 | import { zodFunction } from 'openai/helpers/zod'
2 | import { z } from 'zod'
3 | import { conditions, operators } from './const'
4 |
5 | // use zodFunction to convert to JSON schema
6 | const searchTagsDef = {
7 | name: "search_tag",
8 | description: "A function to use a list of words or partial words to search for tags. Useful to refine search scope or improve accuracy.",
9 | parameters: z.object({
10 | queries: z.array(z.string()).describe("List of up to five words or partial words to search for tags")
11 | }),
12 | }
13 |
14 | const searchCreatorsDef = {
15 | name: "search_creator",
16 | description: "A function to use a list of names or partial names to search for creators (authors, editors etc.). Useful to refine search scope or improve accuracy.",
17 | parameters: z.object({
18 | queries: z.array(z.string()).describe("List of up to five names or partial names to search for authors. The names should cover different spelling variants for comprehensiveness.")
19 | }),
20 | }
21 |
22 | export const searchItemsDef = {
23 | name: "search_items",
24 | description: "A function to search for items in your Zotero library using a list of words or partial words. Useful to refine search scope or validate search results.",
25 | parameters: z.object({
26 | conditions: z.array(
27 | z.object({
28 | condition: z.enum(conditions).describe("The condition field to search within."),
29 | operator: z.enum(operators).describe("The operator to use for the search condition. The \"isBefore\" and \"isAfter\" operators only work with date conditions."),
30 | value: z.optional(z.string().describe("The value to search for in the specified field, omittable for some operators.")),
31 | })
32 | ).describe("A list of search conditions to apply."),
33 | match: z.enum(["all", "any"]).describe("Determines whether to match all conditions ('all', more restrictive) or any condition ('any', broader scope) based on the user aquestion."),
34 | // searchSubcollections: z.boolean().describe("Whether to include subcollections in the search."),
35 | // showOnlyTopLevelItems: z.boolean().describe("Whether to show only top-level items in the search results."),
36 | // includeParentAndChildItems: z.boolean().describe("Whether to include both parent and child items of matching items."),
37 | }),
38 | }
--------------------------------------------------------------------------------
/src/models/tools.ts:
--------------------------------------------------------------------------------
1 | import { title } from "process"
2 | import * as zot from "../apis/zotero"
3 | import { suggestTags, suggestCreators } from "../apis/zotero/suggest"
4 | import { countBy, orderBy } from "lodash"
5 | import stringify from "json-stringify-pretty-compact"
6 | import { search } from "../apis/zotero/search"
7 |
8 | export const tools = {
9 | search_tag: {
10 | title: "Search Tags",
11 | description: "Searched tags in your Zotero library using the following queries:"
12 | },
13 | search_creator: {
14 | title: "Search Creators",
15 | description: "Searched creators (authors, editors etc.) in your Zotero library using the following queries:"
16 | },
17 | search_item: {
18 | title: "Search Items",
19 | description: "Searched items in your Zotero library using the following conditions:"
20 | }
21 | }
22 |
23 | export async function runFunctionTool(tool: string, toolArguments: any) {
24 | if (tool.startsWith("search_")) {
25 | const fieldName = tool.slice(7) as zot.FieldName | "item"
26 | if (fieldName === "item") {
27 | const searchParams = toolArguments
28 | return stringify(await search(searchParams, 10, "search"))
29 | } else {
30 | const { queries } = toolArguments
31 | let results: string[][] = []
32 | if (fieldName === "tag") {
33 | results = await Promise.all(queries.map((query: string) => suggestTags({ qtext: query })))
34 | } else if (fieldName === "creator") {
35 | results = await Promise.all(queries.map((query: string) => suggestCreators({ qtext: query })))
36 | } else {
37 | const { queries } = toolArguments
38 | for (const query of queries) {
39 | const result = await zot.suggest(query, fieldName) as string[]
40 | console.log({ query, result })
41 | results.push(result)
42 | }
43 | }
44 | const allResults = results.flat()
45 | const frequencyMap = countBy(allResults)
46 | const sortedResults = orderBy(
47 | Object.keys(frequencyMap),
48 | (key) => frequencyMap[key],
49 | "desc",
50 | )
51 | return sortedResults.slice(0, 10).join("; ")
52 | }
53 | }
54 |
55 | return ""
56 | }
--------------------------------------------------------------------------------
/src/models/tools/search.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lifan0127/ai-research-assistant/9bbcd116f045587a9bc21b422e949b55e07e1cb6/src/models/tools/search.ts
--------------------------------------------------------------------------------
/src/models/tools/zoteroCollection.ts:
--------------------------------------------------------------------------------
1 | import { Tool } from 'langchain/tools'
2 | import { serializeError } from 'serialize-error'
3 |
4 | export class ZoteroCollection extends Tool {
5 | name = 'zotero-collection'
6 |
7 | constructor() {
8 | super()
9 | }
10 |
11 | async _call(input: string) {
12 | try {
13 | const sql = `
14 | SELECT c.collectionID, c.collectionName, c.parentCollectionID, c.libraryID, COUNT(ci.itemID) as itemCount
15 | FROM collections c
16 | LEFT JOIN collectionItems ci ON c.collectionID=ci.collectionID
17 | WHERE c.collectionID=?
18 | GROUP BY c.collectionID
19 | `.trim()
20 | const results = await Zotero.DB.queryAsync(sql, [`${input}`])
21 | let output = []
22 | for (let row of results) {
23 | output.push({
24 | id: row.collectionID,
25 | name: row.collectionName,
26 | parent: row.parentCollectionID,
27 | library: row.libraryID,
28 | itemCount: row.itemCount,
29 | })
30 | }
31 | if (output.length > 0) {
32 | return `ID: ${output[0].id}
33 | Name: ${output[0].name}
34 | Parent ID: ${output[0].parent}
35 | Library ID: ${output[0].library}
36 | Number of items in collection: ${output[0].itemCount}
37 | `
38 | }
39 | return `No collection matching ID ${input} found.`
40 | } catch (error) {
41 | return `Error retrieving collection information for ${input}`
42 | }
43 | }
44 |
45 | description = `Useful for retrieving the current collection information, including id, name, parent, library and number of items. The input is a collection ID.`
46 | }
47 |
--------------------------------------------------------------------------------
/src/models/tools/zoteroCreators.ts:
--------------------------------------------------------------------------------
1 | import { Tool } from 'langchain/tools'
2 | import { serializeError } from 'serialize-error'
3 |
4 | export class ZoteroCreators extends Tool {
5 | name = 'zotero-creators'
6 |
7 | constructor() {
8 | super()
9 | }
10 |
11 | async _call(input: string) {
12 | try {
13 | // Must trim the input or the query won't run
14 | const sql = `
15 | SELECT DISTINCT CASE fieldMode
16 | WHEN 1 THEN lastName
17 | WHEN 0 THEN firstName || ' ' || lastName END AS val, NULL AS id
18 | FROM creators
19 | WHERE CASE fieldMode
20 | WHEN 1 THEN lastName LIKE ?1
21 | WHEN 0 THEN (firstName || ' ' || lastName LIKE ?1) OR (lastName LIKE ?1) END
22 | ORDER BY val
23 | LIMIT 10
24 | `.trim()
25 | const results = await Zotero.DB.queryAsync(sql, [`${input}`])
26 | // Unpack the iterator array
27 | let output: string[] = []
28 | for (let row of results) {
29 | output.push(row.val)
30 | }
31 | return output.join('\n')
32 | } catch (error) {
33 | const errorObj = serializeError(error)
34 | console.log({ zoteroCreatorsError: errorObj })
35 | return `Error: ${errorObj.message}`
36 | }
37 | }
38 |
39 | description = `Useful for searching for creators (authors, editors) in Zotero. The input to this tool should be a string representing a partial creator name.`
40 | }
41 |
--------------------------------------------------------------------------------
/src/models/tools/zoteroItem.ts:
--------------------------------------------------------------------------------
1 | import { Tool } from 'langchain/tools'
2 | import { serializeError } from 'serialize-error'
3 |
4 | export class ZoteroItem extends Tool {
5 | name = 'zotero-item'
6 |
7 | constructor() {
8 | super()
9 | }
10 |
11 | async _call(input: string) {
12 | try {
13 | const item = await Zotero.Items.getAsync(parseInt(input))
14 | const id = item.id
15 | const itemType = item.itemType
16 | const title = item.getField('title', false, true)
17 | const abstract = item.getField('abstractNote', false, true) || ''
18 | const author = item.getField('firstCreator', false, true)
19 | const date = item.getField('date', true, true) as string
20 | const publication = item.getField('publicationTitle', false, true)
21 | return `
22 | ## ID
23 | ${id}
24 |
25 | ## Item Type
26 | ${itemType}
27 |
28 | ## Title
29 | ${title}
30 |
31 | ## Abstract
32 | ${abstract}
33 |
34 | ## Author
35 | ${author} et al.
36 |
37 | ## Publication Date
38 | ${date}
39 |
40 | ## Publication Name
41 | ${publication}
42 | `
43 | } catch (error) {
44 | const errorObj = serializeError(error)
45 | console.log({ zoteroItemError: errorObj })
46 | return `Error: ${errorObj.message}`
47 | }
48 | }
49 |
50 | description = `Useful for retrieving an item from Zotero and extract some key fields for summarization. The input to this tool should be a string representing an item ID such as "576".`
51 | }
52 |
--------------------------------------------------------------------------------
/src/models/utils/actions.ts:
--------------------------------------------------------------------------------
1 | export interface BaseActionResponse {
2 | action: string
3 | payload: object
4 | }
5 |
6 | export interface ClarificationActionResponse extends BaseActionResponse {
7 | action: 'clarification'
8 | payload: {
9 | message: string
10 | _raw: string
11 | }
12 | }
13 |
14 | export interface ErrorActionResponse extends BaseActionResponse {
15 | action: 'error'
16 | payload: {
17 | error: object
18 | _raw: string
19 | }
20 | }
21 |
22 | export interface RoutingActionResponse extends BaseActionResponse {
23 | action: 'routing'
24 | payload: {
25 | route: string
26 | input: string
27 | _raw: string
28 | }
29 | }
30 |
31 | export interface SearchActionResponse extends BaseActionResponse {
32 | widget: 'search'
33 | input: {
34 | qtexts?: string[]
35 | creators?: string[]
36 | tags?: string[]
37 | years?: {
38 | from: number
39 | to: number
40 | }
41 | _raw: string
42 | }
43 | }
44 |
45 | export interface QAActionResponse extends BaseActionResponse {
46 | action: 'qa'
47 | payload: {
48 | answer: string
49 | sources: string[]
50 | _raw: string
51 | }
52 | }
53 |
54 | export interface VisionActionResponse extends BaseActionResponse {
55 | action: 'vision'
56 | payload: {
57 | message: string
58 | _raw: string
59 | }
60 | }
61 |
62 | export interface ExecutorActionResponse extends BaseActionResponse {
63 | action: 'search' | 'qa'
64 | payload: {
65 | widget: 'MARKDOWN' | 'SEARCH_RESULTS' | 'QA_RESPONSE'
66 | input: object
67 | _raw: string
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/src/models/utils/callbacks.ts:
--------------------------------------------------------------------------------
1 | export interface ZoteroCallbacks {
2 | handleZoteroActionStart: (action: string) => void
3 | handleZoteroActionEnd: (action: string) => void
4 | }
5 |
6 | export interface ErrorCallbacks {
7 | handleErrorEnd: (error: any) => void
8 | }
9 |
--------------------------------------------------------------------------------
/src/models/utils/dataTransfer.ts:
--------------------------------------------------------------------------------
1 | import { compileItemInfo, compileAttachmentInfo } from '../../apis/zotero/item'
2 |
3 | export async function parseDataTransfer(dataTransfer: DataTransfer) {
4 | const { items, types, files } = dataTransfer
5 | const type = types.includes('zotero/item')
6 | ? 'zotero/item'
7 | : types.includes('zotero/collection')
8 | ? 'zotero/collection'
9 | : types.includes('zotero/annotation')
10 | ? 'zotero/annotation'
11 | : 'text/plain'
12 | switch (type) {
13 | case 'zotero/item': {
14 | const ids = dataTransfer
15 | .getData(type)
16 | .split(',')
17 | .map(x => parseInt(x))
18 | const items = await Promise.all(
19 | ids.map(async id => {
20 | const item = await Zotero.Items.getAsync(id)
21 | if (item.isAttachment()) {
22 | return {
23 | ...compileAttachmentInfo(item),
24 | title: item.getDisplayTitle(),
25 | isAttachment: true,
26 | }
27 | } else {
28 | return compileItemInfo(item, 'search')
29 | }
30 | })
31 | )
32 | return {
33 | type,
34 | items,
35 | }
36 | }
37 | case 'zotero/collection': {
38 | const id = parseInt(dataTransfer.getData(type))
39 | const collection = Zotero.Collections.get(id) as Zotero.Collection
40 | const title = collection.name
41 | const itemCount = collection.getChildItems().length
42 | const label = `${title} (${itemCount} ${itemCount > 1 ? 'items' : 'item'})`
43 | return {
44 | type,
45 | collection: { id, title: label },
46 | }
47 | }
48 | case 'zotero/annotation': {
49 | const {
50 | attachmentItemID,
51 | id: key,
52 | type: annotationType,
53 | image,
54 | } = JSON.parse(dataTransfer.getData('zotero/annotation'))[0]
55 | if (annotationType !== 'image') {
56 | return {
57 | type: 'text/plain',
58 | text: `Sorry. Only image-based annotations are currently supported.`,
59 | }
60 | }
61 | const libraryID = (await Zotero.Items.getAsync(attachmentItemID)).libraryID
62 | return {
63 | type: 'zotero/annotation-image',
64 | image,
65 | libraryID,
66 | key,
67 | }
68 | }
69 | case 'text/plain': {
70 | return {
71 | type,
72 | text: dataTransfer.getData('text/plain'),
73 | }
74 | }
75 | }
76 | }
77 |
78 | Zotero.Annotations
79 |
--------------------------------------------------------------------------------
/src/models/utils/error.ts:
--------------------------------------------------------------------------------
1 | export function anonymizeError(errorMessage: string) {
2 | return errorMessage.replace(/file:\/\/\/.*?\/extensions\//g, 'file:/
9 | Version: {version} (Model: {OPENAI_MODEL})
10 |
11 | )
12 | }
13 |
--------------------------------------------------------------------------------
/src/views/components/buttons/ButtonGroup.tsx:
--------------------------------------------------------------------------------
1 | import React, { MouseEvent } from 'react'
2 |
3 | function classNames(...classes: any[]) {
4 | return classes.filter(Boolean).join(' ')
5 | }
6 |
7 | interface ButtonGroupProps {
8 | groups: {
9 | key: string
10 | label: string | JSX.Element
11 | onClick: () => void
12 | }[]
13 | selected?: string
14 | }
15 |
16 | export function ButtonGroup({ groups, selected }: ButtonGroupProps) {
17 | if (groups.length === 0) {
18 | return null
19 | }
20 |
21 | function handleClick(event: MouseEvent
28 | {groups.map(({ key, label, onClick }, index) => {
29 | return (
30 | handleClick(event, onClick)}
40 | >
41 | {label}
42 |
43 | )
44 | })}
45 |
46 | )
47 | }
48 |
--------------------------------------------------------------------------------
/src/views/components/buttons/CopyButton.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import { marked } from "marked"
3 | import { BotMessageProps } from "../../../typings/legacyMessages"
4 | import { Square2StackIcon } from "@heroicons/react/24/outline"
5 | import { copyButtonDef } from "./types"
6 |
7 | interface CopyButtonProps extends copyButtonDef {
8 | copyId: BotMessageProps["copyId"]
9 | setCopyId: BotMessageProps["setCopyId"]
10 | id: BotMessageProps["id"]
11 | input: BotMessageProps["content"]
12 | }
13 |
14 | export function CopyButton({
15 | copyId,
16 | setCopyId,
17 | id,
18 | utils,
19 | input,
20 | }: CopyButtonProps) {
21 | function handleCopy() {
22 | utils.copy(input)
23 | setCopyId(id)
24 | }
25 | return (
26 |
27 |
41 |
42 | )
43 | }
44 |
--------------------------------------------------------------------------------
/src/views/components/buttons/ItemButton.tsx:
--------------------------------------------------------------------------------
1 | import React, { useRef } from "react"
2 | import { ItemIcon } from "../../icons/zotero"
3 | import { ItemInfo, AttachmentInfo } from "../../../typings/zotero"
4 | import { useDialog } from "../../../hooks/useDialog"
5 |
6 | interface ItemButtonProps {
7 | item: Pick
43 |
101 | )
102 | }
103 |
--------------------------------------------------------------------------------
/src/views/components/buttons/StopRespondingButton.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import { marked } from "marked"
3 | import { StopIcon } from "@heroicons/react/24/solid"
4 | import { stopRespondingButtonDef } from "./types"
5 | import { BotMessageStatus } from "../../../typings/legacyMessages"
6 |
7 | interface StopRespondingButtonProps extends stopRespondingButtonDef {
8 | status: BotMessageStatus
9 | }
10 |
11 | export function StopRespondingButton({
12 | status,
13 | utils,
14 | }: StopRespondingButtonProps) {
15 | return (
16 |
44 |
68 |
69 | -
75 |
- 76 | 82 | 83 | {items.map((item) => { 84 | const itemTitle = 85 | item.title && item.title.length > 64 86 | ? item.title.slice(0, 64) + "..." 87 | : item.title 88 | return ( 89 |
- 90 | 96 | 97 | ) 98 | })} 99 |
17 |
26 |
27 | )
28 | }
29 |
--------------------------------------------------------------------------------
/src/views/components/buttons/types.ts:
--------------------------------------------------------------------------------
1 | export interface copyButtonDef {
2 | name: 'COPY'
3 | utils: {
4 | copy: (props: any) => void
5 | }
6 | }
7 |
8 | export interface noteButtonDef {
9 | name: 'NOTE'
10 | utils: {
11 | createNote: (props: any) => Promise
25 |
26 | {code}
27 |
28 |
29 | )
30 | }
31 |
--------------------------------------------------------------------------------
/src/views/components/files/FileRetriever.tsx:
--------------------------------------------------------------------------------
1 | import React, { useState, useEffect, useMemo } from "react"
2 | import { QueryType } from "../../../typings/actions"
3 | import { FileForIndexing } from "../../../typings/files"
4 | import { recursiveSearch } from "../../../apis/zotero/search"
5 | import { getItemsAndIndexAttachments } from "../../../apis/zotero/item"
6 | import { useAssistant } from "../../../hooks/useAssistant"
7 | import { uniq } from "lodash"
8 | import { ItemIcon } from "../../icons/zotero"
9 |
10 | interface FileRetrievalProps {
11 | itemIds?: number[]
12 | query?: QueryType
13 | onComplete: (results: FileForIndexing[]) => void
14 | files?: FileForIndexing[]
15 | limit?: number
16 | }
17 |
18 | export function FileRetriever({
19 | itemIds = [],
20 | query,
21 | onComplete,
22 | files,
23 | limit = 10,
24 | }: FileRetrievalProps) {
25 | const { assistant } = useAssistant()
26 | const [count, setCount] = useState()
27 | const [results, setResults] = useState|
60 | {/* |
63 | {/* {JSON.stringify(attachment)} | */} 64 |
{message}
43 |
47 |
54 |
55 |
56 |
64 |
72 |
73 |
46 |
97 | )
98 | }
99 |
--------------------------------------------------------------------------------
/src/views/components/navigations/Modal.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 |
3 | interface ModalProps {
4 | children: React.ReactNode
5 | }
6 |
7 | export function Modal({ children }: ModalProps) {
8 | return (
9 |
47 |
55 |
56 |
57 | -
61 | {items.map((item) => {
62 | switch (item.type) {
63 | case "BUTTON": {
64 | const { label, handleClick, disabled = false } = item
65 | return (
66 |
- 67 | 74 | 75 | ) 76 | } 77 | case "COMPONENT": { 78 | const { label, Component, props } = item 79 | return ( 80 |
-
81 |
82 |
83 | )
84 | }
85 | case "SEPARATOR": {
86 | const { label } = item
87 | return (
88 | -
89 |
90 |
91 | )
92 | }
93 | }
94 | })}
95 |
10 |
18 | )
19 | }
20 |
--------------------------------------------------------------------------------
/src/views/components/test/data/qaResponse.ts:
--------------------------------------------------------------------------------
1 | export const qaResponseAction: any = {
2 | action: 'qa',
3 | payload: {
4 | widget: 'QA_RESPONSE' as const,
5 | input: {
6 | answer:
7 | 'Machine learning can be used for materials discovery through the digitization of chemistry. This involves creating a hard link between an abstracted process ontology of chemistry and bespoke hardware for performing reactions or exploring reactivity. A chemical state machine is developed that uses this ontology to connect precise instruction sets to hardware that performs chemical transformations. This approach enables a universal standard for describing chemistry procedures via a chemical programming language. The digitization of chemistry can reduce the labor needed to make new compounds and broaden accessible chemical space. Automation in chemistry has developed workflows for automating chemical synthesis as well as materials, nanomaterials, and formulation production. A key aspect is the use of a batch system that can encode the chemical reagents, solvent, and products as packets which can be moved around the system. The integration of sensor systems for monitoring and controlling the state of the chemical synthesis machine, as well as high resolution spectroscopic tools, is vital for facilitating closed-loop autonomous experiments. Systems that not only make molecules and materials, but also optimize their function, and use algorithms to assist with the development of new synthetic pathways and process optimization are also possible. Digital-chemical robot systems need to integrate feedback from simple sensors, such as conductivity or temperature, as well as online analytics in order to navigate process space autonomously. This opens the door to accessing known molecules (synthesis), exploring whether known compounds/reactions are possible under new conditions (optimization), and searching chemical space for unknown and unexpected new molecules, reactions, and modes of reactivity (discovery).',
8 | sources: [
9 | {
10 | item: {
11 | id: 242,
12 | type: 'journalArticle' as const,
13 | },
14 | attachment: {
15 | id: 244,
16 | type: 'attachment-pdf-link' as const,
17 | },
18 | bib: '(1) Wilbraham, L.; Mehr, S. H. M.; Cronin, L. Digitizing Chemistry Using the Chemical Processing Unit: From Synthesis to Discovery. Acc. Chem. Res. 2021, 54 (2), 253–262. https://doi.org/10.1021/acs.accounts.0c00674.\n',
19 | },
20 | {
21 | item: {
22 | id: 335,
23 | type: 'journalArticle' as const,
24 | },
25 | bib: '(2) Hammer, A. J. S.; Leonov, A. I.; Bell, N. L.; Cronin, L. Chemputation and the Standardization of Chemical Informatics. JACS Au 2021, 1 (10), 1572–1587. https://doi.org/10.1021/jacsau.1c00303.\n',
26 | },
27 | ],
28 | },
29 | },
30 | }
31 |
--------------------------------------------------------------------------------
/src/views/components/test/data/urlMessage.ts:
--------------------------------------------------------------------------------
1 | export const urlMessageAction: any = {
2 | action: 'clarification',
3 | payload: {
4 | widget: 'MARKDOWN',
5 | input: {
6 | content: 'This is a link to [www.google.com](www.google.com).',
7 | },
8 | },
9 | }
10 |
--------------------------------------------------------------------------------
/src/views/components/types.ts:
--------------------------------------------------------------------------------
1 | export interface Control {
2 | scrollToEnd: () => void
3 | pauseScroll: () => void
4 | resumeScroll: () => void
5 | addFunctionCallOutput: (tool_call_id: string, output: string) => void
6 | }
7 |
--------------------------------------------------------------------------------
/src/views/features/Header.tsx:
--------------------------------------------------------------------------------
1 | import React, { useState, useEffect } from "react"
2 | import { config, version } from "../../../package.json"
3 | import { useScrollPosition } from "../../hooks/useScroll"
4 |
5 | interface HeaderProps {
6 | containerRef: React.RefObject
11 |
17 |
12 |
16 |
13 | {children}
14 |
15 |
38 |
61 |
41 | 
46 |
47 |
46 |
48 |
60 | 51 | A.R.I.A. 52 | (Aria) 53 |
54 |
57 | Your AI Research Assistant
58 |
59 |
62 | {children}
63 |
64 |
28 | {notification}
29 |
30 | )
31 | }
32 |
--------------------------------------------------------------------------------
/src/views/features/infoPanel/FAQ.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import { Link } from '../../components/buttons/Link'
3 |
4 | interface QuestionProps {
5 | question: string
6 | answer: string | JSX.Element
7 | }
8 |
9 | function Question({ question, answer }: QuestionProps) {
10 | return (
11 |
12 |
15 | )
16 | }
17 |
18 | const questions = [
19 | {
20 | question: 'I cannot use Aria, even though I have a ChatGPT Plus subscription.',
21 | answer: (
22 | {question}
13 |{answer}
14 |
23 | ChatGPT Plus and GPT APIs are different offerings from OpenAI. Aria requires
24 | the GPT APIs to work. Please make sure you have a valid OpenAI API key:{' '}
25 | , and note that
26 | OpenAI may limit certain GPT models to paying customers only.
27 |
28 | ),
29 | },
30 | {
31 | question: 'Can I use an OpenAI proxy server or the Azure OpenAI?',
32 | answer:
33 | 'If you access the OpenAI APIs through a proxy server, you can update the OpenAI API base URL accordingly in Preferences > Aria. As for Azure OpenAI, it is unfortunately not supported at the moment.',
34 | },
35 | {
36 | question: 'I encountered an error when using Aria. What should I do?',
37 | answer: (
38 |
39 | Common errors include: 1. invalid OpenAI API key, 2. invalid API base URL or proxy server error, 3. no access to
40 | certain GPT model(s). Please feel free to{' '}
41 | on the GitHub
42 | repo for assistance.
43 |
44 | ),
45 | },
46 | {
47 | question: 'Does Aria support languages other than English?',
48 | answer:
49 | 'Aria officially only supports English. However, as the underlying GPT models are multilingual, you may have success in conversing with Aria in other languages',
50 | },
51 | {
52 | question: "What if I have a question that isn't answered here?",
53 | answer: (
54 |
55 | You are welcome to{' '}
56 | or{' '}
57 | on the
58 | GitHub repo.
59 |
60 | ),
61 | },
62 | ]
63 |
64 | export function FAQ() {
65 | return (
66 | -
67 | {questions.map(({ question, answer }) => (
68 |
-
69 |
70 |
71 | ))}
72 |
27 |
34 | )
35 | }
36 |
--------------------------------------------------------------------------------
/src/views/features/input/States.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import { XCircleIcon } from "@heroicons/react/24/outline"
3 | import { SelectionIcon } from "../../icons/zotero"
4 | import {
5 | States,
6 | SelectedImage,
7 | StateName,
8 | selectionConfig,
9 | } from "../../../models/utils/states"
10 | import { useStates } from "../../../hooks/useStates"
11 |
12 | interface ChipProps {
13 | children: React.ReactNode
14 | onDelete: () => void
15 | name: StateName
16 | }
17 |
18 | function Chip({ children, onDelete, name }: ChipProps) {
19 | const backgroundColor = selectionConfig[name].backgroundColor
20 | return (
21 |
29 | {groups.map(({ key, component }) => {
30 | return selected === key ? {component} : null
31 | })}
32 |
33 |
25 | {children}
26 |
27 |
33 | )
34 | }
35 |
36 | function SelectionContainer({
37 | states,
38 | name,
39 | }: {
40 | states: ReturnType
50 |
51 | {name}
52 |
53 | {selections.map((selection) => {
54 | const { id, type, title } = selection
55 | return name === "images" ? (
56 | states.remove(name, selection)}
85 | name={name}
86 | >
87 |
88 |
92 | )
93 | })}
94 | {selections.length > 2 && (
95 | states.removeAll(name)}
98 | >
99 | Remove all {name}
100 |
101 | )}
102 |
103 | )
104 | }
105 |
106 | interface StatesProps {
107 | states: ReturnType
60 |
81 | ) : (
82 |
64 |
73 | {id}
65 |
66 |
67 | states.remove(name, selection)}
69 | className="text-gray-400 hover:text-black"
70 | />
71 |
72 |
74 | 
79 |
80 |
120 | {stateNames.map((name) => (
121 |
124 | )
125 | }
126 |
--------------------------------------------------------------------------------
/src/views/features/messages/MessageControl.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import { marked } from "marked"
3 | import {
4 | BotMessageProps,
5 | UserMessageProps,
6 | } from "../../../typings/legacyMessages"
7 | import { CopyButton } from "../../components/buttons/CopyButton"
8 | import { NoteButton } from "../../components/buttons/NoteButton"
9 | import { AnnotateButton } from "../../components/buttons/AnnotateButton"
10 |
11 | function defaultCopy(input: any) {
12 | const textContent = "" + JSON.stringify(input, null, 2) + "" 13 | const htmlContent = marked(textContent) 14 | return new ztoolkit.Clipboard() 15 | .addText(textContent, "text/unicode") 16 | .addText(htmlContent, "text/html") 17 | .copy() 18 | } 19 | 20 | interface MessageControlProps 21 | extends Pick
33 | {text}
34 |
35 | )
36 | }
37 |
38 | export function compileContent({ input: { content: textContent } }: Props) {
39 | const htmlContent = marked(textContent)
40 | return { textContent, htmlContent }
41 | }
42 |
43 | function copy(props: Props) {
44 | const { textContent, htmlContent } = compileContent(props)
45 | return new ztoolkit.Clipboard()
46 | .addText(textContent, "text/unicode")
47 | .addText(htmlContent, "text/html")
48 | .copy()
49 | }
50 |
51 | async function createNote(props: Props) {
52 | const { htmlContent } = compileContent(props)
53 | const note =
54 | '' +
55 | `
"
58 | return note
59 | }
60 |
61 | function createAnnotation(props: Props) {
62 | const { textContent } = compileContent(props)
63 | return textContent
64 | }
65 |
66 | export const buttonDefs = [
67 | {
68 | name: "COPY",
69 | utils: { copy },
70 | } as copyButtonDef,
71 | {
72 | name: "NOTE",
73 | utils: { createNote },
74 | } as noteButtonDef,
75 | {
76 | name: "ANNOTATION",
77 | utils: { createAnnotation },
78 | } as annotationButtonDef,
79 | ]
80 |
--------------------------------------------------------------------------------
/src/views/features/messages/steps/ActionStep.tsx:
--------------------------------------------------------------------------------
1 | import React, { useEffect } from "react"
2 | import { ActionStepContent, ActionStepControl } from "../../../../typings/steps"
3 | import { CodeHighlighter } from "../../../components/code/CodeHighlighter"
4 | import stringify from "json-stringify-pretty-compact"
5 | import { SearchAction } from "../actions/SearchAction"
6 | import { FileAction } from "../actions/FileAction"
7 | import { QAAction } from "../actions/QAAction"
8 | import { RetryAction } from "../actions/RetryAction"
9 |
10 | export interface ActionStepProps {
11 | content: ActionStepContent
12 | control: ActionStepControl
13 | }
14 |
15 | export function ActionStep({ content, control }: ActionStepProps) {
16 | switch (content.params.action.type) {
17 | case "search": {
18 | return New Note from ${config.addonName} - ${new Date().toLocaleString()}
` + 56 | htmlContent + 57 | "
53 |
54 |
78 |
104 |
105 | )
106 | }
107 |
--------------------------------------------------------------------------------
/src/views/features/messages/steps/WorkflowStep.tsx:
--------------------------------------------------------------------------------
1 | import React, { useEffect } from "react"
2 | import {
3 | WorkflowStepContent,
4 | WorkflowStepControl,
5 | } from "../../../../typings/steps"
6 | import { CodeHighlighter } from "../../../components/code/CodeHighlighter"
7 | import stringify from "json-stringify-pretty-compact"
8 | import { SearchWorkflow } from "../workflows/SearchWorkflow"
9 | import { QAWorkflow } from "../workflows/QAWorkflow"
10 |
11 | export interface WorkflowStepProps {
12 | content: WorkflowStepContent
13 | control: WorkflowStepControl
14 | }
15 |
16 | export function WorkflowStep({ content, control }: WorkflowStepProps) {
17 | switch (content.params.workflow.type) {
18 | case "search": {
19 | return
79 |
103 | {toolInfo.description}
80 |
81 |
87 | {status === "COMPLETED" ? (
88 | <>
89 | The following response was used:
90 |
91 |
98 |
99 | ) : (
100 |
95 | {output}
96 |
97 | Waiting for response...
101 | )}
102 |
110 | //
116 | // )
117 | }
118 |
--------------------------------------------------------------------------------
/src/views/features/messages/workflows/SearchWorkflow.tsx:
--------------------------------------------------------------------------------
1 | import React, { useState, useEffect } from "react"
2 | import {
3 | SearchActionStepContent,
4 | SearchWorkflowStepContent,
5 | WorkflowStepControl,
6 | } from "../../../../typings/steps"
7 | import { workflow as log } from "../../../../utils/loggers"
8 | import type { recursiveSearchAndCompileResults } from "../../../../apis/zotero/search"
9 | import { invoke } from "lodash"
10 |
11 | interface SearchWorkflowProps {
12 | content: SearchWorkflowStepContent
13 | control: WorkflowStepControl
14 | }
15 |
16 | export function SearchWorkflow({
17 | content,
18 | control: { scrollToEnd, pauseScroll, getBotStep, addBotStep, updateBotStep },
19 | }: SearchWorkflowProps) {
20 | useEffect(() => {
21 | async function invokeSearchAction() {
22 | await addBotStep(content.messageId, {
23 | type: "ACTION_STEP",
24 | params: {
25 | action: {
26 | type: "search",
27 | mode: "search",
28 | },
29 | workflow: {
30 | type: "search",
31 | messageId: content.messageId,
32 | stepId: content.id,
33 | },
34 | },
35 | })
36 | }
37 | async function addSearchResultsStep() {
38 | // const searchResultsBotStep = getBotStep(
39 | // content.messageId,
40 | // content.params.searchResultsStepId!,
41 | // ) as SearchActionStepContent
42 | // log("Search results", { searchResultsBotStep })
43 | await addBotStep(content.messageId, {
44 | type: "MESSAGE_STEP",
45 | status: "COMPLETED",
46 | params: {
47 | messages: [
48 | {
49 | type: "WIDGET",
50 | params: {
51 | widget: "search",
52 | message: {
53 | query: content.params.context.query,
54 | searchResultsStepId: content.params.searchResultsStepId!,
55 | },
56 | },
57 | },
58 | ],
59 | },
60 | })
61 | }
62 | if (content.status !== "COMPLETED") {
63 | if (!content.params.searchResultsStepId) {
64 | invokeSearchAction()
65 | } else {
66 | addSearchResultsStep()
67 | updateBotStep(content.messageId, content.id, { status: "COMPLETED" })
68 | }
69 | }
70 | }, [content])
71 |
72 | const { messageId, id, status, params } = content
73 |
74 | return null
75 | // return (
76 | // SearchWorkflowStep
111 | //Status: {status}
112 | // MessageId: {messageId}
113 | // id: {id}
114 | // Params: {JSON.stringify(params)}
115 | //
77 | //
83 | // )
84 | }
85 |
--------------------------------------------------------------------------------
/src/views/icons/file.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import {
3 | DocumentArrowUpIcon,
4 | DocumentMagnifyingGlassIcon,
5 | } from "@heroicons/react/24/outline"
6 |
7 | export function FileUploadIcon() {
8 | return (
9 |
10 | SearchWorkflowStep
78 | //Status: {status}
79 | // MessageId: {messageId}
80 | // id: {id}
81 | // Params: {JSON.stringify(params)}
82 | // 
15 |
16 | )
17 | }
18 |
--------------------------------------------------------------------------------
/src/views/icons/style.css:
--------------------------------------------------------------------------------
1 | .icon-collection {
2 | height: 16px;
3 | width: 16px;
4 | }
5 |
6 | .icon-groups {
7 | height: 16px;
8 | width: 16px;
9 | }
--------------------------------------------------------------------------------
/src/views/icons/ui.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 |
3 | export function XCircleIcon() {
4 | return (
5 |
8 | )
9 | }
10 |
--------------------------------------------------------------------------------
/src/views/icons/zotero.tsx:
--------------------------------------------------------------------------------
1 | import React from "react"
2 | import { StateName } from "../../typings/input"
3 | import "./style.css"
4 |
5 | interface IconProps {
6 | enlarged?: boolean
7 | }
8 |
9 | interface BaseIconProps extends IconProps {
10 | category: string
11 | type?: string | undefined
12 | }
13 |
14 | // All available icons: https://github.com/zotero/zotero/tree/f012a348af1143a7e033d697beae86df729080ab/chrome/skin/default/zotero
15 | function BaseIcon({ category, type, enlarged = false }: BaseIconProps) {
16 | // tag.png is no longer available: https://github.com/zotero/zotero/blob/main/chrome/skin/default/zotero/tag.svg
17 | const url =
18 | category === "tag"
19 | ? "chrome://zotero/skin/tag.svg"
20 | : type
21 | ? `chrome://zotero/skin/${category}-${type}${enlarged ? "@2x" : ""}.png`
22 | : `chrome://zotero/skin/${category}${enlarged ? "@2x" : ""}.png`
23 | return (
24 |
25 | 
109 |
110 | )
111 | }
112 |
--------------------------------------------------------------------------------
/src/views/style.css:
--------------------------------------------------------------------------------
1 | @tailwind base;
2 | @tailwind components;
3 | @tailwind utilities;
4 |
5 | .dot-flashing {
6 | position: relative;
7 | width: 10px;
8 | height: 10px;
9 | border-radius: 5px;
10 | background-color: #9880ff;
11 | color: #9880ff;
12 | animation: dot-flashing 1s infinite linear alternate;
13 | animation-delay: 0.5s;
14 | }
15 | .dot-flashing::before,
16 | .dot-flashing::after {
17 | content: "";
18 | display: inline-block;
19 | position: absolute;
20 | top: 0;
21 | }
22 | .dot-flashing::before {
23 | left: -15px;
24 | width: 10px;
25 | height: 10px;
26 | border-radius: 5px;
27 | background-color: #9880ff;
28 | color: #9880ff;
29 | animation: dot-flashing 1s infinite alternate;
30 | animation-delay: 0s;
31 | }
32 | .dot-flashing::after {
33 | left: 15px;
34 | width: 10px;
35 | height: 10px;
36 | border-radius: 5px;
37 | background-color: #9880ff;
38 | color: #9880ff;
39 | animation: dot-flashing 1s infinite alternate;
40 | animation-delay: 1s;
41 | }
42 |
43 | @keyframes dot-flashing {
44 | 0% {
45 | background-color: #9880ff;
46 | }
47 | 50%,
48 | 100% {
49 | background-color: rgba(152, 128, 255, 0.2);
50 | }
51 | }
52 |
53 | .saturation-pulse {
54 | filter: saturate(0); /* Start as grayscale */
55 | animation: saturation-pulse 2s infinite; /* Apply the animation */
56 | }
57 |
58 | @keyframes saturation-pulse {
59 | 0% {
60 | filter: saturate(0); /* Grayscale */
61 | }
62 | 50% {
63 | filter: saturate(2); /* Over-saturated */
64 | }
65 | 100% {
66 | filter: saturate(0); /* Back to grayscale */
67 | }
68 | }
69 |
70 | .collapsible-panel-appear {
71 | display: none;
72 | opacity: 0;
73 | }
74 | .collapsible-panel-appear-active {
75 | opacity: 1;
76 | transition: opacity 200ms;
77 | }
78 | .collapsible-panel-appear-done {
79 | opacity: 1;
80 | }
81 | .collapsible-panel-enter {
82 | display: none;
83 | opacity: 0;
84 | display: grid;
85 | grid-template-rows: 0fr;
86 | }
87 |
88 | .collapsible-panel-enter-active {
89 | opacity: 1;
90 | display: grid;
91 | grid-template-rows: 1fr;
92 | transition:
93 | opacity 200ms,
94 | grid-template-rows 200ms;
95 | }
96 |
97 | .collapsible-panel-exit {
98 | opacity: 1;
99 | display: grid;
100 | grid-template-rows: 1fr;
101 | }
102 |
103 | .collapsible-panel-exit-active {
104 | opacity: 0;
105 | display: grid;
106 | grid-template-rows: 0fr;
107 | transition:
108 | opacity 200ms,
109 | grid-template-rows 200ms;
110 | }
111 |
112 | .collapsible-panel-exit-done {
113 | display: none;
114 | }
115 |
--------------------------------------------------------------------------------
/src/views/utils/markdown.tsx:
--------------------------------------------------------------------------------
1 | import React, { ReactNode } from "react"
2 | import { ItemButton } from "../components/buttons/ItemButton"
3 |
4 | export const customMarkdownRenderer = {
5 | link(href: string, content: ReactNode | string) {
6 | if (href.startsWith("aria://items/")) {
7 | const [type, id] = href.slice(13).split("/")
8 | return (
9 |