@proteinjs/conversation 2.1.3 → 2.1.5

package/src/Conversation.ts

@@ -1,5 +1,5 @@
 import { ChatCompletionMessageParam } from 'openai/resources/chat';
-import { DEFAULT_MODEL, OpenAi } from './OpenAi';
+import { DEFAULT_MODEL, OpenAi, ToolInvocationProgressEvent } from './OpenAi';
 import { MessageHistory } from './history/MessageHistory';
 import { Function } from './Function';
 import { Logger, LogLevel } from '@proteinjs/logger';
@@ -9,6 +9,8 @@ import { ConversationModule } from './ConversationModule';
 import { TiktokenModel, encoding_for_model } from 'tiktoken';
 import { searchLibrariesFunctionName } from './fs/package/PackageFunctions';
 import { UsageData } from './UsageData';
+import type { ModelMessage, LanguageModel } from 'ai';
+import { generateObject as aiGenerateObject, jsonSchema } from 'ai';
 
 export type ConversationParams = {
   name: string;
@@ -21,8 +23,36 @@ export type ConversationParams = {
   };
 };
 
+/** Object-only generation (no tool calls in this run). */
+export type GenerateObjectParams<S> = {
+  /** Same input contract as generateResponse */
+  messages: (string | ChatCompletionMessageParam)[];
+
+  /** A ready AI SDK model, e.g., openai('gpt-5') / openai('gpt-4o') */
+  model: LanguageModel;
+
+  /** Zod schema or JSON Schema */
+  schema: S;
+
+  /** Sampling & limits */
+  temperature?: number;
+  topP?: number;
+  maxTokens?: number;
+
+  /** Usage callback */
+  onUsageData?: (usageData: UsageData) => Promise<void>;
+
+  /** Append final JSON to history as assistant text; default true */
+  recordInHistory?: boolean;
+};
+
+export type GenerateObjectOutcome<T> = {
+  object: T; // validated final object
+  usageData: UsageData;
+};
+
 export class Conversation {
-  private tokenLimit = 3000;
+  private tokenLimit = 50000;
   private history;
   private systemMessages: ChatCompletionMessageParam[] = [];
   private functions: Function[] = [];
@@ -42,7 +72,7 @@ export class Conversation {
     });
     this.logger = new Logger({ name: params.name, logLevel: params.logLevel });
 
-    if (typeof params.limits?.enforceLimits === 'undefined' || params.limits.enforceLimits) {
+    if (params?.limits?.enforceLimits) {
       this.addFunctions('Conversation', [summarizeConversationHistoryFunction(this)]);
     }
 
@@ -137,7 +167,7 @@ export class Conversation {
   }
 
   private async enforceTokenLimit(messages: (string | ChatCompletionMessageParam)[], model?: TiktokenModel) {
-    if (this.params.limits?.enforceLimits === false) {
+    if (!this.params.limits?.enforceLimits) {
       return;
     }
 
@@ -234,9 +264,12 @@ export class Conversation {
   async generateResponse({
     messages,
     model,
+    ...rest
   }: {
     messages: (string | ChatCompletionMessageParam)[];
     model?: TiktokenModel;
+    onUsageData?: (usageData: UsageData) => Promise<void>;
+    onToolInvocation?: (evt: ToolInvocationProgressEvent) => void;
   }) {
     await this.ensureModulesProcessed();
     await this.enforceTokenLimit(messages, model);
@@ -245,7 +278,7 @@ export class Conversation {
       functions: this.functions,
       messageModerators: this.messageModerators,
       logLevel: this.params.logLevel,
-    }).generateResponse({ messages, model });
+    }).generateResponse({ messages, model, ...rest });
   }
 
   async generateStreamingResponse({
@@ -257,6 +290,7 @@ export class Conversation {
     model?: TiktokenModel;
     abortSignal?: AbortSignal;
     onUsageData?: (usageData: UsageData) => Promise<void>;
+    onToolInvocation?: (evt: ToolInvocationProgressEvent) => void;
   }) {
     await this.ensureModulesProcessed();
     await this.enforceTokenLimit(messages, model);
@@ -268,6 +302,278 @@ export class Conversation {
     }).generateStreamingResponse({ messages, model, ...rest });
   }
 
+  /**
+   * Generate a validated JSON object (no tools in this run).
+   * Uses AI SDK `generateObject` which leverages provider-native structured outputs when available.
+   */
+  async generateObject<T>({
+    messages,
+    model,
+    schema,
+    temperature,
+    topP,
+    maxTokens,
+    onUsageData,
+    recordInHistory = true,
+  }: GenerateObjectParams<unknown>): Promise<GenerateObjectOutcome<T>> {
+    await this.ensureModulesProcessed();
+
+    const combined: ModelMessage[] = [
+      ...this.toModelMessages(this.history.getMessages()),
+      ...this.toModelMessages(messages),
+    ];
+
+    // Schema normalization (Zod OR JSON Schema supported)
+    const isZod =
+      schema &&
+      (typeof (schema as any).safeParse === 'function' ||
+        (!!(schema as any)._def && typeof (schema as any)._def.typeName === 'string'));
+    const normalizedSchema = isZod ? (schema as any) : jsonSchema(this.strictifyJsonSchema(schema as any));
+
+    const result = await aiGenerateObject({
+      model,
+      messages: combined,
+      schema: normalizedSchema,
+      providerOptions: {
+        openai: {
+          strictJsonSchema: true,
+        },
+      },
+      maxOutputTokens: maxTokens,
+      temperature,
+      topP,
+      experimental_repairText: async ({ text }: any) => {
+        const cleaned = String(text ?? '')
+          .trim()
+          .replace(/^```(?:json)?/i, '')
+          .replace(/```$/, '');
+        try {
+          JSON.parse(cleaned);
+          return cleaned;
+        } catch {
+          return null;
+        }
+      },
+    } as any);
+
+    // Record user messages to history (parity with other methods)
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map((m) =>
+      typeof m === 'string' ? ({ role: 'user', content: m } as ChatCompletionMessageParam) : m
+    );
+    this.addMessagesToHistory(chatCompletions);
+
+    // Optionally persist the final JSON in history
+    if (recordInHistory) {
+      try {
+        const toRecord = typeof result?.object === 'object' ? JSON.stringify(result.object) : '';
+        if (toRecord) {
+          this.addAssistantMessagesToHistory([toRecord]);
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+
+    const usageData = this.processUsageData({
+      result,
+      model,
+    });
+
+    if (onUsageData) {
+      await onUsageData(usageData);
+    }
+
+    return {
+      object: (result?.object ?? ({} as any)) as T,
+      usageData,
+    };
+  }
+
+  /** Convert (string | ChatCompletionMessageParam)[] -> AI SDK ModelMessage[] */
+  private toModelMessages(input: (string | ChatCompletionMessageParam)[]): ModelMessage[] {
+    return input.map((m) => {
+      if (typeof m === 'string') {
+        return { role: 'user', content: m };
+      }
+      const text = Array.isArray(m.content)
+        ? m.content.map((p: any) => (typeof p === 'string' ? p : p?.text ?? '')).join('\n')
+        : (m.content as string | undefined) ?? '';
+      const role = m.role === 'system' || m.role === 'user' || m.role === 'assistant' ? m.role : 'user';
+      return { role, content: text };
+    });
+  }
+
+  /**
+   * Strictifies a plain JSON Schema for OpenAI Structured Outputs (strict mode):
+   *  - Ensures every object has `additionalProperties: false`
+   *  - Ensures every object has a `required` array that includes **all** keys in `properties`
+   *  - Adds missing `type: "object"` / `type: "array"` where implied by keywords
+   */
+  private strictifyJsonSchema(schema: any): any {
+    const root = JSON.parse(JSON.stringify(schema));
+
+    const visit = (node: any) => {
+      if (!node || typeof node !== 'object') {
+        return;
+      }
+
+      // If keywords imply a type but it's missing, add it (helps downstream validators)
+      if (!node.type) {
+        if (node.properties || node.additionalProperties || node.patternProperties) {
+          node.type = 'object';
+        } else if (node.items || node.prefixItems) {
+          node.type = 'array';
+        }
+      }
+
+      const types = Array.isArray(node.type) ? node.type : node.type ? [node.type] : [];
+
+      // Objects: enforce strict requirements
+      if (types.includes('object')) {
+        // 1) additionalProperties: false
+        if (node.additionalProperties !== false) {
+          node.additionalProperties = false;
+        }
+
+        // 2) required must exist and include every key in properties
+        if (node.properties && typeof node.properties === 'object') {
+          const propKeys = Object.keys(node.properties);
+          const currentReq: string[] = Array.isArray(node.required) ? node.required.slice() : [];
+          const union = Array.from(new Set([...currentReq, ...propKeys]));
+          node.required = union;
+
+          // Recurse into each property schema
+          for (const k of propKeys) {
+            visit(node.properties[k]);
+          }
+        }
+
+        // Recurse into patternProperties
+        if (node.patternProperties && typeof node.patternProperties === 'object') {
+          for (const k of Object.keys(node.patternProperties)) {
+            visit(node.patternProperties[k]);
+          }
+        }
+
+        // Recurse into $defs / definitions
+        for (const defsKey of ['$defs', 'definitions']) {
+          if (node[defsKey] && typeof node[defsKey] === 'object') {
+            for (const key of Object.keys(node[defsKey])) {
+              visit(node[defsKey][key]);
+            }
+          }
+        }
+      }
+
+      // Arrays: recurse into items/prefixItems
+      if (types.includes('array')) {
+        if (node.items) {
+          if (Array.isArray(node.items)) {
+            node.items.forEach(visit);
+          } else {
+            visit(node.items);
+          }
+        }
+        if (Array.isArray(node.prefixItems)) {
+          node.prefixItems.forEach(visit);
+        }
+      }
+
+      // Combinators
+      for (const k of ['oneOf', 'anyOf', 'allOf']) {
+        if (Array.isArray(node[k])) {
+          node[k].forEach(visit);
+        }
+      }
+
+      // Negation
+      if (node.not) {
+        visit(node.not);
+      }
+    };
+
+    visit(root);
+    return root;
+  }
+
+  // ---- Usage + provider metadata normalization ----
+
+  private processUsageData(args: {
+    result: any;
+    model?: LanguageModel;
+    toolCounts?: Map<string, number>;
+    toolLedgerLen?: number;
+  }): UsageData {
+    const { result, model, toolCounts, toolLedgerLen } = args;
+
+    // Try several shapes used by AI SDK / providers
+    const u: any = result?.usage ?? result?.response?.usage ?? result?.response?.metadata?.usage;
+
+    // Provider-specific extras (OpenAI Responses variants)
+    const { cachedInputTokens } = this.extractOpenAiUsageDetails?.(result) ?? {};
+
+    const input = Number.isFinite(u?.inputTokens) ? Number(u.inputTokens) : 0;
+    const output = Number.isFinite(u?.outputTokens) ? Number(u.outputTokens) : 0;
+    const total = Number.isFinite(u?.totalTokens) ? Number(u.totalTokens) : input + output;
+    const cached = Number.isFinite(cachedInputTokens) ? Number(cachedInputTokens) : 0;
+
+    // Resolve model id for pricing/telemetry
+    const modelId: any =
+      (model as any)?.modelId ??
+      result?.response?.providerMetadata?.openai?.model ??
+      result?.providerMetadata?.openai?.model ??
+      result?.response?.model ??
+      undefined;
+
+    const tokenUsage = {
+      promptTokens: input,
+      cachedPromptTokens: cached,
+      completionTokens: output,
+      totalTokens: total,
+    };
+
+    const callsPerTool = toolCounts ? Object.fromEntries(toolCounts) : {};
+    const totalToolCalls =
+      typeof toolLedgerLen === 'number' ? toolLedgerLen : Object.values(callsPerTool).reduce((a, b) => a + (b || 0), 0);
+
+    return {
+      model: modelId,
+      initialRequestTokenUsage: { ...tokenUsage },
+      totalTokenUsage: { ...tokenUsage },
+      totalRequestsToAssistant: 1,
+      totalToolCalls,
+      callsPerTool,
+    };
+  }
+
+  // Pull OpenAI-specific cached/extra usage from provider metadata or raw usage.
+  // Safe across providers; returns undefined if not available.
+  private extractOpenAiUsageDetails(result: any): {
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+  } {
+    try {
+      const md = result?.providerMetadata?.openai ?? result?.response?.providerMetadata?.openai;
+      const usage = md?.usage ?? result?.response?.usage ?? result?.usage;
+
+      // OpenAI Responses API has used different shapes over time; try both:
+      const cachedInputTokens =
+        usage?.input_tokens_details?.cached_tokens ??
+        usage?.prompt_tokens_details?.cached_tokens ??
+        usage?.cached_input_tokens;
+
+      // Reasoning tokens (when available on reasoning models)
+      const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens ?? usage?.reasoning_tokens;
+
+      return {
+        cachedInputTokens: typeof cachedInputTokens === 'number' ? cachedInputTokens : undefined,
+        reasoningTokens: typeof reasoningTokens === 'number' ? reasoningTokens : undefined,
+      };
+    } catch {
+      return {};
+    }
+  }
+
   async generateCode({ description, model }: { description: string[]; model?: TiktokenModel }) {
     this.logger.debug({ message: `Generating code`, obj: { description } });
     await this.ensureModulesProcessed();

package/src/OpenAi.ts

@@ -22,14 +22,44 @@ function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/** Structured capture of each tool call during a single generateResponse loop. */
+export type ToolInvocationResult = {
+  id: string; // tool_call_id from the model
+  name: string; // function name invoked
+  startedAt: Date;
+  finishedAt: Date;
+  input: unknown; // parsed JSON args (or raw string if parse failed)
+  ok: boolean;
+  data?: unknown; // tool return value (JSON-serializable)
+  error?: { message: string; stack?: string };
+};
+
+/** Realtime progress hook for tool calls. */
+export type ToolInvocationProgressEvent =
+  | {
+      type: 'started';
+      id: string;
+      name: string;
+      startedAt: Date;
+      input: unknown;
+    }
+  | {
+      type: 'finished';
+      result: ToolInvocationResult;
+    };
+
 export type GenerateResponseParams = {
   messages: (string | ChatCompletionMessageParam)[];
   model?: TiktokenModel;
+  /** Optional realtime hook for tool-call lifecycle (started/finished). */
+  onToolInvocation?: (evt: ToolInvocationProgressEvent) => void;
 };
 
 export type GenerateResponseReturn = {
   message: string;
   usagedata: UsageData;
+  /** Structured ledger of tool calls executed while producing this message. */
+  toolInvocations: ToolInvocationResult[];
 };
 
 export type GenerateStreamingResponseParams = GenerateResponseParams & {
@@ -42,6 +72,8 @@ type GenerateResponseHelperParams = GenerateStreamingResponseParams & {
   stream: boolean;
   currentFunctionCalls?: number;
   usageDataAccumulator?: UsageDataAccumulator;
+  /** Accumulated across recursive tool loops. */
+  toolInvocations?: ToolInvocationResult[];
 };
 
 export type OpenAiParams = {
@@ -53,7 +85,7 @@ export type OpenAiParams = {
   logLevel?: LogLevel;
 };
 
-export const DEFAULT_MODEL: TiktokenModel = 'gpt-3.5-turbo';
+export const DEFAULT_MODEL: TiktokenModel = 'gpt-4o';
 export const DEFAULT_MAX_FUNCTION_CALLS = 50;
 
 export class OpenAi {
@@ -77,7 +109,7 @@ export class OpenAi {
     this.functions = functions;
     this.messageModerators = messageModerators;
     this.maxFunctionCalls = maxFunctionCalls;
-    this.logLevel = logLevel;
+    this.logLevel = (process.env.PROTEINJS_CONVERSATION_OPENAI_LOG_LEVEL as LogLevel | undefined) ?? logLevel;
   }
 
   async generateResponse({ model, ...rest }: GenerateResponseParams): Promise<GenerateResponseReturn> {
@@ -85,11 +117,17 @@ export class OpenAi {
       model: model ?? this.model,
       stream: false,
       ...rest,
+      toolInvocations: [],
     })) as GenerateResponseReturn;
   }
 
   async generateStreamingResponse({ model, ...rest }: GenerateStreamingResponseParams): Promise<Readable> {
-    return (await this.generateResponseHelper({ model: model ?? this.model, stream: true, ...rest })) as Readable;
+    return (await this.generateResponseHelper({
+      model: model ?? this.model,
+      stream: true,
+      ...rest,
+      toolInvocations: [],
+    })) as Readable;
   }
 
   private async generateResponseHelper({
@@ -98,8 +136,10 @@ export class OpenAi {
     stream,
     abortSignal,
     onUsageData,
+    onToolInvocation,
     usageDataAccumulator,
     currentFunctionCalls = 0,
+    toolInvocations = [],
   }: GenerateResponseHelperParams): Promise<GenerateResponseReturn | Readable> {
     const logger = new Logger({ name: 'OpenAi.generateResponseHelper', logLevel: this.logLevel });
     this.updateMessageHistory(messages);
@@ -130,7 +170,9 @@ export class OpenAi {
             currentFunctionCalls,
             resolvedUsageDataAccumulator,
             abortSignal,
-            onUsageData
+            onUsageData,
+            toolInvocations,
+            onToolInvocation
           )) as (toolCalls: ChatCompletionMessageToolCall[], currentFunctionCalls: number) => Promise<Readable>;
         const streamProcessor = new OpenAiStreamProcessor(
           inputStream,
@@ -152,7 +194,9 @@ export class OpenAi {
           currentFunctionCalls,
           resolvedUsageDataAccumulator,
           abortSignal,
-          onUsageData
+          onUsageData,
+          toolInvocations,
+          onToolInvocation
         );
       }
 
@@ -162,7 +206,7 @@ export class OpenAi {
       }
 
       this.history.push([responseMessage]);
-      return { message: responseText, usagedata: resolvedUsageDataAccumulator.usageData };
+      return { message: responseText, usagedata: resolvedUsageDataAccumulator.usageData, toolInvocations };
     };
 
     // Only wrap in context if this is the first call
@@ -208,7 +252,6 @@ export class OpenAi {
       const response = await openaiApi.chat.completions.create(
         {
           model,
-          temperature: 0,
           messages: this.history.getMessages(),
           ...(this.functions &&
             this.functions.length > 0 && {
@@ -310,7 +353,9 @@ export class OpenAi {
     currentFunctionCalls: number,
     usageDataAccumulator: UsageDataAccumulator,
     abortSignal?: AbortSignal,
-    onUsageData?: (usageData: UsageData) => Promise<void>
+    onUsageData?: (usageData: UsageData) => Promise<void>,
+    toolInvocations: ToolInvocationResult[] = [],
+    onToolInvocation?: (evt: ToolInvocationProgressEvent) => void
   ): Promise<GenerateResponseReturn | Readable> {
     if (currentFunctionCalls >= this.maxFunctionCalls) {
       throw new Error(`Max function calls (${this.maxFunctionCalls}) reached. Stopping execution.`);
@@ -327,7 +372,7 @@ export class OpenAi {
     this.history.push([toolCallMessage]);
 
     // Call the tools and get the responses
-    const toolMessageParams = await this.callTools(toolCalls, usageDataAccumulator);
+    const toolMessageParams = await this.callTools(toolCalls, usageDataAccumulator, toolInvocations, onToolInvocation);
 
     // Add the tool responses to the history
     this.history.push(toolMessageParams);
@@ -339,18 +384,31 @@ export class OpenAi {
       stream,
       abortSignal,
       onUsageData,
+      onToolInvocation,
       usageDataAccumulator,
       currentFunctionCalls: currentFunctionCalls + toolCalls.length,
+      toolInvocations,
     });
   }
 
   private async callTools(
     toolCalls: ChatCompletionMessageToolCall[],
-    usageDataAccumulator: UsageDataAccumulator
+    usageDataAccumulator: UsageDataAccumulator,
+    toolInvocations: ToolInvocationResult[],
+    onToolInvocation?: (evt: ToolInvocationProgressEvent) => void
   ): Promise<ChatCompletionMessageParam[]> {
     const toolMessageParams: ChatCompletionMessageParam[] = (
       await Promise.all(
-        toolCalls.map(async (toolCall) => await this.callFunction(toolCall.function, toolCall.id, usageDataAccumulator))
+        toolCalls.map(
+          async (toolCall) =>
+            await this.callFunction(
+              toolCall.function,
+              toolCall.id,
+              usageDataAccumulator,
+              toolInvocations,
+              onToolInvocation
+            )
+        )
       )
     ).reduce((acc, val) => acc.concat(val), []);
 
@@ -360,7 +418,9 @@ export class OpenAi {
   private async callFunction(
     functionCall: ChatCompletionMessageToolCall.Function,
     toolCallId: string,
-    usageDataAccumulator: UsageDataAccumulator
+    usageDataAccumulator: UsageDataAccumulator,
+    toolInvocations: ToolInvocationResult[],
+    onToolInvocation?: (evt: ToolInvocationProgressEvent) => void
   ): Promise<ChatCompletionMessageParam[]> {
     const logger = new Logger({ name: 'OpenAi.callFunction', logLevel: this.logLevel });
     if (!this.functions) {
@@ -370,7 +430,7 @@ export class OpenAi {
     }
 
     functionCall.name = functionCall.name.split('.').pop() as string;
-    const f = this.functions.find((f) => f.definition.name === functionCall.name);
+    const f = this.functions.find((fx) => fx.definition.name === functionCall.name);
     if (!f) {
       const errorMessage = `Assistant attempted to call nonexistent function`;
       logger.error({ message: errorMessage, obj: { functionName: functionCall.name } });
@@ -390,7 +450,33 @@ export class OpenAi {
         obj: { toolCallId, functionName: f.definition.name, args: parsedArguments },
       });
       usageDataAccumulator.recordToolCall(f.definition.name);
+
+      const startedAt = new Date();
+
+      onToolInvocation?.({
+        type: 'started',
+        id: toolCallId,
+        name: f.definition.name,
+        startedAt,
+        input: parsedArguments,
+      });
+
       const returnObject = await f.call(parsedArguments);
+      const finishedAt = new Date();
+
+      // Record success
+      const rec: ToolInvocationResult = {
+        id: toolCallId,
+        name: f.definition.name,
+        startedAt,
+        finishedAt,
+        input: parsedArguments,
+        ok: true,
+        data: returnObject,
+      };
+      toolInvocations.push(rec);
+
+      onToolInvocation?.({ type: 'finished', result: rec });
 
       const returnObjectCompletionParams: ChatCompletionMessageParam[] = [];
       if (isInstanceOf(returnObject, ChatCompletionMessageParamFactory)) {
@@ -433,11 +519,35 @@ export class OpenAi {
 
       return returnObjectCompletionParams;
     } catch (error: any) {
+      const now = new Date();
+      const attemptedArgs = (() => {
+        try {
+          return JSON.parse(functionCall.arguments);
+        } catch {
+          return functionCall.arguments;
+        }
+      })();
+
+      // Record failure
+      const rec: ToolInvocationResult = {
+        id: toolCallId,
+        name: functionCall.name,
+        startedAt: now,
+        finishedAt: now,
+        input: attemptedArgs,
+        ok: false,
+        error: { message: String(error?.message ?? error), stack: (error as any)?.stack },
+      };
+      toolInvocations.push(rec);
+
+      onToolInvocation?.({ type: 'finished', result: rec });
+
       logger.error({
         message: `An error occurred while executing function`,
         error,
         obj: { toolCallId, functionName: f.definition.name },
       });
+
       throw error;
     }
   }

package/src/fs/conversation_fs/ConversationFsModule.ts

@@ -6,7 +6,8 @@ import { ConversationFsModerator } from './ConversationFsModerator';
 import {
   fsFunctions,
   getRecentlyAccessedFilePathsFunction,
-  getRecentlyAccessedFilePathsFunctionName,
+  grepFunction,
+  grepFunctionName,
   readFilesFunction,
   readFilesFunctionName,
   writeFilesFunction,
@@ -36,7 +37,7 @@ export class ConversationFsModule implements ConversationModule {
       `When reading/writing a file in a specified package, join the package directory with the relative path to form the file path`,
       `When searching for source files, do not look in the dist or node_modules directories`,
       `If you don't know a file path, don't try to guess it, use the ${searchFilesFunctionName} function to find it`,
-      `When searching for something (ie. a file to work with/in), unless more context is specified, use the ${searchLibrariesFunctionName} function first, then fall back to functions: ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+      `When searching for something (ie. a file to work with/in), unless more context is specified, use the ${grepFunctionName} function first, then fall back to functions: ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
       `After finding a file to work with, assume the user's following question pertains to that file and use ${readFilesFunctionName} to read the file if needed`,
     ];
   }
@@ -46,6 +47,7 @@ export class ConversationFsModule implements ConversationModule {
       readFilesFunction(this),
       writeFilesFunction(this),
       getRecentlyAccessedFilePathsFunction(this),
+      grepFunction(this),
       ...fsFunctions,
     ];
   }
@@ -61,6 +63,10 @@ export class ConversationFsModule implements ConversationModule {
   getRecentlyAccessedFilePaths() {
     return this.recentlyAccessedFilePaths;
   }
+
+  getRepoPath(): string {
+    return this.repoPath;
+  }
 }
 
 export class ConversationFsModuleFactory implements ConversationModuleFactory {