11601533701

Committed 30 Oct 2024 08:57PM UTC coverage: 31.32% (-0.008%) from 31.328%

Build # 11601533701

Build Type

Pull #9934

github

Committed by

b0b3rt

Commit Message

much stricter prompt

Pull Request Pull Request #9934: filter out terms that are probably familiar to LW audiences and clean up some other prompting

Run Details

5031 of 42403 branches covered (11.86%)

Branch coverage included in aggregate %.

10 of 50 new or added lines in 4 files covered. (20.0%)

95 existing lines in 5 files now uncovered.

29651 of 68332 relevant lines covered (43.39%)

173.74 hits per line

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

5.26

/packages/lesswrong/server/languageModels/llmApiWrapper.ts

import type { ChatModel as OpenAIModel, ChatCompletionSystemMessageParam as OpenAISystemMessage } from 'openai/resources/chat';
import type { ChatCompletionCreateParamsBase as OpenAISendMessagesParams } from 'openai/resources/chat/completions';
import type { Model as AnthropicModel } from '@anthropic-ai/sdk/resources/messages';
import type { MessageCreateParamsBase as AnthropicSendMessagesParams, PromptCachingBetaMessageParam as AnthropicMessage, PromptCachingBetaToolUseBlockParam as AnthropicMessageToolUseBlock, PromptCachingBetaToolResultBlockParam as AnthropicMessageToolResultBlock, PromptCachingBetaTextBlockParam as AnthropicMessageTextBlock, PromptCachingBetaTool } from '@anthropic-ai/sdk/resources/beta/prompt-caching/messages';

import { getOpenAI } from './languageModelIntegration';
import { getAnthropicPromptCachingClientOrThrow } from './anthropicClient';
import { z } from 'zod';
import { zodResponseFormat } from 'openai/helpers/zod';
import { zodToJsonSchema } from 'zod-to-json-schema';

interface SendToolUseRequest<T> {
  zodParser: z.ZodType<T>;
  name: string;
}

interface SendNonToolUseRequest {
  zodParser?: undefined;
  name?: undefined;
}

type SendMaybeToolUseRequest<T extends boolean, ZodType> = T extends true 
  ? SendToolUseRequest<ZodType> 
  : SendNonToolUseRequest;

export type SendOpenAIMessages<ToolUse extends boolean = false, ZodType = never> = SendMaybeToolUseRequest<ToolUse, ZodType> & {
  provider: 'openai';
  model: OpenAIModel;
  messages: OpenAISendMessagesParams['messages'];
  maxTokens: OpenAISendMessagesParams['max_tokens'];
  system?: AnthropicSendMessagesParams['system'];
}

export type SendAnthropicMessages<ToolUse extends boolean = false, ZodType = never> = SendMaybeToolUseRequest<ToolUse, ZodType> & {
  provider: 'anthropic';
  model: AnthropicModel;
  messages: Array<Omit<AnthropicMessage, 'content'> & { content: string | (AnthropicMessageTextBlock | AnthropicMessageToolUseBlock | AnthropicMessageToolResultBlock)[] }>;
  maxTokens: AnthropicSendMessagesParams['max_tokens'];
  system?: AnthropicSendMessagesParams['system'];
  customApiKey?: string;
}

export type SendLLMMessagesArgs<
  ToolUse extends boolean = boolean,
  ZodType = any
> = SendOpenAIMessages<ToolUse, ZodType> | SendAnthropicMessages<ToolUse, ZodType>;

type SendLLMMessageReturnTypes<T extends SendLLMMessagesArgs> = T['zodParser'] extends undefined ? string : z.infer<Exclude<T['zodParser'], undefined>> | null;

function convertAnthropicToolsToOpenAI(tools: Exclude<AnthropicSendMessagesParams['tools'], undefined>): OpenAISendMessagesParams['tools'] {
  return tools.map(tool => {
    return {
      type: 'function',
      function: {
        name: tool.name,
        description: tool.description,
        parameters: tool.input_schema,
        strict: true,
      }
    }
  });
}

function convertAnthropicToolChoiceToOpenAI(toolChoice: Exclude<AnthropicSendMessagesParams['tool_choice'], undefined>): OpenAISendMessagesParams['tool_choice'] {
  if (toolChoice.type !== 'tool') {
    throw new Error('Only supports forced tool-choice for OpenAI tool_choice!');
  }

  return {
    type: 'function',
    function: {
      name: toolChoice.name
    }
  };
}

function convertAnthropicSystemMessageToOpenAI(system: Exclude<AnthropicSendMessagesParams['system'], undefined>): OpenAISystemMessage {
  return {
    role: 'system',
    content: system
  };
}

export function convertZodParserToAnthropicTool(zodParser: z.ZodType<any>, name: string): PromptCachingBetaTool {
  const jsonSchema = zodToJsonSchema(zodParser, name);
  const inputSchema = jsonSchema.definitions?.[name];
  if (!inputSchema) {
    throw new Error(`Couldn't find tool definition for ${name}!`);
  }

  if (!('type' in inputSchema) || inputSchema.type !== 'object') {
    throw new Error(`Missing 'type' field in input schema for ${name}!`);
  }

  return {
    name,
    input_schema: inputSchema as PromptCachingBetaTool['input_schema'],
    description: zodParser.description
  };
}

export async function sendMessagesToLlm<T extends SendLLMMessagesArgs>(args: T): Promise<SendLLMMessageReturnTypes<T>> {
  if (args.provider === 'openai') {
    const client = await getOpenAI();
    if (!client) {
      throw new Error(`Couldn't get OpenAI Client!`);
    }

    const { maxTokens, model, messages, system, zodParser, name } = args;

    const allMessages = [...messages];
    if (system) {
      allMessages.unshift(convertAnthropicSystemMessageToOpenAI(system));
    }

    if (zodParser) {
      const response = await client.beta.chat.completions.parse({
        model,
        max_tokens: maxTokens,
        messages: allMessages,
        response_format: zodResponseFormat(zodParser, name),
      });

      const [firstContentBlock] = response.choices;

      if (!firstContentBlock) {
        throw new Error('Response from OpenAI has no content blocks!');
      }

      return firstContentBlock.message.parsed as SendLLMMessageReturnTypes<T>;
    }

    const response = await client.beta.chat.completions.parse({
      model,
      max_tokens: maxTokens,
      messages: allMessages,
    });

    const [firstContentBlock] = response.choices;

    if (!firstContentBlock) {
      throw new Error('Response from OpenAI has no content blocks!');
    }

    return firstContentBlock.message.content as SendLLMMessageReturnTypes<T>;
  }
  
  const client = getAnthropicPromptCachingClientOrThrow(args.customApiKey);

  const { maxTokens, messages, model, system, zodParser, name } = args;

  if (zodParser) {
    const tool = convertZodParserToAnthropicTool(zodParser, name);
    const tools = [tool];
    const toolChoice: AnthropicSendMessagesParams['tool_choice'] = { name, type: 'tool' };

    const response = await client.messages.create({
      model,
      max_tokens: maxTokens,
      messages,
      system,
      tools,
      tool_choice: toolChoice,
    });

    const [firstContentBlock] = response.content;

    if (!firstContentBlock) {
      throw new Error('Response from Anthropic has no content blocks!');
    }

    if (firstContentBlock.type !== 'tool_use') {
      throw new Error('Got unexpected non-tool-use response from Anthropic!');
    }

    const responseContent = firstContentBlock.input;
    const validatedTerm = zodParser.safeParse(responseContent);
    if (!validatedTerm.success) {
      throw new Error('Invalid tool use response from Anthropic!');
    }

    return validatedTerm.data as SendLLMMessageReturnTypes<T>;
  }

  const response = await client.messages.create({
    model,
    max_tokens: maxTokens,
    messages,
    system
  });

  const [firstContentBlock] = response.content;

  if (!firstContentBlock) {
    throw new Error('Response from Anthropic has no content blocks!');
  }

  if (firstContentBlock.type !== 'text') {
    throw new Error('Got unexpected tool_use response from Anthropic!');
  }

  return firstContentBlock.text;
}

1	import type { ChatModel as OpenAIModel, ChatCompletionSystemMessageParam as OpenAISystemMessage } from 'openai/resources/chat';	54✔
2	import type { ChatCompletionCreateParamsBase as OpenAISendMessagesParams } from 'openai/resources/chat/completions';
3	import type { Model as AnthropicModel } from '@anthropic-ai/sdk/resources/messages';
4	import type { MessageCreateParamsBase as AnthropicSendMessagesParams, PromptCachingBetaMessageParam as AnthropicMessage, PromptCachingBetaToolUseBlockParam as AnthropicMessageToolUseBlock, PromptCachingBetaToolResultBlockParam as AnthropicMessageToolResultBlock, PromptCachingBetaTextBlockParam as AnthropicMessageTextBlock, PromptCachingBetaTool } from '@anthropic-ai/sdk/resources/beta/prompt-caching/messages';
5
6	import { getOpenAI } from './languageModelIntegration';	18✔
7	import { getAnthropicPromptCachingClientOrThrow } from './anthropicClient';	18✔
8	import { z } from 'zod';
9	import { zodResponseFormat } from 'openai/helpers/zod';	18✔
10	import { zodToJsonSchema } from 'zod-to-json-schema';	18✔
11
12	interface SendToolUseRequest<T> {
13	zodParser: z.ZodType<T>;
14	name: string;
15	}
16
17	interface SendNonToolUseRequest {
18	zodParser?: undefined;
19	name?: undefined;
20	}
21
22	type SendMaybeToolUseRequest<T extends boolean, ZodType> = T extends true
23	? SendToolUseRequest<ZodType>
24	: SendNonToolUseRequest;
25
26	export type SendOpenAIMessages<ToolUse extends boolean = false, ZodType = never> = SendMaybeToolUseRequest<ToolUse, ZodType> & {
27	provider: 'openai';
28	model: OpenAIModel;
29	messages: OpenAISendMessagesParams['messages'];
30	maxTokens: OpenAISendMessagesParams['max_tokens'];
31	system?: AnthropicSendMessagesParams['system'];
32	}
33
34	export type SendAnthropicMessages<ToolUse extends boolean = false, ZodType = never> = SendMaybeToolUseRequest<ToolUse, ZodType> & {
35	provider: 'anthropic';
36	model: AnthropicModel;
37	messages: Array<Omit<AnthropicMessage, 'content'> & { content: string \| (AnthropicMessageTextBlock \| AnthropicMessageToolUseBlock \| AnthropicMessageToolResultBlock)[] }>;
38	maxTokens: AnthropicSendMessagesParams['max_tokens'];
39	system?: AnthropicSendMessagesParams['system'];
40	customApiKey?: string;
41	}
42
43	export type SendLLMMessagesArgs<
44	ToolUse extends boolean = boolean,
45	ZodType = any
46	> = SendOpenAIMessages<ToolUse, ZodType> \| SendAnthropicMessages<ToolUse, ZodType>;
47
48	type SendLLMMessageReturnTypes<T extends SendLLMMessagesArgs> = T['zodParser'] extends undefined ? string : z.infer<Exclude<T['zodParser'], undefined>> \| null;
49
50	function convertAnthropicToolsToOpenAI(tools: Exclude<AnthropicSendMessagesParams['tools'], undefined>): OpenAISendMessagesParams['tools'] {
51	return tools.map(tool => {	×
52	return {	×
53	type: 'function',
54	function: {
55	name: tool.name,
56	description: tool.description,
57	parameters: tool.input_schema,
58	strict: true,
59	}
60	}
61	});
62	}
63
64	function convertAnthropicToolChoiceToOpenAI(toolChoice: Exclude<AnthropicSendMessagesParams['tool_choice'], undefined>): OpenAISendMessagesParams['tool_choice'] {
65	if (toolChoice.type !== 'tool') {	×
66	throw new Error('Only supports forced tool-choice for OpenAI tool_choice!');	×
67	}
68
69	return {	×
70	type: 'function',
71	function: {
72	name: toolChoice.name
73	}
74	};
75	}
76
77	function convertAnthropicSystemMessageToOpenAI(system: Exclude<AnthropicSendMessagesParams['system'], undefined>): OpenAISystemMessage {
78	return {	×
79	role: 'system',
80	content: system
81	};
82	}
83
84	export function convertZodParserToAnthropicTool(zodParser: z.ZodType<any>, name: string): PromptCachingBetaTool {
NEW 85	const jsonSchema = zodToJsonSchema(zodParser, name);	×
NEW 86	const inputSchema = jsonSchema.definitions?.[name];	×
NEW 87	if (!inputSchema) {	×
NEW 88	throw new Error(`Couldn't find tool definition for ${name}!`);	×
89	}
90
NEW 91	if (!('type' in inputSchema) \|\| inputSchema.type !== 'object') {	×
NEW 92	throw new Error(`Missing 'type' field in input schema for ${name}!`);	×
93	}
94
NEW 95	return {	×
96	name,
97	input_schema: inputSchema as PromptCachingBetaTool['input_schema'],
98	description: zodParser.description
99	};
100	}
101
102	export async function sendMessagesToLlm<T extends SendLLMMessagesArgs>(args: T): Promise<SendLLMMessageReturnTypes<T>> {
103	if (args.provider === 'openai') {	×
104	const client = await getOpenAI();	×
105	if (!client) {	×
106	throw new Error(`Couldn't get OpenAI Client!`);	×
107	}
108
NEW 109	const { maxTokens, model, messages, system, zodParser, name } = args;	×
110
111	const allMessages = [...messages];	×
112	if (system) {	×
113	allMessages.unshift(convertAnthropicSystemMessageToOpenAI(system));	×
114	}
115
NEW 116	if (zodParser) {	×
NEW 117	const response = await client.beta.chat.completions.parse({	×
118	model,
119	max_tokens: maxTokens,
120	messages: allMessages,
121	response_format: zodResponseFormat(zodParser, name),
122	});
123
NEW 124	const [firstContentBlock] = response.choices;	×
125
NEW 126	if (!firstContentBlock) {	×
NEW 127	throw new Error('Response from OpenAI has no content blocks!');	×
128	}
129
NEW 130	return firstContentBlock.message.parsed as SendLLMMessageReturnTypes<T>;	×
131	}
132
NEW 133	const response = await client.beta.chat.completions.parse({	×
134	model,
135	max_tokens: maxTokens,
136	messages: allMessages,
137	});
138
139	const [firstContentBlock] = response.choices;	×
140
141	if (!firstContentBlock) {	×
142	throw new Error('Response from OpenAI has no content blocks!');	×
143	}
144
NEW 145	return firstContentBlock.message.content as SendLLMMessageReturnTypes<T>;	×
146	}
147
148	const client = getAnthropicPromptCachingClientOrThrow(args.customApiKey);	×
149
NEW 150	const { maxTokens, messages, model, system, zodParser, name } = args;	×
151
NEW 152	if (zodParser) {	×
NEW 153	const tool = convertZodParserToAnthropicTool(zodParser, name);	×
NEW 154	const tools = [tool];	×
NEW 155	const toolChoice: AnthropicSendMessagesParams['tool_choice'] = { name, type: 'tool' };	×
156
NEW 157	const response = await client.messages.create({	×
158	model,
159	max_tokens: maxTokens,
160	messages,
161	system,
162	tools,
163	tool_choice: toolChoice,
164	});
165
NEW 166	const [firstContentBlock] = response.content;	×
167
NEW 168	if (!firstContentBlock) {	×
NEW 169	throw new Error('Response from Anthropic has no content blocks!');	×
170	}
171
NEW 172	if (firstContentBlock.type !== 'tool_use') {	×
NEW 173	throw new Error('Got unexpected non-tool-use response from Anthropic!');	×
174	}
175
NEW 176	const responseContent = firstContentBlock.input;	×
NEW 177	const validatedTerm = zodParser.safeParse(responseContent);	×
NEW 178	if (!validatedTerm.success) {	×
NEW 179	throw new Error('Invalid tool use response from Anthropic!');	×
180	}
181
NEW 182	return validatedTerm.data as SendLLMMessageReturnTypes<T>;	×
183	}
184
185	const response = await client.messages.create({	×
186	model,
187	max_tokens: maxTokens,
188	messages,
189	system
190	});
191
192	const [firstContentBlock] = response.content;	×
193
194	if (!firstContentBlock) {	×
195	throw new Error('Response from Anthropic has no content blocks!');	×
196	}
197
198	if (firstContentBlock.type !== 'text') {	×
199	throw new Error('Got unexpected tool_use response from Anthropic!');	×
200	}
201
202	return firstContentBlock.text;	×
203	}

ForumMagnum / ForumMagnum / 11601533701

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