10909436048

Committed 17 Sep 2024 07:07PM UTC coverage: 31.853% (-0.03%) from 31.878%

Build # 10909436048

Build Type

Pull #9701

github

Committed by

b0b3rt

Commit Message

switch to error only on conflicting key values

Pull Request Pull Request #9701: fix graphql resolver args

Run Details

5026 of 41189 branches covered (12.2%)

Branch coverage included in aggregate %.

13 of 23 new or added lines in 6 files covered. (56.52%)

610 existing lines in 24 files now uncovered.

29355 of 66746 relevant lines covered (43.98%)

187.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

8.29

/packages/lesswrong/server/autocompleteEndpoint.ts

import type { Express } from "express";
import { getContextFromReqAndRes, getUserFromReq } from "./vulcan-lib/apollo-server/context";
import { userIsAdmin } from "@/lib/vulcan-users/permissions";
import { getAnthropicPromptCachingClientOrThrow } from "./languageModels/anthropicClient";
import express from "express";
import { PromptCachingBetaMessageParam } from "@anthropic-ai/sdk/resources/beta/prompt-caching/messages";
import { formatRelative } from "@/lib/utils/timeFormat";
import { Readable } from 'stream';
import { pipeline } from 'stream/promises'
import { hyperbolicApiKey } from "@/lib/instanceSettings";
import { runFragmentQuery } from "./vulcan-lib/query";
import Users from "@/lib/vulcan-users";



const getParentComments = (comment: CommentsForAutocompleteWithParents) => {
  const parentComments: CommentsForAutocompleteWithParents[] = [];
  let currentComment: CommentsForAutocompleteWithParents | null = comment;
  while (currentComment.parentComment && currentComment.parentComment._id !== currentComment._id) {
    currentComment = currentComment.parentComment as CommentsForAutocompleteWithParents;
    if (currentComment) {
      parentComments.push(currentComment);
    } else {
      break;
    }
  }
  return parentComments.reverse();
}

const getPostBodyFormatted = (post: PostsForAutocomplete) => {
  return `${post.title}
by ${post.user?.displayName}
${post.baseScore}
${post.contents?.markdown}`.trim();
}

const getCommentBodyFormatted = (comment: CommentsForAutocomplete) => {
  const dateString = formatRelative(new Date(comment.createdAt), new Date(), false)
  return `Comment on ${comment.post?.title}
${comment.user?.displayName} ${dateString} ${comment.baseScore} ${comment.extendedScore?.agreement}
${comment.contents?.markdown}`.trim();
}

const getPostReplyMessageFormatted = (post: PostsForAutocomplete, currentUser: DbUser, prefix: string) => {
  return `${getPostBodyFormatted(post)}
---
Comment on ${post.title}
${currentUser.displayName} 1h ${Math.floor(20 + (Math.random() * 75))} ${Math.floor((Math.random() - 0.35) * 100)}
${prefix}`.trim();
}

const getCommentReplyMessageFormatted = (comment: CommentsForAutocompleteWithParents, prefix: string, currentUser: DbUser) => {
  const parentComments = getParentComments(comment);
  return `${getPostBodyFormatted(comment.post!)}
---
${parentComments.map((comment) => getCommentBodyFormatted(comment)).join("\n---\n")}
---
${getCommentBodyFormatted(comment)}
---
Comment on ${comment.post?.title}
${currentUser.displayName} 1h ${Math.floor(20 + (Math.random() * 75))} ${Math.floor((Math.random() - 0.5) * 100)}
${prefix}`.trim();
}

async function constructMessageHistory(
  prefix: string,
  commentIds: string[],
  postIds: string[],
  user: DbUser,
  context: ResolverContext,
  replyingCommentId?: string,
  postId?: string
): Promise<PromptCachingBetaMessageParam[]> {
  const messages: PromptCachingBetaMessageParam[] = [];

  // Make the fetches parallel to save time
  const [posts, comments] = await Promise.all([
    runFragmentQuery({
      collectionName: "Posts",
      fragmentName: "PostsForAutocomplete",
      terms: { postIds },
      context,
    }),
    runFragmentQuery({
      collectionName: "Comments",
      fragmentName: "CommentsForAutocomplete",
      terms: { commentIds },
      context,
    }),
  ]);

  // eslint-disable-next-line no-console
  console.log(`Converting ${posts.length} posts and ${comments.length} comments to messages`);

  // Add fetched posts and comments to message history
  for (const post of posts) {
    messages.push({
      role: "user",
      content: [{ type: "text", text: `<cmd>cat lw/${post._id}.txt</cmd>` }],
    });

    messages.push({
      role: "assistant",
      content: [
        {
          type: "text",
          text: getPostBodyFormatted(post),
        },
      ],
    });
  }

  for (const comment of comments) {
    messages.push({
      role: "user",
      content: [{ type: "text", text: `<cmd>cat lw/${comment._id}.txt</cmd>` }],
    });

    messages.push({
      role: "assistant",
      content: [{ type: "text", text: getCommentBodyFormatted(comment) }],
    });
  }

  // Add final user message with prefix
  messages.push({
    role: "user",
    content: [{ type: "text", text: `<cmd>cat lw/hsqKp56whpPEQns3Z.txt</cmd>`, cache_control: {type: "ephemeral"}}]
  });

  if (replyingCommentId) {
    // Fetch the comment we're replying to
    const replyingToCommentResponse = await runFragmentQuery({
      collectionName: "Comments",
      fragmentName: "CommentsForAutocompleteWithParents",
      terms: { commentIds: [replyingCommentId] },
      context,
    })
    if (!replyingToCommentResponse || replyingToCommentResponse.length === 0) {
      throw new Error("Comment not found");
    }
    const replyingToComment = replyingToCommentResponse[0];
    const message = getCommentReplyMessageFormatted(replyingToComment, prefix, user)

    messages.push({
      role: "assistant",
      content: [
        {
          type: "text",
          text: message
        },
      ],
    });
  }
  else if (postId) {
    const postResponse = await runFragmentQuery({
      collectionName: "Posts",
      fragmentName: "PostsForAutocomplete",
      terms: { postIds: [postId] },
      context,
    })
    if (!postResponse || postResponse.length === 0) {
      throw new Error("Post not found");
    }
    const post = postResponse[0];

    messages.push({
      role: "assistant",
      content: [
        {
          type: "text",
          text: getPostReplyMessageFormatted(post, user, prefix)
        },
      ],
    });
  }
  else {
    messages.push({
      role: "assistant",
      content: [
        {
          type: "text",
          text: `${prefix}`
        }
      ]
    });
  }
  return messages;
}

async function construct405bPrompt(
  prefix: string,
  commentIds: string[],
  postIds: string[],
  user: DbUser,
  context: ResolverContext,
  replyingCommentId?: string,
  postId?: string
): Promise<string> {

  // Make the fetches parallel to save time
  const [posts, comments] = await Promise.all([
    runFragmentQuery({
      collectionName: "Posts",
      fragmentName: "PostsForAutocomplete",
      terms: { postIds },
      context,
    }),
    runFragmentQuery({
      collectionName: "Comments",
      fragmentName: "CommentsForAutocomplete",
      terms: { commentIds },
      context,
    }),
  ]);


  // eslint-disable-next-line no-console
  console.log(`Converting ${posts.length} posts and ${comments.length} comments to messages`, postId, replyingCommentId);

  let finalSection = ''

  if (replyingCommentId) {
    // Fetch the comment we're replying to
    const replyingToCommentResponse = await runFragmentQuery({
      collectionName: "Comments",
      fragmentName: "CommentsForAutocompleteWithParents",
      terms: { commentIds: [replyingCommentId] },
      context,
    })
    if (!replyingToCommentResponse || replyingToCommentResponse.length === 0) {
      throw new Error("Comment not found");
    }
    const replyingToComment = replyingToCommentResponse[0];

    finalSection = getCommentReplyMessageFormatted(replyingToComment, prefix, user)    
  } else if (postId) {
    const postResponse = await runFragmentQuery({
      collectionName: "Posts",
      fragmentName: "PostsForAutocomplete",
      terms: { postIds: [postId] },
      context,
    })
    if (!postResponse || postResponse.length === 0) {
      throw new Error("Post not found");
    }
    const post = postResponse[0];

    finalSection = getPostReplyMessageFormatted(post, user, prefix)
  } else {
    finalSection = `${prefix}`
  }


  return `
${posts.map((post) => getPostBodyFormatted(post)).join("\n---\n")}
====
${comments.map((comment) => getCommentBodyFormatted(comment)).join("\n---\n")}
====
${finalSection}`.trim();
}


export function addAutocompleteEndpoint(app: Express) {
  app.use("/api/autocomplete", express.json());
  app.post("/api/autocomplete", async (req, res) => {
    const context = await getContextFromReqAndRes({req, res, isSSR: false});
    const currentUser = context.currentUser
    if (!currentUser) {
      return res.status(401).json({ error: "Unauthorized" });
    }

    try {
      if (!userIsAdmin(currentUser)) {
        throw new Error("Claude Completion is for admins only");
      }

      const client = getAnthropicPromptCachingClientOrThrow();

      const { prefix = '', commentIds, postIds, replyingCommentId, postId, userId } = req.body;
      const user = userId ? await context.loaders.Users.load(userId) : undefined;

      // Set headers for streaming response
      res.writeHead(200, {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        Connection: "keep-alive",
      });

      const loadingMessagesStream = client.messages.stream({
        model: "claude-3-5-sonnet-20240620",
        max_tokens: 1000,
        system: "The assistant is in CLI simulation mode, and responds to the user's CLI commands only with the output of the command.",
        messages: await constructMessageHistory(
          prefix,
          commentIds,
          postIds,
          user ?? currentUser,
          context,
          replyingCommentId,
          postId
        ),
      });

      loadingMessagesStream.on("text", (delta, snapshot) => {
        res.write(
          `data: ${JSON.stringify({ type: "text", content: delta })}\n\n`,
        );
      });

      loadingMessagesStream.on("end", () => {
        res.write(`data: ${JSON.stringify({ type: "end" })}\n\n`);
        res.end();
      });

      loadingMessagesStream.on("error", (error) => {
        // eslint-disable-next-line no-console
        console.error("Stream error:", JSON.stringify(error));
        res.write(
          `data: ${JSON.stringify({ type: "error", message: "An error occurred" })}\n\n`,
        );
        res.end();
      });
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error("Autocomplete error:", error);
      res.status(500).json({ error: "An error occurred during autocomplete" });
    }
  });
  app.use("/api/autocomplete405b", express.json());
  app.post("/api/autocomplete405b", async (req, res) => {
    const context = await getContextFromReqAndRes({req, res, isSSR: false});
    const currentUser = context.currentUser
    if (!currentUser) {
      return res.status(401).json({ error: "Unauthorized" });
    }
    
    try {
      if (!userIsAdmin(currentUser)) {
        throw new Error("Claude Completion is for admins only");
      }
  
      const { prefix = '', commentIds, postIds, replyingCommentId, postId, userId } = req.body;
      const user = userId ? await Users.findOne({ _id: userId}) : undefined;

      // Set headers for streaming response
      res.writeHead(200, {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        Connection: "keep-alive",
      });
  
      const url = 'https://api.hyperbolic.xyz/v1/completions';
  
      const response = await fetch(url, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${hyperbolicApiKey.get()}`,
        },
        body: JSON.stringify({
          model: 'meta-llama/Meta-Llama-3.1-405B',
          prompt: await construct405bPrompt(
            prefix,
            commentIds,
            postIds,
            user ?? currentUser,
            context,
            replyingCommentId,
            postId
          ),
          max_tokens: 256,
          temperature: 0.7,
          top_p: 0.9,
          stream: true
        }),
      });
  
      if (!response.ok || !response.body) {
        res.writeHead(response.status, response.statusText);
        res.end(`Error from API: ${response.statusText}`);
        return;
      }
      const reader = response.body.getReader();
      const readableNodeStream = new Readable({
        async read() {
          const { done, value } = await reader.read();
          if (done) {
            this.push(null);
          } else {
            this.push(Buffer.from(value));
          }
        }
      });

      await pipeline(readableNodeStream, res);
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error("Autocomplete error:", error);
      res.status(500).json({ error: "An error occurred during autocomplete" });
    }
  });
}

1	import type { Express } from "express";	54✔
2	import { getContextFromReqAndRes, getUserFromReq } from "./vulcan-lib/apollo-server/context";	18✔
3	import { userIsAdmin } from "@/lib/vulcan-users/permissions";	18✔
4	import { getAnthropicPromptCachingClientOrThrow } from "./languageModels/anthropicClient";	18✔
5	import express from "express";	18✔
6	import { PromptCachingBetaMessageParam } from "@anthropic-ai/sdk/resources/beta/prompt-caching/messages";
7	import { formatRelative } from "@/lib/utils/timeFormat";	18✔
8	import { Readable } from 'stream';	18✔
9	import { pipeline } from 'stream/promises'	18✔
10	import { hyperbolicApiKey } from "@/lib/instanceSettings";	18✔
11	import { runFragmentQuery } from "./vulcan-lib/query";	18✔
12	import Users from "@/lib/vulcan-users";	18✔
13
14
15
16	const getParentComments = (comment: CommentsForAutocompleteWithParents) => {	18✔
17	const parentComments: CommentsForAutocompleteWithParents[] = [];	×
18	let currentComment: CommentsForAutocompleteWithParents \| null = comment;	×
19	while (currentComment.parentComment && currentComment.parentComment._id !== currentComment._id) {	×
20	currentComment = currentComment.parentComment as CommentsForAutocompleteWithParents;	×
21	if (currentComment) {	×
22	parentComments.push(currentComment);	×
23	} else {
24	break;	×
25	}
26	}
27	return parentComments.reverse();	×
28	}
29
30	const getPostBodyFormatted = (post: PostsForAutocomplete) => {	18✔
31	return `${post.title}	×
32	by ${post.user?.displayName}	×
33	${post.baseScore}
34	${post.contents?.markdown}`.trim();	×
35	}
36
37	const getCommentBodyFormatted = (comment: CommentsForAutocomplete) => {	18✔
38	const dateString = formatRelative(new Date(comment.createdAt), new Date(), false)	×
39	return `Comment on ${comment.post?.title}	×
40	${comment.user?.displayName} ${dateString} ${comment.baseScore} ${comment.extendedScore?.agreement}	×
41	${comment.contents?.markdown}`.trim();	×
42	}
43
44	const getPostReplyMessageFormatted = (post: PostsForAutocomplete, currentUser: DbUser, prefix: string) => {	18✔
45	return `${getPostBodyFormatted(post)}	×
46	---
47	Comment on ${post.title}
48	${currentUser.displayName} 1h ${Math.floor(20 + (Math.random() * 75))} ${Math.floor((Math.random() - 0.35) * 100)}
49	${prefix}`.trim();
50	}
51
52	const getCommentReplyMessageFormatted = (comment: CommentsForAutocompleteWithParents, prefix: string, currentUser: DbUser) => {	18✔
53	const parentComments = getParentComments(comment);	×
54	return `${getPostBodyFormatted(comment.post!)}	×
55	---
56	${parentComments.map((comment) => getCommentBodyFormatted(comment)).join("\n---\n")}	×
57	---
58	${getCommentBodyFormatted(comment)}
59	---
60	Comment on ${comment.post?.title}	×
61	${currentUser.displayName} 1h ${Math.floor(20 + (Math.random() * 75))} ${Math.floor((Math.random() - 0.5) * 100)}
62	${prefix}`.trim();
63	}
64
65	async function constructMessageHistory(
66	prefix: string,
67	commentIds: string[],
68	postIds: string[],
69	user: DbUser,
70	context: ResolverContext,
71	replyingCommentId?: string,
72	postId?: string
73	): Promise<PromptCachingBetaMessageParam[]> {
74	const messages: PromptCachingBetaMessageParam[] = [];	×
75
76	// Make the fetches parallel to save time
77	const [posts, comments] = await Promise.all([	×
78	runFragmentQuery({
79	collectionName: "Posts",
80	fragmentName: "PostsForAutocomplete",
81	terms: { postIds },
82	context,
83	}),
84	runFragmentQuery({
85	collectionName: "Comments",
86	fragmentName: "CommentsForAutocomplete",
87	terms: { commentIds },
88	context,
89	}),
90	]);
91
92	// eslint-disable-next-line no-console
93	console.log(`Converting ${posts.length} posts and ${comments.length} comments to messages`);	×
94
95	// Add fetched posts and comments to message history
96	for (const post of posts) {	×
97	messages.push({	×
98	role: "user",
99	content: [{ type: "text", text: `<cmd>cat lw/${post._id}.txt</cmd>` }],
100	});
101
102	messages.push({	×
103	role: "assistant",
104	content: [
105	{
106	type: "text",
107	text: getPostBodyFormatted(post),
108	},
109	],
110	});
111	}
112
113	for (const comment of comments) {	×
114	messages.push({	×
115	role: "user",
116	content: [{ type: "text", text: `<cmd>cat lw/${comment._id}.txt</cmd>` }],
117	});
118
119	messages.push({	×
120	role: "assistant",
121	content: [{ type: "text", text: getCommentBodyFormatted(comment) }],
122	});
123	}
124
125	// Add final user message with prefix
126	messages.push({	×
127	role: "user",
128	content: [{ type: "text", text: `<cmd>cat lw/hsqKp56whpPEQns3Z.txt</cmd>`, cache_control: {type: "ephemeral"}}]
129	});
130
131	if (replyingCommentId) {	×
132	// Fetch the comment we're replying to
133	const replyingToCommentResponse = await runFragmentQuery({	×
134	collectionName: "Comments",
135	fragmentName: "CommentsForAutocompleteWithParents",
136	terms: { commentIds: [replyingCommentId] },
137	context,
138	})
139	if (!replyingToCommentResponse \|\| replyingToCommentResponse.length === 0) {	×
140	throw new Error("Comment not found");	×
141	}
142	const replyingToComment = replyingToCommentResponse[0];	×
143	const message = getCommentReplyMessageFormatted(replyingToComment, prefix, user)	×
144
145	messages.push({	×
146	role: "assistant",
147	content: [
148	{
149	type: "text",
150	text: message
151	},
152	],
153	});
154	}	×
155	else if (postId) {
156	const postResponse = await runFragmentQuery({	×
157	collectionName: "Posts",
158	fragmentName: "PostsForAutocomplete",
159	terms: { postIds: [postId] },
160	context,
161	})
162	if (!postResponse \|\| postResponse.length === 0) {	×
163	throw new Error("Post not found");	×
164	}
165	const post = postResponse[0];	×
166
167	messages.push({	×
168	role: "assistant",
169	content: [
170	{
171	type: "text",
172	text: getPostReplyMessageFormatted(post, user, prefix)
173	},
174	],
175	});
176	}
177	else {
178	messages.push({	×
179	role: "assistant",
180	content: [
181	{
182	type: "text",
183	text: `${prefix}`
184	}
185	]
186	});
187	}
188	return messages;	×
189	}
190
191	async function construct405bPrompt(
192	prefix: string,
193	commentIds: string[],
194	postIds: string[],
195	user: DbUser,
196	context: ResolverContext,
197	replyingCommentId?: string,
198	postId?: string
199	): Promise<string> {
200
201	// Make the fetches parallel to save time
202	const [posts, comments] = await Promise.all([	×
203	runFragmentQuery({
204	collectionName: "Posts",
205	fragmentName: "PostsForAutocomplete",
206	terms: { postIds },
207	context,
208	}),
209	runFragmentQuery({
210	collectionName: "Comments",
211	fragmentName: "CommentsForAutocomplete",
212	terms: { commentIds },
213	context,
214	}),
215	]);
216
217
218	// eslint-disable-next-line no-console
219	console.log(`Converting ${posts.length} posts and ${comments.length} comments to messages`, postId, replyingCommentId);	×
220
221	let finalSection = ''	×
222
223	if (replyingCommentId) {	×
224	// Fetch the comment we're replying to
225	const replyingToCommentResponse = await runFragmentQuery({	×
226	collectionName: "Comments",
227	fragmentName: "CommentsForAutocompleteWithParents",
228	terms: { commentIds: [replyingCommentId] },
229	context,
230	})
231	if (!replyingToCommentResponse \|\| replyingToCommentResponse.length === 0) {	×
232	throw new Error("Comment not found");	×
233	}
234	const replyingToComment = replyingToCommentResponse[0];	×
235
236	finalSection = getCommentReplyMessageFormatted(replyingToComment, prefix, user)	×
237	} else if (postId) {	×
238	const postResponse = await runFragmentQuery({	×
239	collectionName: "Posts",
240	fragmentName: "PostsForAutocomplete",
241	terms: { postIds: [postId] },
242	context,
243	})
244	if (!postResponse \|\| postResponse.length === 0) {	×
245	throw new Error("Post not found");	×
246	}
247	const post = postResponse[0];	×
248
249	finalSection = getPostReplyMessageFormatted(post, user, prefix)	×
250	} else {
251	finalSection = `${prefix}`	×
252	}
253
254
255	return `	×
256	${posts.map((post) => getPostBodyFormatted(post)).join("\n---\n")}	×
257	====
258	${comments.map((comment) => getCommentBodyFormatted(comment)).join("\n---\n")}	×
259	====
260	${finalSection}`.trim();
261	}
262
263
264	export function addAutocompleteEndpoint(app: Express) {
265	app.use("/api/autocomplete", express.json());	×
266	app.post("/api/autocomplete", async (req, res) => {	×
267	const context = await getContextFromReqAndRes({req, res, isSSR: false});	×
268	const currentUser = context.currentUser	×
269	if (!currentUser) {	×
270	return res.status(401).json({ error: "Unauthorized" });	×
271	}
272
273	try {	×
274	if (!userIsAdmin(currentUser)) {	×
275	throw new Error("Claude Completion is for admins only");	×
276	}
277
278	const client = getAnthropicPromptCachingClientOrThrow();	×
279
280	const { prefix = '', commentIds, postIds, replyingCommentId, postId, userId } = req.body;	×
281	const user = userId ? await context.loaders.Users.load(userId) : undefined;	×
282
283	// Set headers for streaming response
284	res.writeHead(200, {	×
285	"Content-Type": "text/event-stream",
286	"Cache-Control": "no-cache",
287	Connection: "keep-alive",
288	});
289
290	const loadingMessagesStream = client.messages.stream({	×
291	model: "claude-3-5-sonnet-20240620",
292	max_tokens: 1000,
293	system: "The assistant is in CLI simulation mode, and responds to the user's CLI commands only with the output of the command.",
294	messages: await constructMessageHistory(
295	prefix,
296	commentIds,
297	postIds,
298	user ?? currentUser,	×
299	context,
300	replyingCommentId,
301	postId
302	),
303	});
304
305	loadingMessagesStream.on("text", (delta, snapshot) => {	×
306	res.write(	×
307	`data: ${JSON.stringify({ type: "text", content: delta })}\n\n`,
308	);
309	});
310
311	loadingMessagesStream.on("end", () => {	×
312	res.write(`data: ${JSON.stringify({ type: "end" })}\n\n`);	×
313	res.end();	×
314	});
315
316	loadingMessagesStream.on("error", (error) => {	×
317	// eslint-disable-next-line no-console
318	console.error("Stream error:", JSON.stringify(error));	×
319	res.write(	×
320	`data: ${JSON.stringify({ type: "error", message: "An error occurred" })}\n\n`,
321	);
322	res.end();	×
323	});
324	} catch (error) {
325	// eslint-disable-next-line no-console
326	console.error("Autocomplete error:", error);	×
327	res.status(500).json({ error: "An error occurred during autocomplete" });	×
328	}
329	});
330	app.use("/api/autocomplete405b", express.json());	×
331	app.post("/api/autocomplete405b", async (req, res) => {	×
332	const context = await getContextFromReqAndRes({req, res, isSSR: false});	×
333	const currentUser = context.currentUser	×
334	if (!currentUser) {	×
335	return res.status(401).json({ error: "Unauthorized" });	×
336	}
337
338	try {	×
339	if (!userIsAdmin(currentUser)) {	×
340	throw new Error("Claude Completion is for admins only");	×
341	}
342
343	const { prefix = '', commentIds, postIds, replyingCommentId, postId, userId } = req.body;	×
344	const user = userId ? await Users.findOne({ _id: userId}) : undefined;	×
345
346	// Set headers for streaming response
347	res.writeHead(200, {	×
348	"Content-Type": "text/event-stream",
349	"Cache-Control": "no-cache",
350	Connection: "keep-alive",
351	});
352
353	const url = 'https://api.hyperbolic.xyz/v1/completions';	×
354
355	const response = await fetch(url, {	×
356	method: 'POST',
357	headers: {
358	'Content-Type': 'application/json',
359	Authorization: `Bearer ${hyperbolicApiKey.get()}`,
360	},
361	body: JSON.stringify({
362	model: 'meta-llama/Meta-Llama-3.1-405B',
363	prompt: await construct405bPrompt(
364	prefix,
365	commentIds,
366	postIds,
367	user ?? currentUser,	×
368	context,
369	replyingCommentId,
370	postId
371	),
372	max_tokens: 256,
373	temperature: 0.7,
374	top_p: 0.9,
375	stream: true
376	}),
377	});
378
UNCOV 379	if (!response.ok \|\| !response.body) {	×
380	res.writeHead(response.status, response.statusText);	×
381	res.end(`Error from API: ${response.statusText}`);	×
382	return;	×
383	}
UNCOV 384	const reader = response.body.getReader();	×
385	const readableNodeStream = new Readable({	×
386	async read() {
UNCOV 387	const { done, value } = await reader.read();	×
388	if (done) {	×
389	this.push(null);	×
390	} else {
UNCOV 391	this.push(Buffer.from(value));	×
392	}
393	}
394	});
395
UNCOV 396	await pipeline(readableNodeStream, res);	×
397	} catch (error) {
398	// eslint-disable-next-line no-console
UNCOV 399	console.error("Autocomplete error:", error);	×
400	res.status(500).json({ error: "An error occurred during autocomplete" });	×
401	}
402	});
403	}

ForumMagnum / ForumMagnum / 10909436048

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous